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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double sqrt(double);
void r_mvndrh2(int *m0, double *w, double *x, double *rhmat, int *j0, int *k0,
               int *nsim, double *eps, int *ifail, double *drh) {
  double der, tem, pr, sd, rh, r1, rjm, rjm1;
  double rr[20][20], a[20], b[20], rc[20][20], dd[20];
  double mu11[20], mu12[20], mu21[20], mu22[20], ac[20], bc[20];
  int i, j, m1, k, temi, m2, ii, m, j1, k1;
  void mvn2(int, double[], double[], double[][20], int, double, double *,
            double *, int *);
  double phi2(double, double, double);
  m = *m0;
  j1 = *j0;
  k1 = *k0;
  if (j1 > k1) {
    temi = j1, j1 = k1;
    k1 = temi;
  }
  for (i = 1, ii = 0; i <= m; i++) {
    for (j = 1; j <= m; j++) {
      rr[i][j] = rhmat[ii];
      ii++;
    }
    a[i] = w[i - 1];
    b[i] = x[i - 1];
  }
  m1 = m - 1;
  m2 = m - 2;
  if (m == 2) {
    rh = rr[1][2];
    der = phi2(a[1], a[2], rh);
    der -= phi2(a[1], b[2], rh);
    der -= phi2(b[1], a[2], rh);
    der += phi2(b[1], b[2], rh);
    *drh = der;
  }
  if (k1 == m) {
    if (j1 < m1) {
      for (i = 1; i <= m; i++) {
        tem = rr[i][m1];
        rr[i][m1] = rr[i][j1];
        rr[i][j1] = tem;
      }
      for (i = 1; i <= m; i++) {
        tem = rr[m1][i];
        rr[m1][i] = rr[j1][i];
        rr[j1][i] = tem;
      }
      tem = a[m1];
      a[m1] = a[j1];
      a[j1] = tem;
      tem = b[m1];
      b[m1] = b[j1];
      b[j1] = tem;
    }
  } else if (k1 == m1) {
    for (i = 1; i <= m; i++) {
      tem = rr[i][m];
      rr[i][m] = rr[i][j1];
      rr[i][j1] = tem;
    }
    for (i = 1; i <= m; i++) {
      tem = rr[m][i];
      rr[m][i] = rr[j1][i];
      rr[j1][i] = tem;
    }
    tem = a[m];
    a[m] = a[j1];
    a[j1] = tem;
    tem = b[m];
    b[m] = b[j1];
    b[j1] = tem;
  } else {
    for (i = 1; i <= m; i++) {
      tem = rr[i][m1];
      rr[i][m1] = rr[i][j1];
      rr[i][j1] = tem;
    }
    for (i = 1; i <= m; i++) {
      tem = rr[m1][i];
      rr[m1][i] = rr[j1][i];
      rr[j1][i] = tem;
    }
    tem = a[m1];
    a[m1] = a[j1];
    a[j1] = tem;
    tem = b[m1];
    b[m1] = b[j1];
    b[j1] = tem;
    for (i = 1; i <= m; i++) {
      tem = rr[i][m];
      rr[i][m] = rr[i][k1];
      rr[i][k1] = tem;
    }
    for (i = 1; i <= m; i++) {
      tem = rr[m][i];
      rr[m][i] = rr[k1][i];
      rr[k1][i] = tem;
    }
    tem = a[m];
    a[m] = a[k1];
    a[k1] = tem;
    tem = b[m];
    b[m] = b[k1];
    b[k1] = tem;
  }
  rh = rr[m1][m];
  r1 = 1. / (1. - rh * rh);
  for (j = 1; j <= m2; j++) {
    rjm = rr[j][m];
    rjm1 = rr[j][m1];
    for (k = 1; k <= m2; k++) {
      rr[j][k] -= r1 * (rjm1 * rr[m1][k] + rjm * rr[m][k] -
                        rh * rjm1 * rr[m][k] - rh * rjm * rr[m1][k]);
    }
    mu11[j] =
        r1 * (rjm1 * a[m1] + rjm * a[m] - rh * rjm1 * a[m] - rh * rjm * a[m1]);
    mu12[j] =
        r1 * (rjm1 * a[m1] + rjm * b[m] - rh * rjm1 * b[m] - rh * rjm * a[m1]);
    mu21[j] =
        r1 * (rjm1 * b[m1] + rjm * a[m] - rh * rjm1 * a[m] - rh * rjm * b[m1]);
    mu22[j] =
        r1 * (rjm1 * b[m1] + rjm * b[m] - rh * rjm1 * b[m] - rh * rjm * b[m1]);
  }
  for (j = 1; j <= m2; j++) {
    dd[j] = sqrt(rr[j][j]);
    ac[j] = (a[j] - mu11[j]) / dd[j];
    bc[j] = (b[j] - mu11[j]) / dd[j];
  }
  for (j = 1; j <= m2; j++) {
    for (k = 1; k <= m2; k++)
      rc[j][k] = rr[j][k] / (dd[j] * dd[k]);
  }
  der = 0.;
  if (a[m1] > -6. && a[m] > -6.) {
    mvn2(m2, ac, bc, rc, *nsim, *eps, &pr, &sd, ifail);
    der += phi2(a[m1], a[m], rh) * pr;
  }
  for (j = 1; j <= m2; j++) {
    ac[j] = (a[j] - mu12[j]) / dd[j];
    bc[j] = (b[j] - mu12[j]) / dd[j];
  }
  if (a[m1] > -6. && b[m] < 6.) {
    mvn2(m2, ac, bc, rc, *nsim, *eps, &pr, &sd, ifail);
    der -= phi2(a[m1], b[m], rh) * pr;
  }
  for (j = 1; j <= m2; j++) {
    ac[j] = (a[j] - mu21[j]) / dd[j];
    bc[j] = (b[j] - mu21[j]) / dd[j];
  }
  if (a[m] > -6. && b[m1] < 6.) {
    mvn2(m2, ac, bc, rc, *nsim, *eps, &pr, &sd, ifail);
    der -= phi2(b[m1], a[m], rh) * pr;
  }
  for (j = 1; j <= m2; j++) {
    ac[j] = (a[j] - mu22[j]) / dd[j];
    bc[j] = (b[j] - mu22[j]) / dd[j];
  }
  if (b[m] < 6. && b[m1] < 6.) {
    mvn2(m2, ac, bc, rc, *nsim, *eps, &pr, &sd, ifail);
    der += phi2(b[m1], b[m], rh) * pr;
  }
  *drh = der;
}


x86 assembly (clang, -O0):
<r_mvndrh2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f50,%rsp
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)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f34(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f38(%rbp)
mov    -0x1f34(%rbp),%eax
cmp    -0x1f38(%rbp),%eax
jle    11bd <r_mvndrh2+0x8d>
mov    -0x1f34(%rbp),%eax
mov    %eax,-0x1f24(%rbp)
mov    -0x1f38(%rbp),%eax
mov    %eax,-0x1f34(%rbp)
mov    -0x1f24(%rbp),%eax
mov    %eax,-0x1f38(%rbp)
movl   $0x1,-0x1f14(%rbp)
movl   $0x0,-0x1f2c(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     12b4 <r_mvndrh2+0x184>
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     1256 <r_mvndrh2+0x126>
mov    -0x20(%rbp),%rax
movslq -0x1f2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f2c(%rbp)
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    11ed <r_mvndrh2+0xbd>
mov    -0x10(%rbp),%rax
mov    -0x1f14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
mov    -0x1f14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    11d1 <r_mvndrh2+0xa1>
mov    -0x1f30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1f1c(%rbp)
mov    -0x1f30(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1f28(%rbp)
cmpl   $0x2,-0x1f30(%rbp)
jne    1392 <r_mvndrh2+0x262>
movsd  -0xc40(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0xd88(%rbp),%xmm0
ff
movsd  -0xd80(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0xd88(%rbp),%xmm0
ff
movsd  -0xe20(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movaps %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0xe28(%rbp),%xmm0
ff
movsd  -0xd80(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movaps %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0xe28(%rbp),%xmm0
ff
movsd  -0xe20(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x1f38(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jne    15e3 <r_mvndrh2+0x4b3>
mov    -0x1f34(%rbp),%eax
cmp    -0x1f1c(%rbp),%eax
jge    15de <r_mvndrh2+0x4ae>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     1480 <r_mvndrh2+0x350>
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    13c0 <r_mvndrh2+0x290>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     154a <r_mvndrh2+0x41a>
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    148a <r_mvndrh2+0x35a>
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
jmp    1c77 <r_mvndrh2+0xb47>
mov    -0x1f38(%rbp),%eax
cmp    -0x1f1c(%rbp),%eax
jne    1822 <r_mvndrh2+0x6f2>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     16bf <r_mvndrh2+0x58f>
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    15ff <r_mvndrh2+0x4cf>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     1789 <r_mvndrh2+0x659>
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    16c9 <r_mvndrh2+0x599>
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
jmp    1c72 <r_mvndrh2+0xb42>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     18ec <r_mvndrh2+0x7bc>
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    182c <r_mvndrh2+0x6fc>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     19b6 <r_mvndrh2+0x886>
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    18f6 <r_mvndrh2+0x7c6>
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f34(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f1c(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f34(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     1b14 <r_mvndrh2+0x9e4>
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f14(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    1a54 <r_mvndrh2+0x924>
movl   $0x1,-0x1f14(%rbp)
mov    -0x1f14(%rbp),%eax
cmp    -0x1f30(%rbp),%eax
jg     1bde <r_mvndrh2+0xaae>
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f38(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movslq -0x1f38(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f14(%rbp)
jmp    1b1e <r_mvndrh2+0x9ee>
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f38(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f38(%rbp),%rax
movsd  %xmm0,-0xd90(%rbp,%rax,8)
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x40(%rbp)
movslq -0x1f38(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
movslq -0x1f38(%rbp),%rax
movsd  %xmm0,-0xe30(%rbp,%rax,8)
ff ff
jmp    1c77 <r_mvndrh2+0xb47>
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x1333(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x1327(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     21c9 <r_mvndrh2+0x1099>
movslq -0x1f18(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movslq -0x1f18(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x1f20(%rbp)
mov    -0x1f20(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     1ec1 <r_mvndrh2+0xd91>
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x68(%rbp),%xmm1
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movslq -0x1f30(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movslq -0x1f1c(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movslq -0x1f18(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f20(%rbp)
jmp    1d5a <r_mvndrh2+0xc2a>
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
ff ff
movsd  -0x68(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
mulsd  -0xd90(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1bf0(%rbp,%rax,8)
ff ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
ff ff
movsd  -0x68(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
mulsd  -0xe30(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1c90(%rbp,%rax,8)
ff ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movsd  -0x68(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
mulsd  -0xd90(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1d30(%rbp,%rax,8)
ff ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movsd  -0x68(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
mulsd  -0xe30(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm3
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1dd0(%rbp,%rax,8)
ff ff
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    1cec <r_mvndrh2+0xbbc>
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     22b2 <r_mvndrh2+0x1182>
movslq -0x1f18(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sqrt@plt>
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1b50(%rbp,%rax,8)
ff ff
movslq -0x1f18(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1bf0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1e70(%rbp,%rax,8)
ff ff
movslq -0x1f18(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1bf0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    21d3 <r_mvndrh2+0x10a3>
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     2383 <r_mvndrh2+0x1253>
movl   $0x1,-0x1f20(%rbp)
mov    -0x1f20(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     236a <r_mvndrh2+0x123a>
movslq -0x1f18(%rbp),%rcx
lea    -0xcf0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1f18(%rbp),%rax
movsd  -0x1b50(%rbp,%rax,8),%xmm1
ff ff
movslq -0x1f20(%rbp),%rax
mulsd  -0x1b50(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movslq -0x1f18(%rbp),%rcx
lea    -0x1ab0(%rbp),%rax
imul   $0xa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1f20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f20(%rbp)
jmp    22d8 <r_mvndrh2+0x11a8>
jmp    236f <r_mvndrh2+0x123f>
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    22bc <r_mvndrh2+0x118c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  0xc65(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2454 <r_mvndrh2+0x1324>
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  0xc43(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2454 <r_mvndrh2+0x1324>
mov    -0x1f28(%rbp),%edi
lea    -0x1e70(%rbp),%rsi
lea    -0x1f10(%rbp),%rdx
lea    -0x1ab0(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    (%rax),%r8d
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
lea    -0x48(%rbp),%r9
lea    -0x50(%rbp),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <mvn2@plt>
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movsd  -0x48(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     2504 <r_mvndrh2+0x13d4>
movslq -0x1f18(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1c90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1e70(%rbp,%rax,8)
ff ff
movslq -0x1f18(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1c90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    245e <r_mvndrh2+0x132e>
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  0xaec(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    25e0 <r_mvndrh2+0x14b0>
movslq -0x1f30(%rbp),%rax
movsd  0xadb(%rip),%xmm0
ucomisd -0xe30(%rbp,%rax,8),%xmm0
ff ff
jbe    25e0 <r_mvndrh2+0x14b0>
mov    -0x1f28(%rbp),%edi
lea    -0x1e70(%rbp),%rsi
lea    -0x1f10(%rbp),%rdx
lea    -0x1ab0(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    (%rax),%r8d
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
lea    -0x48(%rbp),%r9
lea    -0x50(%rbp),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <mvn2@plt>
movslq -0x1f1c(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movsd  -0x48(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     2690 <r_mvndrh2+0x1560>
movslq -0x1f18(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1d30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1e70(%rbp,%rax,8)
ff ff
movslq -0x1f18(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1d30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    25ea <r_mvndrh2+0x14ba>
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movsd  0x960(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    276c <r_mvndrh2+0x163c>
movslq -0x1f1c(%rbp),%rax
movsd  0x94f(%rip),%xmm0
ucomisd -0xe30(%rbp,%rax,8),%xmm0
ff ff
jbe    276c <r_mvndrh2+0x163c>
mov    -0x1f28(%rbp),%edi
lea    -0x1e70(%rbp),%rsi
lea    -0x1f10(%rbp),%rdx
lea    -0x1ab0(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    (%rax),%r8d
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
lea    -0x48(%rbp),%r9
lea    -0x50(%rbp),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <mvn2@plt>
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movsd  -0x48(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x1f18(%rbp)
mov    -0x1f18(%rbp),%eax
cmp    -0x1f28(%rbp),%eax
jg     281c <r_mvndrh2+0x16ec>
movslq -0x1f18(%rbp),%rax
movsd  -0xd90(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1dd0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1e70(%rbp,%rax,8)
ff ff
movslq -0x1f18(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
subsd  -0x1dd0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
divsd  -0x1b50(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f18(%rbp),%rax
movsd  %xmm0,-0x1f10(%rbp,%rax,8)
ff ff
mov    -0x1f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f18(%rbp)
jmp    2776 <r_mvndrh2+0x1646>
movslq -0x1f30(%rbp),%rax
movsd  0x7e5(%rip),%xmm0
ucomisd -0xe30(%rbp,%rax,8),%xmm0
ff ff
jbe    28dd <r_mvndrh2+0x17ad>
movslq -0x1f1c(%rbp),%rax
movsd  0x7c7(%rip),%xmm0
ucomisd -0xe30(%rbp,%rax,8),%xmm0
ff ff
jbe    28dd <r_mvndrh2+0x17ad>
mov    -0x1f28(%rbp),%edi
lea    -0x1e70(%rbp),%rsi
lea    -0x1f10(%rbp),%rdx
lea    -0x1ab0(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    (%rax),%r8d
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
lea    -0x48(%rbp),%r9
lea    -0x50(%rbp),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <mvn2@plt>
movslq -0x1f1c(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1f30(%rbp),%rax
movsd  -0xe30(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x58(%rbp),%xmm2
call   1040 <phi2@plt>
movsd  -0x48(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x1f50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<r_mvndrh2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f38,%rsp
movslq (%rdi),%r10
mov    (%r8),%eax
mov    (%r9),%r13d
cmp    %r13d,%eax
mov    %eax,%r8d
cmovg  %r13d,%r8d
cmovg  %eax,%r13d
mov    %r10d,%r15d
mov    %r10,%rbx
test   %r10,%r10
mov    %r10,0x8(%rsp)
mov    %r15,0x50(%rsp)
jle    11ea <r_mvndrh2+0xaa>
mov    %rdx,%r14
mov    %rcx,0x10(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r8d,0x60(%rsp)
mov    %r13d,0x80(%rsp)
mov    %r15,%rbp
lea    0x0(,%r15,8),%rbx
add    $0xffffffff,%r15d
lea    0x138(%rsp),%rdi
mov    %rbx,%rdx
call   1030 <memcpy@plt>
lea    0x98(%rsp),%rdi
mov    %r14,%rsi
mov    %rbx,%r12
mov    %rbx,%rdx
call   1030 <memcpy@plt>
cmp    $0x1,%ebp
mov    %r15,0x30(%rsp)
mov    %rbx,0x18(%rsp)
jne    13d5 <r_mvndrh2+0x295>
xor    %r14d,%r14d
xor    %r13d,%r13d
jmp    145a <r_mvndrh2+0x31a>
lea    -0x1(%rbx),%r12d
lea    -0x2(%r10),%eax
mov    %eax,0x24(%rsp)
cmp    %r15d,%r13d
je     1599 <r_mvndrh2+0x459>
cmp    %r12d,%r13d
jne    1773 <r_mvndrh2+0x633>
test   %r15d,%r15d
jle    1943 <r_mvndrh2+0x803>
movslq %r8d,%rax
lea    0x1(%r15),%r14
mov    $0x1,%edx
cmp    $0x2,%r14d
je     1295 <r_mvndrh2+0x155>
lea    0x450(%rsp),%rsi
mov    %r15d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%edx
nopl   0x0(%rax)
movsd  (%rsi,%r15,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%r15,8)
movsd  %xmm0,(%rsi,%rax,8)
movsd  0xa0(%rsi,%r15,8),%xmm0
movsd  0xa0(%rsi,%rax,8),%xmm1
movsd  %xmm1,0xa0(%rsi,%r15,8)
movsd  %xmm0,0xa0(%rsi,%rax,8)
add    $0x140,%rsi
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
jne    1240 <r_mvndrh2+0x100>
test   $0x1,%r15b
je     12c3 <r_mvndrh2+0x183>
lea    (%rdx,%rdx,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b0,%rdx
movsd  (%rdx,%r15,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%r15,8)
movsd  %xmm0,(%rdx,%rax,8)
test   %ebx,%ebx
jle    1943 <r_mvndrh2+0x803>
lea    -0x1(%r14),%r10
mov    $0x1,%edx
cmp    $0x4,%r10
jb     19b0 <r_mvndrh2+0x870>
lea    (%r15,%r15,4),%rbx
shl    $0x5,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x3b8,%rdi
lea    (%rsp,%rbx,1),%r8
add    $0x3b0,%r8
lea    (%rax,%rax,4),%rsi
shl    $0x5,%rsi
lea    (%rsp,%rsi,1),%r9
add    $0x3b0,%r9
lea    (%r9,%r14,8),%rbp
cmp    %rbp,%rdi
jae    1330 <r_mvndrh2+0x1f0>
lea    (%r8,%r14,8),%rdi
lea    (%rsp,%rsi,1),%rbp
add    $0x3b8,%rbp
cmp    %rdi,%rbp
jb     19b0 <r_mvndrh2+0x870>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     1956 <r_mvndrh2+0x816>
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
add    %rsp,%rsi
add    $0x3e8,%rsi
lea    (%rsp,%rbx,1),%rbp
add    $0x3e8,%rbp
xor    %ebx,%ebx
nopl   (%rax)
movups -0x30(%rbp,%rbx,8),%xmm0
movups -0x20(%rbp,%rbx,8),%xmm1
movups -0x30(%rsi,%rbx,8),%xmm2
movups -0x20(%rsi,%rbx,8),%xmm3
movups %xmm2,-0x30(%rbp,%rbx,8)
movups %xmm3,-0x20(%rbp,%rbx,8)
movups %xmm0,-0x30(%rsi,%rbx,8)
movups %xmm1,-0x20(%rsi,%rbx,8)
movupd -0x10(%rbp,%rbx,8),%xmm0
movupd 0x0(%rbp,%rbx,8),%xmm1
movupd -0x10(%rsi,%rbx,8),%xmm2
movupd (%rsi,%rbx,8),%xmm3
movupd %xmm2,-0x10(%rbp,%rbx,8)
movupd %xmm3,0x0(%rbp,%rbx,8)
movupd %xmm0,-0x10(%rsi,%rbx,8)
movupd %xmm1,(%rsi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1370 <r_mvndrh2+0x230>
jmp    1958 <r_mvndrh2+0x818>
mov    %r15,%rbx
lea    0x1(%r15),%rax
mov    %rax,0x48(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0x40(%rsp)
lea    0x4f8(%rsp),%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
mov    0x18(%rsp),%r15
mov    0x48(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0xa0(%rbx),%rdi
movslq %r13d,%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    %r12d,%ebp
add    $0x2,%r14
movslq %ebp,%r13
mov    0x10(%rsp),%rax
lea    (%rax,%r13,8),%rsi
mov    %rbx,%rdi
mov    %r15,%rdx
call   1030 <memcpy@plt>
add    %r12,%r13
add    $0x140,%rbx
cmp    %r14,0x40(%rsp)
jne    1410 <r_mvndrh2+0x2d0>
testb  $0x1,0x50(%rsp)
mov    0x18(%rsp),%rdx
je     1492 <r_mvndrh2+0x352>
lea    (%r14,%r14,4),%rax
shl    $0x5,%rax
lea    0x3b0(%rsp),%rcx
lea    (%rax,%rcx,1),%rdi
add    $0xa8,%rdi
movslq %r13d,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
call   1030 <memcpy@plt>
mov    0x50(%rsp),%r15
cmp    $0x2,%r15d
mov    0x30(%rsp),%r12
jne    1571 <r_mvndrh2+0x431>
movsd  0x460(%rsp),%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  0x138(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x140(%rsp),%xmm1
movsd  %xmm1,0x40(%rsp)
call   1050 <phi2@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0xa0(%rsp),%xmm1
movsd  %xmm1,0x48(%rsp)
movsd  0x38(%rsp),%xmm0
movsd  0x18(%rsp),%xmm2
call   1050 <phi2@plt>
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x40(%rsp),%xmm1
movsd  0x18(%rsp),%xmm2
call   1050 <phi2@plt>
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x38(%rsp),%xmm0
movsd  0x48(%rsp),%xmm1
movsd  0x18(%rsp),%xmm2
call   1050 <phi2@plt>
addsd  0x10(%rsp),%xmm0
mov    0x1f88(%rsp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,0x24(%rsp)
jmp    1579 <r_mvndrh2+0x439>
lea    -0x2(%r15),%eax
mov    %eax,0x24(%rsp)
mov    0x8(%rsp),%r10
mov    0x80(%rsp),%r13d
mov    0x60(%rsp),%r8d
mov    0x58(%rsp),%rbx
cmp    %r15d,%r13d
jne    11ff <r_mvndrh2+0xbf>
cmp    %r12d,%r8d
jge    2091 <r_mvndrh2+0xf51>
test   %r15d,%r15d
jle    194b <r_mvndrh2+0x80b>
movslq %r12d,%rax
movslq %r8d,%rcx
lea    0x1(%r15),%r14
mov    $0x1,%esi
cmp    $0x2,%r14d
je     1631 <r_mvndrh2+0x4f1>
lea    0x450(%rsp),%rdx
mov    %r15d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0xa0(%rdx,%rax,8),%xmm0
movsd  0xa0(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0xa0(%rdx,%rax,8)
movsd  %xmm0,0xa0(%rdx,%rcx,8)
add    $0x140,%rdx
lea    (%rdi,%rsi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    15e0 <r_mvndrh2+0x4a0>
test   $0x1,%r15b
je     165d <r_mvndrh2+0x51d>
lea    (%rsi,%rsi,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b0,%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
test   %r15d,%r15d
jle    194b <r_mvndrh2+0x80b>
lea    -0x1(%r14),%r10
mov    $0x1,%esi
cmp    $0x4,%r10
jb     1b07 <r_mvndrh2+0x9c7>
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x3b8,%rdi
lea    (%rsp,%rbp,1),%r8
add    $0x3b0,%r8
lea    (%rcx,%rcx,4),%rdx
shl    $0x5,%rdx
lea    (%rsp,%rdx,1),%r9
add    $0x3b0,%r9
lea    (%r9,%r14,8),%rbx
cmp    %rbx,%rdi
jae    16cb <r_mvndrh2+0x58b>
lea    (%r8,%r14,8),%rdi
lea    (%rsp,%rdx,1),%rbx
add    $0x3b8,%rbx
cmp    %rdi,%rbx
jb     1b07 <r_mvndrh2+0x9c7>
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
lea    -0x4(%rsi),%rdi
mov    %rdi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     1aac <r_mvndrh2+0x96c>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsp,%rdx,1),%rdi
add    $0x3e8,%rdi
lea    (%rsp,%rbp,1),%rdx
add    $0x3e8,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x30(%rdx,%rbp,8),%xmm0
movups -0x20(%rdx,%rbp,8),%xmm1
movups -0x30(%rdi,%rbp,8),%xmm2
movups -0x20(%rdi,%rbp,8),%xmm3
movups %xmm2,-0x30(%rdx,%rbp,8)
movups %xmm3,-0x20(%rdx,%rbp,8)
movups %xmm0,-0x30(%rdi,%rbp,8)
movups %xmm1,-0x20(%rdi,%rbp,8)
movupd -0x10(%rdx,%rbp,8),%xmm0
movupd (%rdx,%rbp,8),%xmm1
movupd -0x10(%rdi,%rbp,8),%xmm2
movupd (%rdi,%rbp,8),%xmm3
movupd %xmm2,-0x10(%rdx,%rbp,8)
movupd %xmm3,(%rdx,%rbp,8)
movupd %xmm0,-0x10(%rdi,%rbp,8)
movupd %xmm1,(%rdi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1710 <r_mvndrh2+0x5d0>
jmp    1aae <r_mvndrh2+0x96e>
movslq %r12d,%rax
movslq %r8d,%rcx
test   %r15d,%r15d
jle    1d15 <r_mvndrh2+0xbd5>
lea    0x1(%r15),%r14
mov    $0x1,%esi
cmp    $0x2,%r14d
je     1801 <r_mvndrh2+0x6c1>
lea    0x450(%rsp),%rdx
mov    %r15d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0xa0(%rdx,%rax,8),%xmm0
movsd  0xa0(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0xa0(%rdx,%rax,8)
movsd  %xmm0,0xa0(%rdx,%rcx,8)
add    $0x140,%rdx
lea    (%rdi,%rsi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    17b0 <r_mvndrh2+0x670>
test   $0x1,%r15b
je     182d <r_mvndrh2+0x6ed>
lea    (%rsi,%rsi,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b0,%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
test   %r15d,%r15d
jle    1d15 <r_mvndrh2+0xbd5>
lea    -0x1(%r14),%r10
mov    $0x1,%esi
cmp    $0x4,%r10
jb     1c5d <r_mvndrh2+0xb1d>
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x3b8,%rdi
lea    (%rsp,%rbp,1),%r8
add    $0x3b0,%r8
lea    (%rcx,%rcx,4),%rdx
shl    $0x5,%rdx
lea    (%rsp,%rdx,1),%r9
add    $0x3b0,%r9
lea    (%r9,%r14,8),%rbx
cmp    %rbx,%rdi
jae    189b <r_mvndrh2+0x75b>
lea    (%r8,%r14,8),%rdi
lea    (%rsp,%rdx,1),%rbx
add    $0x3b8,%rbx
cmp    %rdi,%rbx
jb     1c5d <r_mvndrh2+0xb1d>
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
lea    -0x4(%rsi),%rdi
mov    %rdi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     1c02 <r_mvndrh2+0xac2>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsp,%rdx,1),%rdi
add    $0x3e8,%rdi
lea    (%rsp,%rbp,1),%rdx
add    $0x3e8,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x30(%rdx,%rbp,8),%xmm0
movups -0x20(%rdx,%rbp,8),%xmm1
movups -0x30(%rdi,%rbp,8),%xmm2
movups -0x20(%rdi,%rbp,8),%xmm3
movups %xmm2,-0x30(%rdx,%rbp,8)
movups %xmm3,-0x20(%rdx,%rbp,8)
movups %xmm0,-0x30(%rdi,%rbp,8)
movups %xmm1,-0x20(%rdi,%rbp,8)
movupd -0x10(%rdx,%rbp,8),%xmm0
movupd (%rdx,%rbp,8),%xmm1
movupd -0x10(%rdi,%rbp,8),%xmm2
movupd (%rdi,%rbp,8),%xmm3
movupd %xmm2,-0x10(%rdx,%rbp,8)
movupd %xmm3,(%rdx,%rbp,8)
movupd %xmm0,-0x10(%rdi,%rbp,8)
movupd %xmm1,(%rdi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    18e0 <r_mvndrh2+0x7a0>
jmp    1c04 <r_mvndrh2+0xac4>
movslq %r8d,%rax
jmp    1a68 <r_mvndrh2+0x928>
movslq %r12d,%rax
movslq %r8d,%rcx
jmp    1bb5 <r_mvndrh2+0xa75>
xor    %ebx,%ebx
test   $0x1,%r11b
je     199a <r_mvndrh2+0x85a>
shl    $0x3,%rbx
or     $0x8,%rbx
movupd (%rbx,%r8,1),%xmm0
movupd 0x10(%rbx,%r8,1),%xmm1
movupd (%rbx,%r9,1),%xmm2
movupd 0x10(%rbx,%r9,1),%xmm3
movupd %xmm2,(%rbx,%r8,1)
movupd %xmm3,0x10(%rbx,%r8,1)
movupd %xmm0,(%rbx,%r9,1)
movupd %xmm1,0x10(%rbx,%r9,1)
cmp    %rdx,%r10
jne    19ac <r_mvndrh2+0x86c>
mov    %r15,%rbx
mov    0x8(%rsp),%r10
jmp    1a68 <r_mvndrh2+0x928>
or     $0x1,%rdx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r14b
jne    19fa <r_mvndrh2+0x8ba>
lea    (%r15,%r15,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b0,%rdi
movsd  (%rdi,%rdx,8),%xmm0
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x3b0,%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
movsd  %xmm0,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
mov    0x8(%rsp),%r10
add    %r14,%rsi
je     1a65 <r_mvndrh2+0x925>
lea    (%r15,%r15,4),%rsi
shl    $0x5,%rsi
add    %rsp,%rsi
add    $0x3b8,%rsi
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b8,%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  -0x8(%rdi,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
movsd  %xmm0,-0x8(%rdi,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r14
jne    1a30 <r_mvndrh2+0x8f0>
mov    %r15,%rbx
movsd  0x130(%rsp,%rbx,8),%xmm0
movsd  0x130(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x130(%rsp,%rbx,8)
movsd  %xmm0,0x130(%rsp,%rax,8)
movsd  0x90(%rsp,%rbx,8),%xmm0
movsd  0x90(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x90(%rsp,%rbx,8)
jmp    2088 <r_mvndrh2+0xf48>
xor    %ebp,%ebp
test   $0x1,%r11b
je     1af4 <r_mvndrh2+0x9b4>
shl    $0x3,%rbp
or     $0x8,%rbp
movupd 0x0(%rbp,%r8,1),%xmm0
movupd 0x10(%rbp,%r8,1),%xmm1
movupd 0x0(%rbp,%r9,1),%xmm2
movupd 0x10(%rbp,%r9,1),%xmm3
movupd %xmm2,0x0(%rbp,%r8,1)
movupd %xmm3,0x10(%rbp,%r8,1)
movupd %xmm0,0x0(%rbp,%r9,1)
movupd %xmm1,0x10(%rbp,%r9,1)
cmp    %rsi,%r10
jne    1b03 <r_mvndrh2+0x9c3>
mov    0x8(%rsp),%r10
jmp    1bb5 <r_mvndrh2+0xa75>
or     $0x1,%rsi
mov    %rsi,%rdx
not    %rdx
test   $0x1,%r14b
jne    1b51 <r_mvndrh2+0xa11>
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b0,%rdi
movsd  (%rdi,%rsi,8),%xmm0
lea    (%rcx,%rcx,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x3b0,%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
mov    0x8(%rsp),%r10
add    %r14,%rdx
je     1bb5 <r_mvndrh2+0xa75>
lea    (%rax,%rax,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b8,%rdx
lea    (%rcx,%rcx,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b8,%rdi
nop
movsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rsi,8)
movsd  %xmm0,-0x8(%rdi,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm0
movsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r14
jne    1b80 <r_mvndrh2+0xa40>
movsd  0x130(%rsp,%rax,8),%xmm0
movsd  0x130(%rsp,%rcx,8),%xmm1
movsd  %xmm1,0x130(%rsp,%rax,8)
movsd  %xmm0,0x130(%rsp,%rcx,8)
movsd  0x90(%rsp,%rax,8),%xmm0
movsd  0x90(%rsp,%rcx,8),%xmm1
movsd  %xmm1,0x90(%rsp,%rax,8)
movsd  %xmm0,0x90(%rsp,%rcx,8)
jmp    2091 <r_mvndrh2+0xf51>
xor    %ebp,%ebp
test   $0x1,%r11b
je     1c4a <r_mvndrh2+0xb0a>
shl    $0x3,%rbp
or     $0x8,%rbp
movupd 0x0(%rbp,%r8,1),%xmm0
movupd 0x10(%rbp,%r8,1),%xmm1
movupd 0x0(%rbp,%r9,1),%xmm2
movupd 0x10(%rbp,%r9,1),%xmm3
movupd %xmm2,0x0(%rbp,%r8,1)
movupd %xmm3,0x10(%rbp,%r8,1)
movupd %xmm0,0x0(%rbp,%r9,1)
movupd %xmm1,0x10(%rbp,%r9,1)
cmp    %rsi,%r10
jne    1c59 <r_mvndrh2+0xb19>
mov    0x8(%rsp),%r10
jmp    1d15 <r_mvndrh2+0xbd5>
or     $0x1,%rsi
mov    %rsi,%rdx
not    %rdx
test   $0x1,%r14b
jne    1ca7 <r_mvndrh2+0xb67>
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b0,%rdi
movsd  (%rdi,%rsi,8),%xmm0
lea    (%rcx,%rcx,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x3b0,%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
mov    0x8(%rsp),%r10
add    %r14,%rdx
je     1d15 <r_mvndrh2+0xbd5>
lea    (%rax,%rax,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b8,%rdx
lea    (%rcx,%rcx,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rsi,8)
movsd  %xmm0,-0x8(%rdi,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm0
movsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r14
jne    1ce0 <r_mvndrh2+0xba0>
movsd  0x130(%rsp,%rax,8),%xmm0
movsd  0x130(%rsp,%rcx,8),%xmm1
movsd  %xmm1,0x130(%rsp,%rax,8)
movsd  %xmm0,0x130(%rsp,%rcx,8)
movsd  0x90(%rsp,%rax,8),%xmm0
movsd  0x90(%rsp,%rcx,8),%xmm1
movsd  %xmm1,0x90(%rsp,%rax,8)
movsd  %xmm0,0x90(%rsp,%rcx,8)
movslq %r13d,%rax
test   %r15d,%r15d
jle    1f2c <r_mvndrh2+0xdec>
lea    0x1(%r15),%rcx
mov    $0x1,%edx
cmp    $0x2,%ecx
je     1de5 <r_mvndrh2+0xca5>
lea    0x450(%rsp),%rsi
mov    %r15d,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%edx
nopl   (%rax)
movsd  (%rsi,%r15,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%r15,8)
movsd  %xmm0,(%rsi,%rax,8)
movsd  0xa0(%rsi,%r15,8),%xmm0
movsd  0xa0(%rsi,%rax,8),%xmm1
movsd  %xmm1,0xa0(%rsi,%r15,8)
movsd  %xmm0,0xa0(%rsi,%rax,8)
add    $0x140,%rsi
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
jne    1d90 <r_mvndrh2+0xc50>
test   $0x1,%r15b
je     1e13 <r_mvndrh2+0xcd3>
lea    (%rdx,%rdx,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b0,%rdx
movsd  (%rdx,%r15,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%r15,8)
movsd  %xmm0,(%rdx,%rax,8)
test   %r15d,%r15d
jle    1f2c <r_mvndrh2+0xdec>
mov    %r10d,%r11d
lea    -0x1(%rcx),%r9
mov    $0x1,%esi
cmp    $0x4,%r9
jb     1f94 <r_mvndrh2+0xe54>
lea    (%r15,%r15,4),%rdi
shl    $0x5,%rdi
lea    (%rsp,%rdi,1),%rbp
add    $0x3b8,%rbp
lea    (%rax,%rax,4),%rdx
shl    $0x5,%rdx
lea    (%rsp,%rdx,1),%r8
add    $0x3b0,%r8
lea    (%r8,%rcx,8),%rbx
cmp    %rbx,%rbp
jae    1e83 <r_mvndrh2+0xd43>
add    %rsp,%rdi
add    $0x3b0,%rdi
lea    (%rdi,%rcx,8),%rdi
lea    (%rsp,%rdx,1),%rbp
add    $0x3b8,%rbp
cmp    %rdi,%rbp
jb     1f94 <r_mvndrh2+0xe54>
mov    %r9,%rsi
and    $0xfffffffffffffffc,%rsi
lea    -0x4(%rsi),%rdi
mov    %rdi,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rdi,%rdi
je     1f34 <r_mvndrh2+0xdf4>
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rsp,%rdx,1),%rdi
add    $0x3e8,%rdi
lea    (%r11,%r11,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3e8,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rbx,8),%xmm0
movups -0x20(%rdx,%rbx,8),%xmm1
movups -0x30(%rdi,%rbx,8),%xmm2
movups -0x20(%rdi,%rbx,8),%xmm3
movups %xmm2,-0x30(%rdx,%rbx,8)
movups %xmm3,-0x20(%rdx,%rbx,8)
movups %xmm0,-0x30(%rdi,%rbx,8)
movups %xmm1,-0x20(%rdi,%rbx,8)
movups -0x10(%rdx,%rbx,8),%xmm0
movups (%rdx,%rbx,8),%xmm1
movupd -0x10(%rdi,%rbx,8),%xmm2
movupd (%rdi,%rbx,8),%xmm3
movupd %xmm2,-0x10(%rdx,%rbx,8)
movupd %xmm3,(%rdx,%rbx,8)
movups %xmm0,-0x10(%rdi,%rbx,8)
movups %xmm1,(%rdi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1ed0 <r_mvndrh2+0xd90>
jmp    1f36 <r_mvndrh2+0xdf6>
mov    %r10,%r11
jmp    2045 <r_mvndrh2+0xf05>
xor    %ebx,%ebx
test   $0x1,%r10b
je     1f82 <r_mvndrh2+0xe42>
shl    $0x3,%rbx
or     $0x8,%rbx
lea    (%r11,%r11,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b0,%rdx
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movupd (%rbx,%r8,1),%xmm2
movupd 0x10(%rbx,%r8,1),%xmm3
movupd %xmm2,(%rbx,%rdx,1)
movupd %xmm3,0x10(%rbx,%rdx,1)
movups %xmm0,(%rbx,%r8,1)
movups %xmm1,0x10(%rbx,%r8,1)
cmp    %rsi,%r9
mov    0x8(%rsp),%r10
je     2045 <r_mvndrh2+0xf05>
or     $0x1,%rsi
mov    %rsi,%rdx
not    %rdx
test   $0x1,%cl
jne    1fdd <r_mvndrh2+0xe9d>
lea    (%r11,%r11,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b0,%rdi
movsd  (%rdi,%rsi,8),%xmm0
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
add    %rsp,%rbp
add    $0x3b0,%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  %xmm0,0x0(%rbp,%rsi,8)
add    $0x1,%rsi
add    %rcx,%rdx
je     2045 <r_mvndrh2+0xf05>
lea    (%r11,%r11,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x3b8,%rdx
lea    (%rax,%rax,4),%rdi
shl    $0x5,%rdi
add    %rsp,%rdi
add    $0x3b8,%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rsi,8)
movsd  %xmm0,-0x8(%rdi,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm0
movsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    2010 <r_mvndrh2+0xed0>
movsd  0x130(%rsp,%r11,8),%xmm0
movsd  0x130(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x130(%rsp,%r11,8)
movsd  %xmm0,0x130(%rsp,%rax,8)
movsd  0x90(%rsp,%r11,8),%xmm0
movsd  0x90(%rsp,%rax,8),%xmm1
movsd  %xmm1,0x90(%rsp,%r11,8)
movsd  %xmm0,0x90(%rsp,%rax,8)
mov    %r12,0x30(%rsp)
movslq %r12d,%rax
mov    %rax,0x18(%rsp)
lea    (%rax,%rax,4),%rcx
shl    $0x5,%rcx
lea    (%rsp,%rcx,1),%rax
add    $0x3b0,%rax
movsd  (%rax,%r10,8),%xmm0
movapd %xmm0,0x70(%rsp)
cmp    $0x3,%r15d
jl     24cf <r_mvndrh2+0x138f>
movapd 0xf31(%rip),%xmm9
movapd 0x70(%rsp),%xmm0
xorpd  %xmm0,%xmm9
mulsd  %xmm0,%xmm0
movsd  0xf29(%rip),%xmm13
movapd %xmm13,%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm13
movapd 0xf02(%rip),%xmm15
xorpd  %xmm13,%xmm15
mov    0x18(%rsp),%r10
movsd  0x130(%rsp,%r10,8),%xmm10
mov    0x8(%rsp),%r9
movsd  0x130(%rsp,%r9,8),%xmm11
movsd  0x90(%rsp,%r9,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x90(%rsp,%r10,8),%xmm12
mov    0x30(%rsp),%ebp
lea    0x3b8(%rsp,%rcx,1),%r11
lea    (%rax,%rbp,8),%rcx
mov    %rcx,0x48(%rsp)
lea    (%r9,%r9,4),%rcx
shl    $0x5,%rcx
lea    (%rsp,%rcx,1),%rsi
add    $0x3b8,%rsi
lea    -0x8(%rsi,%rbp,8),%rcx
mov    %rcx,0x40(%rsp)
lea    -0x1(%rbp),%r14
mov    %r14,%r12
and    $0xfffffffffffffffe,%r12
mov    %r14,%rcx
or     $0x1,%rcx
mov    %rcx,0x38(%rsp)
pshufd $0x44,%xmm15,%xmm14
lea    0x458(%rsp),%rdx
lea    0x450(%rsp),%rdi
mov    $0x1,%r13d
movapd %xmm9,0x80(%rsp)
movsd  %xmm10,0x60(%rsp)
movsd  %xmm11,0x58(%rsp)
jmp    228a <r_mvndrh2+0x114a>
nopl   (%rax)
movapd %xmm5,%xmm6
mulsd  %xmm11,%xmm6
movapd %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movapd %xmm1,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm4,%xmm8
mulsd  %xmm11,%xmm8
addsd  %xmm8,%xmm2
movapd %xmm3,%xmm7
mulsd  %xmm10,%xmm7
addsd  %xmm7,%xmm2
mulsd  %xmm13,%xmm2
movsd  %xmm2,0x1210(%rsp,%r13,8)
movsd  0x10(%rsp),%xmm2
mulsd  %xmm2,%xmm5
addsd  %xmm5,%xmm1
mulsd  %xmm2,%xmm4
addsd  %xmm4,%xmm1
addsd  %xmm7,%xmm1
mulsd  %xmm13,%xmm1
movsd  %xmm1,0x1170(%rsp,%r13,8)
mulsd  %xmm12,%xmm0
addsd  %xmm0,%xmm6
addsd  %xmm8,%xmm6
mulsd  %xmm12,%xmm3
addsd  %xmm3,%xmm6
mulsd  %xmm13,%xmm6
movsd  %xmm6,0x10d0(%rsp,%r13,8)
addsd  %xmm5,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm13,%xmm0
movsd  %xmm0,0x1030(%rsp,%r13,8)
add    $0x1,%r13
add    $0xa0,%rdx
add    $0xa0,%rdi
cmp    %rbp,%r13
je     2420 <r_mvndrh2+0x12e0>
lea    0x0(,%r13,4),%rbx
add    %r13,%rbx
shl    $0x5,%rbx
lea    (%rsp,%rbx,1),%r8
add    $0x3b0,%r8
movsd  (%r8,%r9,8),%xmm5
movsd  (%r8,%r10,8),%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm5,%xmm3
mulsd  %xmm9,%xmm3
mov    $0x1,%ecx
cmp    $0x2,%r14
jae    2320 <r_mvndrh2+0x11e0>
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x8(%rsi,%rcx,8),%xmm2
movapd %xmm5,%xmm6
mulsd  %xmm2,%xmm6
movapd %xmm0,%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm6,%xmm7
mulsd  %xmm4,%xmm2
addsd  %xmm7,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm15,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    22d0 <r_mvndrh2+0x1190>
jmp    21c0 <r_mvndrh2+0x1080>
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rcx
add    $0x3b8,%rcx
lea    (%r8,%rbp,8),%rbx
cmp    0x48(%rsp),%rcx
setb   %r9b
cmp    %rbx,%r11
setb   %r10b
cmp    0x40(%rsp),%rcx
setb   %r15b
cmp    %rbx,%rsi
setb   %r8b
mov    $0x1,%ecx
test   %r10b,%r9b
mov    0x18(%rsp),%r10
mov    0x8(%rsp),%r9
jne    22d0 <r_mvndrh2+0x1190>
mov    $0x1,%ecx
and    %r8b,%r15b
jne    22d0 <r_mvndrh2+0x1190>
movapd %xmm5,%xmm10
unpcklpd %xmm5,%xmm10
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
movapd %xmm4,%xmm7
unpcklpd %xmm4,%xmm7
movapd %xmm3,%xmm2
unpcklpd %xmm3,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd (%r11,%rcx,8),%xmm8
movupd (%rsi,%rcx,8),%xmm9
movapd %xmm10,%xmm6
mulpd  %xmm9,%xmm6
movapd %xmm11,%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm6,%xmm1
mulpd  %xmm7,%xmm9
addpd  %xmm1,%xmm9
mulpd  %xmm2,%xmm8
addpd  %xmm9,%xmm8
mulpd  %xmm14,%xmm8
movupd (%rdx,%rcx,8),%xmm1
addpd  %xmm8,%xmm1
movupd %xmm1,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    23a0 <r_mvndrh2+0x1260>
mov    0x38(%rsp),%rcx
cmp    %r12,%r14
movapd 0x80(%rsp),%xmm9
movsd  0x60(%rsp),%xmm10
movsd  0x58(%rsp),%xmm11
jne    22d0 <r_mvndrh2+0x1190>
jmp    21c0 <r_mvndrh2+0x1080>
cmp    $0x3,%r9d
mov    0x50(%rsp),%r15
jl     24cf <r_mvndrh2+0x138f>
lea    0x458(%rsp),%r13
mov    $0x1,%ebx
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%rax
jmp    24b4 <r_mvndrh2+0x1374>
nopw   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%rax
movsd  %xmm0,0x1d0(%rsp,%rbx,8)
movsd  0x130(%rsp,%rbx,8),%xmm1
movsd  0x1210(%rsp,%rbx,8),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x310(%rsp,%rbx,8)
movsd  0x90(%rsp,%rbx,8),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x270(%rsp,%rbx,8)
add    $0x1,%rbx
add    $0xa8,%r13
cmp    %rbx,%rbp
je     24c6 <r_mvndrh2+0x1386>
movsd  0x0(%r13),%xmm0
ucomisd %xmm3,%xmm0
jb     2450 <r_mvndrh2+0x1310>
sqrtsd %xmm0,%xmm0
jmp    245e <r_mvndrh2+0x131e>
cmp    $0x3,%eax
jge    2acf <r_mvndrh2+0x198f>
mov    0x1f80(%rsp),%r13
mov    0x1f78(%rsp),%r12
mov    0x1f70(%rsp),%r14
mov    0x18(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm0
xorpd  %xmm3,%xmm3
ucomisd 0xb17(%rip),%xmm0
jbe    2597 <r_mvndrh2+0x1457>
mov    0x8(%rsp),%r10
movsd  0x130(%rsp,%r10,8),%xmm0
ucomisd 0xafa(%rip),%xmm0
jbe    259c <r_mvndrh2+0x145c>
mov    (%r14),%r8d
movsd  (%r12),%xmm0
lea    0x68(%rsp),%rax
lea    0x310(%rsp),%rsi
lea    0x270(%rsp),%rdx
lea    0x12b0(%rsp),%rcx
lea    0x28(%rsp),%r9
mov    0x24(%rsp),%edi
push   %r13
push   %rax
call   1040 <mvn2@plt>
add    $0x10,%rsp
mov    0x18(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm0
mov    0x8(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm1
movapd 0x70(%rsp),%xmm2
call   1050 <phi2@plt>
mov    0x8(%rsp),%r10
mulsd  0x28(%rsp),%xmm0
xorpd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
jmp    259c <r_mvndrh2+0x145c>
mov    0x8(%rsp),%r10
cmp    $0x3,%r15d
jl     26a8 <r_mvndrh2+0x1568>
mov    0x30(%rsp),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%r8d
cmp    $0x2,%rdx
jb     2628 <r_mvndrh2+0x14e8>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rdx,%r8
or     $0x1,%r8
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x138(%rsp,%rcx,8),%xmm0
movupd 0x1178(%rsp,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
movupd 0x1d8(%rsp,%rcx,8),%xmm2
divpd  %xmm2,%xmm0
movupd %xmm0,0x318(%rsp,%rcx,8)
movupd 0x98(%rsp,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x278(%rsp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    25d0 <r_mvndrh2+0x1490>
cmp    %rsi,%rdx
je     26a8 <r_mvndrh2+0x1568>
lea    (%rsp,%r8,8),%rdx
add    $0x270,%rdx
lea    0x90(%rsp,%r8,8),%rsi
lea    0x310(%rsp,%r8,8),%rdi
lea    (%rsp,%r8,8),%rbp
add    $0x1d0,%rbp
lea    (%rsp,%r8,8),%rbx
add    $0x1170,%rbx
lea    (%rsp,%r8,8),%rcx
add    $0x130,%rcx
sub    %r8,%r9
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rcx,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    2670 <r_mvndrh2+0x1530>
mov    0x18(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm0
ucomisd 0x95a(%rip),%xmm0
jbe    2755 <r_mvndrh2+0x1615>
movsd  0x954(%rip),%xmm0
ucomisd 0x90(%rsp,%r10,8),%xmm0
jbe    2755 <r_mvndrh2+0x1615>
mov    (%r14),%r8d
movsd  (%r12),%xmm0
lea    0x68(%rsp),%rax
lea    0x310(%rsp),%rsi
lea    0x270(%rsp),%rdx
lea    0x12b0(%rsp),%rcx
lea    0x28(%rsp),%r9
mov    0x24(%rsp),%edi
push   %r13
push   %rax
movsd  %xmm3,0x20(%rsp)
call   1040 <mvn2@plt>
add    $0x10,%rsp
mov    0x18(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm0
mov    0x8(%rsp),%rax
movsd  0x90(%rsp,%rax,8),%xmm1
movapd 0x70(%rsp),%xmm2
call   1050 <phi2@plt>
movsd  0x10(%rsp),%xmm3
mov    0x8(%rsp),%r10
mulsd  0x28(%rsp),%xmm0
subsd  %xmm0,%xmm3
cmp    $0x3,%r15d
jl     2868 <r_mvndrh2+0x1728>
mov    0x30(%rsp),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%r8d
cmp    $0x2,%rdx
jb     27e8 <r_mvndrh2+0x16a8>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rdx,%r8
or     $0x1,%r8
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x138(%rsp,%rcx,8),%xmm0
movupd 0x10d8(%rsp,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
movupd 0x1d8(%rsp,%rcx,8),%xmm2
divpd  %xmm2,%xmm0
movupd %xmm0,0x318(%rsp,%rcx,8)
movupd 0x98(%rsp,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x278(%rsp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    2790 <r_mvndrh2+0x1650>
cmp    %rsi,%rdx
je     2868 <r_mvndrh2+0x1728>
lea    (%rsp,%r8,8),%rdx
add    $0x270,%rdx
lea    0x90(%rsp,%r8,8),%rsi
lea    0x310(%rsp,%r8,8),%rdi
lea    (%rsp,%r8,8),%rbp
add    $0x1d0,%rbp
lea    (%rsp,%r8,8),%rbx
add    $0x10d0,%rbx
lea    (%rsp,%r8,8),%rcx
add    $0x130,%rcx
sub    %r8,%r9
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rcx,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    2830 <r_mvndrh2+0x16f0>
movsd  0x130(%rsp,%r10,8),%xmm0
ucomisd 0x79e(%rip),%xmm0
jbe    2910 <r_mvndrh2+0x17d0>
movsd  0x798(%rip),%xmm0
mov    0x18(%rsp),%rbx
ucomisd 0x90(%rsp,%rbx,8),%xmm0
jbe    2910 <r_mvndrh2+0x17d0>
mov    (%r14),%r8d
movsd  (%r12),%xmm0
lea    0x68(%rsp),%rax
lea    0x310(%rsp),%rsi
lea    0x270(%rsp),%rdx
lea    0x12b0(%rsp),%rcx
lea    0x28(%rsp),%r9
mov    0x24(%rsp),%edi
push   %r13
push   %rax
movsd  %xmm3,0x20(%rsp)
call   1040 <mvn2@plt>
add    $0x10,%rsp
movsd  0x90(%rsp,%rbx,8),%xmm0
mov    0x8(%rsp),%rax
movsd  0x130(%rsp,%rax,8),%xmm1
movapd 0x70(%rsp),%xmm2
call   1050 <phi2@plt>
movsd  0x10(%rsp),%xmm3
mov    0x8(%rsp),%r10
mulsd  0x28(%rsp),%xmm0
subsd  %xmm0,%xmm3
cmp    $0x3,%r15d
jl     2a18 <r_mvndrh2+0x18d8>
mov    0x30(%rsp),%r9d
lea    -0x1(%r9),%rdx
mov    $0x1,%r8d
cmp    $0x2,%rdx
jb     2998 <r_mvndrh2+0x1858>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rdx,%r8
or     $0x1,%r8
xor    %ecx,%ecx
nop
movupd 0x138(%rsp,%rcx,8),%xmm0
movupd 0x1038(%rsp,%rcx,8),%xmm1
subpd  %xmm1,%xmm0
movupd 0x1d8(%rsp,%rcx,8),%xmm2
divpd  %xmm2,%xmm0
movupd %xmm0,0x318(%rsp,%rcx,8)
movupd 0x98(%rsp,%rcx,8),%xmm0
subpd  %xmm1,%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x278(%rsp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    2940 <r_mvndrh2+0x1800>
cmp    %rsi,%rdx
je     2a18 <r_mvndrh2+0x18d8>
lea    (%rsp,%r8,8),%rdx
add    $0x270,%rdx
lea    0x90(%rsp,%r8,8),%rsi
lea    0x310(%rsp,%r8,8),%rdi
lea    (%rsp,%r8,8),%rbp
add    $0x1d0,%rbp
lea    (%rsp,%r8,8),%rbx
add    $0x1030,%rbx
lea    (%rsp,%r8,8),%rcx
add    $0x130,%rcx
sub    %r8,%r9
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rcx,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    29e0 <r_mvndrh2+0x18a0>
movsd  0x600(%rip),%xmm0
ucomisd 0x90(%rsp,%r10,8),%xmm0
jbe    2ab1 <r_mvndrh2+0x1971>
mov    0x18(%rsp),%rbp
ucomisd 0x90(%rsp,%rbp,8),%xmm0
jbe    2ab1 <r_mvndrh2+0x1971>
mov    (%r14),%r8d
movsd  (%r12),%xmm0
lea    0x68(%rsp),%rax
lea    0x310(%rsp),%rsi
lea    0x270(%rsp),%rdx
lea    0x12b0(%rsp),%rcx
lea    0x28(%rsp),%r9
mov    0x24(%rsp),%edi
push   %r13
push   %rax
mov    %r10,%rbx
movsd  %xmm3,0x20(%rsp)
call   1040 <mvn2@plt>
add    $0x10,%rsp
movsd  0x90(%rsp,%rbp,8),%xmm0
movsd  0x90(%rsp,%rbx,8),%xmm1
movapd 0x70(%rsp),%xmm2
call   1050 <phi2@plt>
movsd  0x10(%rsp),%xmm3
mulsd  0x28(%rsp),%xmm0
addsd  %xmm0,%xmm3
mov    0x1f88(%rsp),%rax
movsd  %xmm3,(%rax)
add    $0x1f38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x3(%rbp),%r9
mov    %r9,%r11
shr    %r11
add    $0x1,%r11
mov    %r14,%r10
or     $0x1,%r10
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
lea    0x1368(%rsp),%rdi
lea    0x1350(%rsp),%rbx
lea    0x468(%rsp),%rsi
lea    0x450(%rsp),%rax
mov    $0x1,%r13d
jmp    2b48 <r_mvndrh2+0x1a08>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
add    $0xa0,%rdi
add    $0xa0,%rsi
add    $0xa0,%rax
add    $0xa0,%rbx
cmp    %rbp,%r13
je     24cf <r_mvndrh2+0x138f>
movsd  0x1d0(%rsp,%r13,8),%xmm0
mov    $0x1,%ecx
cmp    $0x2,%r14
jb     2c30 <r_mvndrh2+0x1af0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0x2,%r9
jae    2b80 <r_mvndrh2+0x1a40>
xor    %ecx,%ecx
jmp    2bd2 <r_mvndrh2+0x1a92>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rsi,%rcx,8),%xmm2
movupd 0x1d8(%rsp,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,-0x10(%rdi,%rcx,8)
movupd (%rsi,%rcx,8),%xmm2
movupd 0x1e8(%rsp,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
divpd  %xmm3,%xmm2
movupd %xmm2,(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2b90 <r_mvndrh2+0x1a50>
test   $0x1,%r11b
je     2c21 <r_mvndrh2+0x1ae1>
shl    $0x3,%rcx
or     $0x8,%rcx
mov    %r13,%rdx
shl    $0x5,%rdx
lea    (%rdx,%rdx,4),%r15
lea    (%rsp,%r15,1),%rdx
add    $0x3b0,%rdx
movupd (%rcx,%rdx,1),%xmm2
movupd 0x1d0(%rsp,%rcx,1),%xmm3
mulpd  %xmm3,%xmm1
divpd  %xmm1,%xmm2
lea    (%rsp,%r15,1),%rdx
add    $0x12b0,%rdx
mov    0x50(%rsp),%r15
movupd %xmm2,(%rcx,%rdx,1)
mov    %r10,%rcx
cmp    %r12,%r14
je     2b20 <r_mvndrh2+0x19e0>
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x1d0(%rsp,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    2c30 <r_mvndrh2+0x1af0>
jmp    2b20 <r_mvndrh2+0x19e0>

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

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