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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ HUGE_VAL;
double **dmatrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dmatrix(double **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
void NestedANOVA(int a, int *bi, int **Nij, double ***Yijk, double SS[4],
                 double MS[4], double s2[4]) {
  int i, j, k, r;
  double **mYij;
  double S_Nij2, S_SNij2, S_SNij2_over_SNij, SNij2temp;
  double n0, n0bis, nb0;
  int df[4];
  int bimax;
  bimax = 0;
  for (i = 1; i <= a; i++)
    if (bi[i] > bimax)
      bimax = bi[i];
  mYij = dmatrix(0, a, 0, bimax);
  Nij[0][0] = 0;
  mYij[0][0] = 0.;
  for (i = 1; i <= a; i++) {
    Nij[i][0] = 0;
    mYij[i][0] = 0.;
    for (j = 1; j <= bi[i]; j++) {
      mYij[i][j] = 0.;
      Nij[i][0] += Nij[i][j];
      for (k = 1; k <= Nij[i][j]; k++)
        mYij[i][j] += Yijk[i][j][k];
      mYij[i][0] += mYij[i][j];
      if (Nij[i][j])
        mYij[i][j] /= Nij[i][j];
    }
    Nij[0][0] += Nij[i][0];
    mYij[0][0] += mYij[i][0];
    if (Nij[i][0])
      mYij[i][0] /= Nij[i][0];
  }
  if (Nij[0][0])
    mYij[0][0] /= Nij[0][0];
  else {
    for (r = 0; r <= 3; r++)
      SS[r] = MS[r] = s2[r] = (float)HUGE_VAL;
    return;
  }
  SS[0] = SS[1] = SS[2] = SS[3] = 0.;
  for (i = 1; i <= a; i++)
    SS[1] += Nij[i][0] * (mYij[i][0] - mYij[0][0]) * (mYij[i][0] - mYij[0][0]);
  for (i = 1; i <= a; i++)
    for (j = 1; j <= bi[i]; j++)
      SS[2] +=
          Nij[i][j] * (mYij[i][j] - mYij[i][0]) * (mYij[i][j] - mYij[i][0]);
  for (i = 1; i <= a; i++)
    for (j = 1; j <= bi[i]; j++)
      for (k = 1; k <= Nij[i][j]; k++)
        SS[3] += (Yijk[i][j][k] - mYij[i][j]) * (Yijk[i][j][k] - mYij[i][j]);
  for (i = 1; i <= a; i++)
    for (j = 1; j <= bi[i]; j++)
      for (k = 1; k <= Nij[i][j]; k++)
        SS[0] += (Yijk[i][j][k] - mYij[0][0]) * (Yijk[i][j][k] - mYij[0][0]);
  SS[0] = SS[1] + SS[2] + SS[3];
  df[1] = -1;
  for (i = 1; i <= a; i++)
    if (Nij[i][0])
      df[1]++;
  df[2] = 0;
  for (i = 1; i <= a; i++)
    if (Nij[i][0]) {
      for (j = 1; j <= bi[i]; j++)
        if (Nij[i][j])
          df[2]++;
      df[2]--;
    }
  df[3] = 0;
  for (i = 1; i <= a; i++)
    for (j = 1; j <= bi[i]; j++)
      if (Nij[i][j])
        df[3] += Nij[i][j] - 1;
  df[0] = df[1] + df[2] + df[3];
  df[0] = Nij[0][0] - 1;
  if (df[1])
    MS[1] = SS[1] / df[1];
  else
    MS[1] = (float)HUGE_VAL;
  if (df[2])
    MS[2] = SS[2] / df[2];
  else
    MS[2] = (float)HUGE_VAL;
  if (df[3])
    MS[3] = SS[3] / df[3];
  else
    MS[3] = (float)HUGE_VAL;
  S_Nij2 = 0.;
  for (i = 1; i <= a; i++)
    for (j = 1; j <= bi[i]; j++)
      S_Nij2 += Nij[i][j] * Nij[i][j];
  S_SNij2 = 0.;
  for (i = 1; i <= a; i++)
    S_SNij2 += Nij[i][0] * Nij[i][0];
  S_SNij2_over_SNij = 0.;
  for (i = 1; i <= a; i++)
    if (Nij[i][0]) {
      SNij2temp = 0.;
      for (j = 1; j <= bi[i]; j++)
        SNij2temp += Nij[i][j] * Nij[i][j];
      S_SNij2_over_SNij += SNij2temp / Nij[i][0];
    }
  n0bis = n0 = nb0 = 0.;
  if (df[1])
    n0bis = (S_SNij2_over_SNij - (S_Nij2 / Nij[0][0])) / df[1];
  if (df[2])
    n0 = (Nij[0][0] - S_SNij2_over_SNij) / df[2];
  if (df[1])
    nb0 = (Nij[0][0] - (S_SNij2 / Nij[0][0])) / df[1];
  s2[3] = MS[3];
  if (MS[3] != (float)HUGE_VAL) {
    if (n0)
      s2[2] = (MS[2] - s2[3]) / n0;
    else
      s2[2] = (float)HUGE_VAL;
    if (nb0 && s2[2] != (float)HUGE_VAL)
      s2[1] = (MS[1] - s2[3] - n0bis * s2[2]) / nb0;
    else
      s2[1] = (float)HUGE_VAL;
  } else {
    s2[2] = MS[2];
    if (nb0)
      s2[1] = (MS[1] - s2[2]) / nb0;
    else
      s2[1] = (float)HUGE_VAL;
  }
  s2[0] = 0.;
  for (r = 1; r <= 3; r++)
    if (s2[r] != (float)HUGE_VAL)
      s2[0] += s2[r];
  free_dmatrix(mYij, 0, a, 0, bimax);
}


x86 assembly (clang, -O0):
<NestedANOVA>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x94(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     119e <NestedANOVA+0x7e>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x94(%rbp),%eax
jle    118b <NestedANOVA+0x6b>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
jmp    1190 <NestedANOVA+0x70>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1157 <NestedANOVA+0x37>
mov    -0x4(%rbp),%esi
mov    -0x94(%rbp),%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1030 <dmatrix@plt>
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movl   $0x0,(%rax)
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13d6 <NestedANOVA+0x2b6>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x0,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     134e <NestedANOVA+0x22e>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     12c5 <NestedANOVA+0x1a5>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1264 <NestedANOVA+0x144>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     133b <NestedANOVA+0x21b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1340 <NestedANOVA+0x220>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    120e <NestedANOVA+0xee>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,(%rax)
je     13c3 <NestedANOVA+0x2a3>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    13c8 <NestedANOVA+0x2a8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d6 <NestedANOVA+0xb6>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cmpl   $0x0,(%rax)
je     1409 <NestedANOVA+0x2e9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cvtsi2sdl (%rax),%xmm1
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    1464 <NestedANOVA+0x344>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jg     145f <NestedANOVA+0x33f>
mov    0x2bc7(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1410 <NestedANOVA+0x2f0>
jmp    1f4c <NestedANOVA+0xe2c>
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1514 <NestedANOVA+0x3f4>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    149a <NestedANOVA+0x37a>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     15dc <NestedANOVA+0x4bc>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     15c9 <NestedANOVA+0x4a9>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
subsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
subsd  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    152e <NestedANOVA+0x40e>
jmp    15ce <NestedANOVA+0x4ae>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    151b <NestedANOVA+0x3fb>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16db <NestedANOVA+0x5bb>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16c8 <NestedANOVA+0x5a8>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16b5 <NestedANOVA+0x595>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1611 <NestedANOVA+0x4f1>
jmp    16ba <NestedANOVA+0x59a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15f6 <NestedANOVA+0x4d6>
jmp    16cd <NestedANOVA+0x5ad>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15e3 <NestedANOVA+0x4c3>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     17c4 <NestedANOVA+0x6a4>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     17b1 <NestedANOVA+0x691>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     179e <NestedANOVA+0x67e>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
subsd  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1710 <NestedANOVA+0x5f0>
jmp    17a3 <NestedANOVA+0x683>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16f5 <NestedANOVA+0x5d5>
jmp    17b6 <NestedANOVA+0x696>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16e2 <NestedANOVA+0x5c2>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
addsd  0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
addsd  0x18(%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0xffffffff,-0x8c(%rbp)
ff ff ff
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     183b <NestedANOVA+0x71b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,(%rax)
je     1828 <NestedANOVA+0x708>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    182d <NestedANOVA+0x70d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17f8 <NestedANOVA+0x6d8>
movl   $0x0,-0x88(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18e6 <NestedANOVA+0x7c6>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,(%rax)
je     18d3 <NestedANOVA+0x7b3>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18c4 <NestedANOVA+0x7a4>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     18b1 <NestedANOVA+0x791>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    18b6 <NestedANOVA+0x796>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1874 <NestedANOVA+0x754>
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
jmp    18d8 <NestedANOVA+0x7b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    184c <NestedANOVA+0x72c>
movl   $0x0,-0x84(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1980 <NestedANOVA+0x860>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     196d <NestedANOVA+0x84d>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     195a <NestedANOVA+0x83a>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    195f <NestedANOVA+0x83f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    190a <NestedANOVA+0x7ea>
jmp    1972 <NestedANOVA+0x852>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18f7 <NestedANOVA+0x7d7>
mov    -0x8c(%rbp),%eax
add    -0x88(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x8c(%rbp)
je     19da <NestedANOVA+0x8ba>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
cvtsi2sdl -0x8c(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    19f3 <NestedANOVA+0x8d3>
mov    0x2607(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
cmpl   $0x0,-0x88(%rbp)
je     1a23 <NestedANOVA+0x903>
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
cvtsi2sdl -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
jmp    1a3c <NestedANOVA+0x91c>
mov    0x25be(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
cmpl   $0x0,-0x84(%rbp)
je     1a6c <NestedANOVA+0x94c>
mov    -0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
cvtsi2sdl -0x84(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
jmp    1a85 <NestedANOVA+0x965>
mov    0x2575(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1b11 <NestedANOVA+0x9f1>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1afe <NestedANOVA+0x9de>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1aa7 <NestedANOVA+0x987>
jmp    1b03 <NestedANOVA+0x9e3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a94 <NestedANOVA+0x974>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1b65 <NestedANOVA+0xa45>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
imul   (%rcx),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b20 <NestedANOVA+0xa00>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1c31 <NestedANOVA+0xb11>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,(%rax)
je     1c1e <NestedANOVA+0xafe>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1bfb <NestedANOVA+0xadb>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ba4 <NestedANOVA+0xa84>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1c23 <NestedANOVA+0xb03>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b74 <NestedANOVA+0xa54>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x8c(%rbp)
je     1c84 <NestedANOVA+0xb64>
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cvtsi2sdl (%rax),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdl -0x8c(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0x88(%rbp)
je     1cb2 <NestedANOVA+0xb92>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cvtsi2sdl (%rax),%xmm0
subsd  -0x60(%rbp),%xmm0
cvtsi2sdl -0x88(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpl   $0x0,-0x8c(%rbp)
je     1cf3 <NestedANOVA+0xbd3>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cvtsi2sdl (%rax),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
cvtsi2sdl (%rax),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdl -0x8c(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x30(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    0x22d3(%rip),%rax
cvtsi2ssq (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d33 <NestedANOVA+0xc13>
jp     1d33 <NestedANOVA+0xc13>
jmp    1e49 <NestedANOVA+0xd29>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d50 <NestedANOVA+0xc30>
jp     1d50 <NestedANOVA+0xc30>
jmp    1d75 <NestedANOVA+0xc55>
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x10(%rbp),%rax
subsd  0x18(%rax),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
jmp    1d8e <NestedANOVA+0xc6e>
mov    0x226c(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1dab <NestedANOVA+0xc8b>
jp     1dab <NestedANOVA+0xc8b>
jmp    1e2b <NestedANOVA+0xd0b>
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x222d(%rip),%rax
cvtsi2ssq (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1dd9 <NestedANOVA+0xcb9>
jp     1dd9 <NestedANOVA+0xcb9>
jmp    1e2b <NestedANOVA+0xd0b>
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    0x10(%rbp),%rax
subsd  0x18(%rax),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1e44 <NestedANOVA+0xd24>
mov    0x21b6(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1ebb <NestedANOVA+0xd9b>
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e78 <NestedANOVA+0xd58>
jp     1e78 <NestedANOVA+0xd58>
jmp    1e9d <NestedANOVA+0xd7d>
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
divsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1eb6 <NestedANOVA+0xd96>
mov    0x2144(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1ebb <NestedANOVA+0xd9b>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jg     1f35 <NestedANOVA+0xe15>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20fd(%rip),%rax
cvtsi2ssq (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1f09 <NestedANOVA+0xde9>
jp     1f09 <NestedANOVA+0xde9>
jmp    1f22 <NestedANOVA+0xe02>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
jmp    1f27 <NestedANOVA+0xe07>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1ecd <NestedANOVA+0xdad>
mov    -0x48(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x94(%rbp),%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1040 <free_dmatrix@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NestedANOVA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,%r12
mov    %rcx,%r14
mov    %rdx,%r13
mov    %rsi,%r15
mov    %edi,%ebp
test   %edi,%edi
jle    1158 <NestedANOVA+0x38>
mov    %ebp,%ebx
cmp    $0x8,%ebp
jae    115f <NestedANOVA+0x3f>
xor    %ecx,%ecx
mov    $0x1,%eax
jmp    12a3 <NestedANOVA+0x183>
xor    %ecx,%ecx
jmp    12c2 <NestedANOVA+0x1a2>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1833 <NestedANOVA+0x713>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopl   (%rax)
movdqu 0x4(%r15,%rsi,4),%xmm2
movdqu 0x14(%r15,%rsi,4),%xmm3
movdqu 0x24(%r15,%rsi,4),%xmm4
movdqu 0x34(%r15,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1190 <NestedANOVA+0x70>
test   $0x1,%dl
je     1250 <NestedANOVA+0x130>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu (%r15,%rsi,1),%xmm2
movdqu 0x10(%r15,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ecx
cmp    %rax,%rbx
je     12c2 <NestedANOVA+0x1a2>
or     $0x1,%rax
add    $0x1,%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rax,4),%edx
cmp    %ecx,%edx
cmovg  %edx,%ecx
add    $0x1,%rax
cmp    %rax,%rbx
jne    12b0 <NestedANOVA+0x190>
mov    0x80(%rsp),%rax
mov    %rax,0x40(%rsp)
xor    %edi,%edi
mov    %ebp,%esi
xor    %edx,%edx
mov    %ecx,0x3c(%rsp)
call   1030 <dmatrix@plt>
mov    0x0(%r13),%rcx
mov    %rcx,0x30(%rsp)
movl   $0x0,(%rcx)
mov    (%rax),%r10
movq   $0x0,(%r10)
test   %ebp,%ebp
jle    16b3 <NestedANOVA+0x593>
mov    %rax,0x18(%rsp)
mov    %rbp,0x8(%rsp)
lea    0x1(%rbp),%eax
mov    %rax,0x10(%rsp)
mov    $0x1,%r11d
mov    %r13,0x28(%rsp)
jmp    1334 <NestedANOVA+0x214>
xchg   %ax,%ax
add    $0x1,%r11
cmp    0x10(%rsp),%r11
mov    0x28(%rsp),%r13
je     14ab <NestedANOVA+0x38b>
mov    0x0(%r13,%r11,8),%rbx
movl   $0x0,(%rbx)
mov    0x18(%rsp),%rax
mov    (%rax,%r11,8),%rsi
movq   $0x0,(%rsi)
cmpl   $0x0,(%r15,%r11,4)
jle    1470 <NestedANOVA+0x350>
mov    $0x1,%edx
xor    %edi,%edi
pxor   %xmm0,%xmm0
jmp    1384 <NestedANOVA+0x264>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rax
movslq (%r15,%r11,4),%rcx
cmp    %rcx,%rdx
mov    %rax,%rdx
jge    1476 <NestedANOVA+0x356>
movq   $0x0,(%rsi,%rdx,8)
mov    (%rbx,%rdx,4),%r9d
add    %r9d,%edi
mov    %edi,(%rbx)
pxor   %xmm1,%xmm1
test   %r9d,%r9d
jle    1443 <NestedANOVA+0x323>
mov    (%r14,%r11,8),%rax
mov    (%rax,%rdx,8),%r8
lea    -0x1(%r9),%rax
mov    %r9d,%ebp
and    $0x3,%ebp
cmp    $0x3,%rax
jae    13d0 <NestedANOVA+0x2b0>
mov    $0x1,%r13d
pxor   %xmm1,%xmm1
test   %rbp,%rbp
jne    1422 <NestedANOVA+0x302>
jmp    1443 <NestedANOVA+0x323>
xchg   %ax,%ax
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
pxor   %xmm1,%xmm1
xor    %r13d,%r13d
nopl   (%rax)
addsd  0x8(%r8,%r13,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
addsd  0x10(%r8,%r13,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
addsd  0x18(%r8,%r13,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
addsd  0x20(%r8,%r13,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x4,%r13
cmp    %r13,%rcx
jne    13e0 <NestedANOVA+0x2c0>
add    $0x1,%r13
test   %rbp,%rbp
je     1443 <NestedANOVA+0x323>
lea    (%r8,%r13,8),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1430 <NestedANOVA+0x310>
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi)
test   %r9,%r9
je     1370 <NestedANOVA+0x250>
xorps  %xmm2,%xmm2
cvtsi2sd %r9d,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
jmp    1370 <NestedANOVA+0x250>
nopw   0x0(%rax,%rax,1)
pxor   %xmm0,%xmm0
xor    %edi,%edi
mov    0x30(%rsp),%rax
add    (%rax),%edi
mov    %edi,(%rax)
addsd  (%r10),%xmm0
movsd  %xmm0,(%r10)
mov    (%rbx),%eax
test   %eax,%eax
je     1320 <NestedANOVA+0x200>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  (%rsi),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
jmp    1320 <NestedANOVA+0x200>
test   %edi,%edi
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%r9
je     16b3 <NestedANOVA+0x593>
cvtsi2sd %edi,%xmm8
movsd  (%r10),%xmm0
divsd  %xmm8,%xmm0
movsd  %xmm0,(%r10)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x10(%r12)
movupd %xmm0,(%r12)
test   %eax,%eax
jle    1821 <NestedANOVA+0x701>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%r8
mov    %rax,%rsi
add    $0xfffffffffffffffe,%rsi
je     1936 <NestedANOVA+0x816>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
xorpd  %xmm11,%xmm11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rcx,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax),%xmm0
mov    (%r9,%rcx,8),%rax
movsd  (%rax),%xmm2
subsd  (%r10),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm11,%xmm0
movsd  %xmm0,0x8(%r12)
mov    0x8(%r13,%rcx,8),%rax
xorps  %xmm11,%xmm11
cvtsi2sdl (%rax),%xmm11
mov    0x8(%r9,%rcx,8),%rax
movsd  (%rax),%xmm2
subsd  (%r10),%xmm2
mulsd  %xmm2,%xmm11
mulsd  %xmm2,%xmm11
addsd  %xmm0,%xmm11
movsd  %xmm11,0x8(%r12)
lea    (%rdx,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    1520 <NestedANOVA+0x400>
test   $0x1,%r8b
je     15c4 <NestedANOVA+0x4a4>
mov    0x0(%r13,%rcx,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax),%xmm0
mov    (%r9,%rcx,8),%rax
movsd  (%rax),%xmm2
subsd  (%r10),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm11
movsd  %xmm11,0x8(%r12)
cmpl   $0x0,0x8(%rsp)
jle    194f <NestedANOVA+0x82f>
mov    %rsi,0x30(%rsp)
mov    $0x1,%ecx
pxor   %xmm2,%xmm2
jmp    15ef <NestedANOVA+0x4cf>
nop
add    $0x1,%rcx
cmp    0x10(%rsp),%rcx
je     1720 <NestedANOVA+0x600>
mov    (%r15,%rcx,4),%edx
test   %edx,%edx
jle    15e0 <NestedANOVA+0x4c0>
mov    0x0(%r13,%rcx,8),%rbx
mov    (%r9,%rcx,8),%rbp
mov    $0x1,%esi
cmp    $0x1,%edx
je     167f <NestedANOVA+0x55f>
mov    %edx,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sdl (%rbx,%rsi,4),%xmm0
movsd  0x0(%rbp,%rsi,8),%xmm3
subsd  0x0(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%r12)
xorps  %xmm2,%xmm2
cvtsi2sdl 0x4(%rbx,%rsi,4),%xmm2
movsd  0x8(%rbp,%rsi,8),%xmm3
subsd  0x0(%rbp),%xmm3
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r12)
lea    (%rdi,%rsi,1),%rax
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x1,%rax
jne    1620 <NestedANOVA+0x500>
test   $0x1,%dl
je     15e0 <NestedANOVA+0x4c0>
xorps  %xmm0,%xmm0
cvtsi2sdl (%rbx,%rsi,4),%xmm0
movsd  0x0(%rbp,%rsi,8),%xmm3
subsd  0x0(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r12)
jmp    15e0 <NestedANOVA+0x4c0>
mov    0x392e(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x40(%rsp),%rcx
movsd  %xmm0,(%rcx)
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  %xmm0,(%r12)
movsd  %xmm0,0x8(%rcx)
movsd  %xmm0,0x8(%rax)
movsd  %xmm0,0x8(%r12)
movsd  %xmm0,0x10(%rcx)
movsd  %xmm0,0x10(%rax)
movsd  %xmm0,0x10(%r12)
movsd  %xmm0,0x18(%rcx)
movsd  %xmm0,0x18(%rax)
movsd  %xmm0,0x18(%r12)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpl   $0x0,0x8(%rsp)
jle    1997 <NestedANOVA+0x877>
mov    $0x1,%ecx
pxor   %xmm3,%xmm3
jmp    174f <NestedANOVA+0x62f>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    0x10(%rsp),%rcx
je     184b <NestedANOVA+0x72b>
mov    (%r15,%rcx,4),%r13d
test   %r13d,%r13d
jle    1740 <NestedANOVA+0x620>
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,8),%r11
add    $0x1,%r13
mov    $0x1,%ebx
jmp    1779 <NestedANOVA+0x659>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %r13,%rbx
je     1740 <NestedANOVA+0x620>
mov    (%r11,%rbx,4),%edx
test   %edx,%edx
jle    1770 <NestedANOVA+0x650>
mov    (%r14,%rcx,8),%rax
mov    (%rax,%rbx,8),%rbp
mov    0x18(%rsp),%rax
mov    (%rax,%rcx,8),%rsi
mov    $0x1,%r9d
cmp    $0x1,%edx
je     17f8 <NestedANOVA+0x6d8>
mov    %edx,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%r9d
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r9,8),%xmm0
subsd  (%rsi,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x18(%r12)
movsd  0x8(%rbp,%r9,8),%xmm3
subsd  (%rsi,%rbx,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,0x18(%r12)
lea    (%rdi,%r9,1),%rax
add    $0x2,%rax
add    $0x2,%r9
cmp    $0x1,%rax
jne    17b0 <NestedANOVA+0x690>
test   $0x1,%dl
je     1770 <NestedANOVA+0x650>
movsd  0x0(%rbp,%r9,8),%xmm0
subsd  (%rsi,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
movsd  %xmm3,0x18(%r12)
jmp    1770 <NestedANOVA+0x650>
pxor   %xmm3,%xmm3
xorpd  %xmm11,%xmm11
pxor   %xmm2,%xmm2
jmp    199b <NestedANOVA+0x87b>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    120b <NestedANOVA+0xeb>
jmp    1250 <NestedANOVA+0x130>
cmpl   $0x0,0x8(%rsp)
jle    1ea1 <NestedANOVA+0xd81>
mov    $0x1,%r9d
pxor   %xmm4,%xmm4
mov    0x28(%rsp),%r13
jmp    187f <NestedANOVA+0x75f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    0x10(%rsp),%r9
je     1959 <NestedANOVA+0x839>
mov    (%r15,%r9,4),%edx
test   %edx,%edx
jle    1870 <NestedANOVA+0x750>
mov    0x0(%r13,%r9,8),%r11
add    $0x1,%rdx
mov    $0x1,%ebx
jmp    18a9 <NestedANOVA+0x789>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rdx,%rbx
je     1870 <NestedANOVA+0x750>
mov    (%r11,%rbx,4),%ebp
test   %ebp,%ebp
jle    18a0 <NestedANOVA+0x780>
mov    (%r14,%r9,8),%rax
mov    (%rax,%rbx,8),%rsi
mov    $0x1,%ecx
cmp    $0x1,%ebp
je     1913 <NestedANOVA+0x7f3>
mov    %ebp,%edi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%ecx
movsd  (%rsi,%rcx,8),%xmm0
subsd  (%r10),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,(%r12)
movsd  0x8(%rsi,%rcx,8),%xmm4
subsd  (%r10),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,(%r12)
lea    (%rdi,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    18d0 <NestedANOVA+0x7b0>
test   $0x1,%bpl
je     18a0 <NestedANOVA+0x780>
movsd  (%rsi,%rcx,8),%xmm0
subsd  (%r10),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm4
movsd  %xmm4,(%r12)
jmp    18a0 <NestedANOVA+0x780>
mov    $0x1,%ecx
xorpd  %xmm11,%xmm11
test   $0x1,%r8b
jne    1597 <NestedANOVA+0x477>
jmp    15c4 <NestedANOVA+0x4a4>
pxor   %xmm3,%xmm3
pxor   %xmm2,%xmm2
jmp    199b <NestedANOVA+0x87b>
addsd  %xmm11,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%r12)
mov    0x8(%rsp),%rdx
test   %edx,%edx
jle    1eb0 <NestedANOVA+0xd90>
mov    %r8d,%ecx
and    $0x3,%ecx
cmpq   $0x3,0x30(%rsp)
jae    1ebe <NestedANOVA+0xd9e>
mov    $0xffffffff,%r11d
mov    $0x1,%edi
jmp    1f0d <NestedANOVA+0xded>
pxor   %xmm3,%xmm3
mov    0x8(%rsp),%rdx
addsd  %xmm11,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%r12)
mov    $0xffffffff,%r11d
xor    %r14d,%r14d
xor    %r8d,%r8d
xorps  %xmm0,%xmm0
cvtsi2sd %r11d,%xmm0
divsd  %xmm0,%xmm11
xor    %r9d,%r9d
mov    0x20(%rsp),%rax
movsd  %xmm11,0x8(%rax)
xorps  %xmm9,%xmm9
cvtsi2sd %r8d,%xmm9
test   %r8d,%r8d
je     19f2 <NestedANOVA+0x8d2>
movsd  0x10(%r12),%xmm0
divsd  %xmm9,%xmm0
jmp    1a05 <NestedANOVA+0x8e5>
mov    0x35ef(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,0x10(%rax)
test   %r14d,%r14d
je     1a29 <NestedANOVA+0x909>
movsd  0x18(%r12),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
divsd  %xmm0,%xmm1
jmp    1a3f <NestedANOVA+0x91f>
mov    0x35b8(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mov    0x20(%rsp),%r14
movsd  %xmm1,0x18(%r14)
xorpd  %xmm2,%xmm2
pxor   %xmm5,%xmm5
xorpd  %xmm4,%xmm4
pxor   %xmm6,%xmm6
test   %edx,%edx
jle    1d34 <NestedANOVA+0xc14>
xorpd  %xmm4,%xmm4
mov    $0x1,%r10d
jmp    1a7f <NestedANOVA+0x95f>
xchg   %ax,%ax
add    $0x1,%r10
cmp    0x10(%rsp),%r10
je     1b3f <NestedANOVA+0xa1f>
mov    (%r15,%r10,4),%edi
test   %edi,%edi
jle    1a70 <NestedANOVA+0x950>
mov    0x0(%r13,%r10,8),%rbp
lea    -0x1(%rdi),%rax
mov    %edi,%ecx
and    $0x3,%ecx
mov    $0x1,%ebx
cmp    $0x3,%rax
jb     1b05 <NestedANOVA+0x9e5>
and    $0xfffffffc,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rbp,%rbx,4),%eax
mov    0x8(%rbp,%rbx,4),%esi
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm4,%xmm0
imul   %esi,%esi
xorps  %xmm5,%xmm5
cvtsi2sd %esi,%xmm5
addsd  %xmm0,%xmm5
mov    0xc(%rbp,%rbx,4),%eax
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rbp,%rbx,4),%eax
imul   %eax,%eax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
addsd  %xmm5,%xmm0
addsd  %xmm0,%xmm4
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1ab0 <NestedANOVA+0x990>
add    $0x1,%rbx
test   %rcx,%rcx
je     1a70 <NestedANOVA+0x950>
lea    0x0(,%rbx,4),%rax
add    %rbp,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdi,4),%esi
imul   %esi,%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
addsd  %xmm0,%xmm4
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1b20 <NestedANOVA+0xa00>
jmp    1a70 <NestedANOVA+0x950>
test   %edx,%edx
jle    1b72 <NestedANOVA+0xa52>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%rsi
add    $0xfffffffffffffffe,%rax
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    1b7f <NestedANOVA+0xa5f>
pxor   %xmm5,%xmm5
mov    $0x1,%ebp
test   %rcx,%rcx
jne    1bf6 <NestedANOVA+0xad6>
jmp    1c2d <NestedANOVA+0xb0d>
pxor   %xmm5,%xmm5
pxor   %xmm6,%xmm6
jmp    1d34 <NestedANOVA+0xc14>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm5,%xmm5
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    0x8(%r13,%rbp,8),%rax
mov    0x10(%r13,%rbp,8),%rdi
mov    (%rax),%eax
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    (%rdi),%eax
imul   %eax,%eax
xorps  %xmm6,%xmm6
cvtsi2sd %eax,%xmm6
addsd  %xmm5,%xmm0
addsd  %xmm0,%xmm6
mov    0x18(%r13,%rbp,8),%rax
mov    (%rax),%eax
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x20(%r13,%rbp,8),%rax
mov    (%rax),%eax
imul   %eax,%eax
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
addsd  %xmm6,%xmm0
addsd  %xmm0,%xmm5
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    1b90 <NestedANOVA+0xa70>
add    $0x1,%rbp
test   %rcx,%rcx
je     1c2d <NestedANOVA+0xb0d>
lea    0x0(,%rbp,8),%rax
add    %r13,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rdi,8),%rsi
mov    (%rsi),%esi
imul   %esi,%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1c10 <NestedANOVA+0xaf0>
pxor   %xmm6,%xmm6
test   %edx,%edx
jle    1d34 <NestedANOVA+0xc14>
mov    $0x1,%ecx
jmp    1c63 <NestedANOVA+0xb43>
pxor   %xmm7,%xmm7
xorps  %xmm0,%xmm0
cvtsi2sd %r10d,%xmm0
divsd  %xmm0,%xmm7
addsd  %xmm7,%xmm6
add    $0x1,%rcx
cmp    0x10(%rsp),%rcx
je     1d2f <NestedANOVA+0xc0f>
mov    0x0(%r13,%rcx,8),%rbx
mov    (%rbx),%r10d
test   %r10d,%r10d
je     1c54 <NestedANOVA+0xb34>
mov    (%r15,%rcx,4),%edi
test   %edi,%edi
jle    1c40 <NestedANOVA+0xb20>
lea    -0x1(%rdi),%rax
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x3,%rax
jae    1c97 <NestedANOVA+0xb77>
pxor   %xmm7,%xmm7
mov    $0x1,%esi
test   %rbp,%rbp
jne    1cfe <NestedANOVA+0xbde>
jmp    1c44 <NestedANOVA+0xb24>
and    $0xfffffffc,%edi
pxor   %xmm7,%xmm7
xor    %esi,%esi
mov    0x4(%rbx,%rsi,4),%eax
mov    0x8(%rbx,%rsi,4),%edx
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm7,%xmm0
imul   %edx,%edx
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
addsd  %xmm0,%xmm3
mov    0xc(%rbx,%rsi,4),%eax
imul   %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rbx,%rsi,4),%eax
imul   %eax,%eax
xorps  %xmm7,%xmm7
cvtsi2sd %eax,%xmm7
addsd  %xmm3,%xmm0
addsd  %xmm0,%xmm7
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1ca0 <NestedANOVA+0xb80>
add    $0x1,%rsi
test   %rbp,%rbp
je     1c44 <NestedANOVA+0xb24>
lea    (%rbx,%rsi,4),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rsi,4),%edx
imul   %edx,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
addsd  %xmm0,%xmm7
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1d10 <NestedANOVA+0xbf0>
jmp    1c44 <NestedANOVA+0xb24>
mov    0x8(%rsp),%rdx
test   %r9b,%r9b
jne    1d52 <NestedANOVA+0xc32>
divsd  %xmm8,%xmm4
movdqa %xmm6,%xmm2
subsd  %xmm4,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %r11d,%xmm0
divsd  %xmm0,%xmm2
xorpd  %xmm4,%xmm4
pxor   %xmm7,%xmm7
test   %r8d,%r8d
je     1d6d <NestedANOVA+0xc4d>
movapd %xmm8,%xmm7
subsd  %xmm6,%xmm7
divsd  %xmm9,%xmm7
test   %r9b,%r9b
mov    0x3c(%rsp),%r8d
jne    1d93 <NestedANOVA+0xc73>
divsd  %xmm8,%xmm5
subsd  %xmm5,%xmm8
xorps  %xmm0,%xmm0
cvtsi2sd %r11d,%xmm0
divsd  %xmm0,%xmm8
movapd %xmm8,%xmm4
mov    0x40(%rsp),%rcx
movsd  %xmm1,0x18(%rcx)
mov    0x3244(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
movsd  0x18(%r14),%xmm3
cvtss2sd %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jne    1dbe <NestedANOVA+0xc9e>
jnp    1e0a <NestedANOVA+0xcea>
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm7
movapd %xmm0,%xmm3
mov    0x18(%rsp),%rdi
jne    1dd3 <NestedANOVA+0xcb3>
jnp    1de1 <NestedANOVA+0xcc1>
movsd  0x10(%r14),%xmm3
subsd  %xmm1,%xmm3
divsd  %xmm7,%xmm3
movsd  %xmm3,0x10(%rcx)
ucomisd %xmm5,%xmm4
jne    1dee <NestedANOVA+0xcce>
jnp    1e36 <NestedANOVA+0xd16>
ucomisd %xmm0,%xmm3
jne    1df6 <NestedANOVA+0xcd6>
jnp    1e36 <NestedANOVA+0xd16>
movsd  0x8(%r14),%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm5
jmp    1e30 <NestedANOVA+0xd10>
movsd  0x10(%r14),%xmm3
movsd  %xmm3,0x10(%rcx)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm4
mov    0x18(%rsp),%rdi
jne    1e26 <NestedANOVA+0xd06>
jnp    1e36 <NestedANOVA+0xd16>
movsd  0x8(%r14),%xmm5
subsd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
jmp    1e3a <NestedANOVA+0xd1a>
movapd %xmm0,%xmm5
movsd  %xmm5,0x8(%rcx)
xorpd  %xmm2,%xmm2
addsd  %xmm5,%xmm2
cmpneqsd %xmm0,%xmm5
andpd  %xmm2,%xmm5
movapd %xmm3,%xmm2
cmpneqsd %xmm0,%xmm2
andpd  %xmm2,%xmm3
movsd  0x11ab(%rip),%xmm4
andnpd %xmm4,%xmm2
orpd   %xmm3,%xmm2
addsd  %xmm5,%xmm2
cmpneqsd %xmm1,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm4,%xmm0
orpd   %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx)
xor    %esi,%esi
xor    %ecx,%ecx
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_dmatrix@plt>
mov    0x8(%rsp),%rdx
mov    0x28(%rsp),%r13
jmp    19a0 <NestedANOVA+0x880>
xor    %r14d,%r14d
mov    $0xffffffff,%r11d
jmp    19b8 <NestedANOVA+0x898>
and    $0xfffffffffffffffc,%r8
mov    $0xffffffff,%r11d
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    0x8(%r13,%rdi,8),%rax
mov    0x10(%r13,%rdi,8),%rsi
cmpl   $0x1,(%rax)
sbb    $0xffffffff,%r11d
cmpl   $0x1,(%rsi)
sbb    $0xffffffff,%r11d
mov    0x18(%r13,%rdi,8),%rax
cmpl   $0x1,(%rax)
sbb    $0xffffffff,%r11d
mov    0x20(%r13,%rdi,8),%rax
cmpl   $0x1,(%rax)
sbb    $0xffffffff,%r11d
add    $0x4,%rdi
cmp    %rdi,%r8
jne    1ed0 <NestedANOVA+0xdb0>
add    $0x1,%rdi
test   %rcx,%rcx
je     1f34 <NestedANOVA+0xe14>
lea    0x0(,%rdi,8),%rax
add    %r13,%rax
xor    %edi,%edi
nop
mov    (%rax,%rdi,8),%rsi
cmpl   $0x1,(%rsi)
sbb    $0xffffffff,%r11d
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1f20 <NestedANOVA+0xe00>
test   %edx,%edx
jle    2284 <NestedANOVA+0x1164>
movabs $0x3ffffffffffffffe,%r10
ff ff 3f
xor    %r8d,%r8d
mov    $0x1,%r9d
xorpd  %xmm2,%xmm2
pcmpeqd %xmm9,%xmm9
movdqa 0x109f(%rip),%xmm10
jmp    1f83 <NestedANOVA+0xe63>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%r8d
add    $0x1,%r9
cmp    0x10(%rsp),%r9
je     20c8 <NestedANOVA+0xfa8>
mov    0x0(%r13,%r9,8),%rcx
cmpl   $0x0,(%rcx)
je     1f74 <NestedANOVA+0xe54>
mov    (%r15,%r9,4),%ebx
test   %ebx,%ebx
jle    1f70 <NestedANOVA+0xe50>
mov    $0x1,%edi
cmp    $0x8,%rbx
jb     208f <NestedANOVA+0xf6f>
mov    %ebx,%edi
and    $0xfffffff8,%edi
movd   %r8d,%xmm5
lea    -0x8(%rdi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     20b6 <NestedANOVA+0xf96>
mov    %r8,%rsi
and    %r10,%rsi
pxor   %xmm7,%xmm7
xor    %ebp,%ebp
movdqa %xmm5,%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqu 0x4(%rcx,%rbp,4),%xmm3
movdqu 0x14(%rcx,%rbp,4),%xmm4
movdqu 0x24(%rcx,%rbp,4),%xmm5
movdqu 0x34(%rcx,%rbp,4),%xmm6
pcmpeqd %xmm2,%xmm3
paddd  %xmm0,%xmm3
pcmpeqd %xmm2,%xmm4
paddd  %xmm7,%xmm4
pcmpeqd %xmm2,%xmm5
pcmpeqd %xmm2,%xmm6
paddd  %xmm10,%xmm5
paddd  %xmm3,%xmm5
paddd  %xmm10,%xmm6
paddd  %xmm4,%xmm6
add    $0x10,%rbp
movdqa %xmm5,%xmm0
movdqa %xmm6,%xmm7
add    $0xfffffffffffffffe,%rsi
jne    1fe0 <NestedANOVA+0xec0>
test   $0x1,%r8b
je     2067 <NestedANOVA+0xf47>
shl    $0x2,%rbp
or     $0x4,%rbp
movdqu (%rcx,%rbp,1),%xmm0
movdqu 0x10(%rcx,%rbp,1),%xmm3
pcmpeqd %xmm2,%xmm0
paddd  %xmm0,%xmm5
pcmpeqd %xmm2,%xmm3
paddd  %xmm3,%xmm6
psubd  %xmm9,%xmm5
psubd  %xmm9,%xmm6
paddd  %xmm6,%xmm5
pshufd $0xee,%xmm5,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x55,%xmm0,%xmm3
paddd  %xmm0,%xmm3
movd   %xmm3,%r8d
cmp    %rdi,%rbx
je     1f70 <NestedANOVA+0xe50>
or     $0x1,%rdi
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x1,(%rcx,%rdi,4)
sbb    $0xffffffff,%r8d
add    $0x1,%rdi
cmp    %rdi,%rbx
jne    20a0 <NestedANOVA+0xf80>
jmp    1f70 <NestedANOVA+0xe50>
pxor   %xmm6,%xmm6
xor    %ebp,%ebp
test   $0x1,%r8b
jne    203a <NestedANOVA+0xf1a>
jmp    2067 <NestedANOVA+0xf47>
test   %edx,%edx
jle    2287 <NestedANOVA+0x1167>
mov    %r10,%rsi
xor    %r9d,%r9d
mov    $0x1,%r10d
pxor   %xmm9,%xmm9
pcmpeqd %xmm10,%xmm10
xor    %r14d,%r14d
jmp    20ff <NestedANOVA+0xfdf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    0x10(%rsp),%r10
je     227d <NestedANOVA+0x115d>
mov    (%r15,%r10,4),%ecx
test   %ecx,%ecx
jle    20f0 <NestedANOVA+0xfd0>
mov    0x0(%r13,%r10,8),%rdx
mov    $0x1,%edi
cmp    $0x8,%rcx
jb     2243 <NestedANOVA+0x1123>
mov    %ecx,%edi
and    $0xfffffff8,%edi
movd   %r14d,%xmm4
lea    -0x8(%rdi),%rax
mov    %rax,%r14
shr    $0x3,%r14
add    $0x1,%r14
test   %rax,%rax
je     226b <NestedANOVA+0x114b>
mov    %r14,%rbx
and    %rsi,%rbx
pxor   %xmm6,%xmm6
xor    %ebp,%ebp
movdqa %xmm4,%xmm0
nopl   (%rax)
movdqu 0x4(%rdx,%rbp,4),%xmm2
movdqu 0x14(%rdx,%rbp,4),%xmm7
movdqu 0x24(%rdx,%rbp,4),%xmm4
movdqu 0x34(%rdx,%rbp,4),%xmm5
movdqa %xmm2,%xmm3
paddd  %xmm10,%xmm3
movdqa %xmm7,%xmm1
paddd  %xmm10,%xmm1
pcmpeqd %xmm9,%xmm2
pandn  %xmm3,%xmm2
paddd  %xmm0,%xmm2
pcmpeqd %xmm9,%xmm7
pandn  %xmm1,%xmm7
paddd  %xmm6,%xmm7
movdqa %xmm4,%xmm0
paddd  %xmm10,%xmm0
movdqa %xmm5,%xmm1
paddd  %xmm10,%xmm1
pcmpeqd %xmm9,%xmm4
pandn  %xmm0,%xmm4
paddd  %xmm2,%xmm4
pcmpeqd %xmm9,%xmm5
pandn  %xmm1,%xmm5
paddd  %xmm7,%xmm5
add    $0x10,%rbp
movdqa %xmm4,%xmm0
movdqa %xmm5,%xmm6
add    $0xfffffffffffffffe,%rbx
jne    2150 <NestedANOVA+0x1030>
test   $0x1,%r14b
je     221b <NestedANOVA+0x10fb>
shl    $0x2,%rbp
or     $0x4,%rbp
movdqu (%rdx,%rbp,1),%xmm0
movdqu 0x10(%rdx,%rbp,1),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm10,%xmm2
movdqa %xmm1,%xmm3
paddd  %xmm10,%xmm3
pcmpeqd %xmm9,%xmm0
pandn  %xmm2,%xmm0
paddd  %xmm0,%xmm4
pcmpeqd %xmm9,%xmm1
pandn  %xmm3,%xmm1
paddd  %xmm1,%xmm5
paddd  %xmm5,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r14d
cmp    %rdi,%rcx
je     20f0 <NestedANOVA+0xfd0>
or     $0x1,%rdi
add    $0x1,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,4),%eax
sub    $0x1,%eax
cmovb  %r9d,%eax
add    %eax,%r14d
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    2250 <NestedANOVA+0x1130>
jmp    20f0 <NestedANOVA+0xfd0>
pxor   %xmm5,%xmm5
xor    %ebp,%ebp
test   $0x1,%r14b
jne    21dc <NestedANOVA+0x10bc>
jmp    221b <NestedANOVA+0x10fb>
mov    0x8(%rsp),%rdx
jmp    228a <NestedANOVA+0x116a>
xor    %r8d,%r8d
xor    %r14d,%r14d
test   %r11d,%r11d
jne    19bb <NestedANOVA+0x89b>
mov    0x2d4e(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
xorps  %xmm11,%xmm11
cvtss2sd %xmm0,%xmm11
xor    %r11d,%r11d
mov    $0x1,%r9b
jmp    19cb <NestedANOVA+0x8ab>

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

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