void initGeneric(const int n, const unsigned int *valueVector,
                 int valueVectorLength, double *fracchanges, double *ext_EIGN,
                 double *EV, double *EI, double *frequencies,
                 double *ext_initialRates, double *tipVector, int model) {
  double **r, **a, **EIGV, *initialRates = ext_initialRates, *f, *e, *d,
                           *invfreq, *EIGN, *eptr;
  int i, j, k, m, l;
  r = (double **)rax_malloc(n * sizeof(double *));
  EIGV = (double **)rax_malloc(n * sizeof(double *));
  a = (double **)rax_malloc(n * sizeof(double *));
  for (i = 0; i < n; i++) {
    a[i] = (double *)rax_malloc(n * sizeof(double));
    EIGV[i] = (double *)rax_malloc(n * sizeof(double));
    r[i] = (double *)rax_malloc(n * sizeof(double));
  }
  f = (double *)rax_malloc(n * sizeof(double));
  e = (double *)rax_malloc(n * sizeof(double));
  d = (double *)rax_malloc(n * sizeof(double));
  invfreq = (double *)rax_malloc(n * sizeof(double));
  EIGN = (double *)rax_malloc(n * sizeof(double));
  for (l = 0; l < n; l++)
    f[l] = frequencies[l];
  i = 0;
  for (j = 0; j < n; j++)
    for (k = 0; k < n; k++)
      r[j][k] = 0.0;
  for (j = 0; j < n - 1; j++)
    for (k = j + 1; k < n; k++)
      r[j][k] = initialRates[i++];
  for (j = 0; j < n; j++) {
    r[j][j] = 0.0;
    for (k = 0; k < j; k++)
      r[j][k] = r[k][j];
  }
  fracchanges[model] = 0.0;
  for (j = 0; j < n; j++)
    for (k = 0; k < n; k++)
      fracchanges[model] += f[j] * r[j][k] * f[k];
  m = 0;
  for (i = 0; i < n; i++)
    a[i][i] = 0;
  for (i = 0; i < n; i++) {
    for (j = i + 1; j < n; j++) {
      double factor = initialRates[m++];
      a[i][j] = a[j][i] = factor * sqrt(f[i] * f[j]);
      a[i][i] -= factor * f[j];
      a[j][j] -= factor * f[i];
    }
  }
  makeEigen(a, n, d, e);
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      a[i][j] *= sqrt(f[j]);
  for (i = 0; i < n; i++) {
    if (d[i] > -1e-8) {
      if (i != 0) {
        double tmp = d[i], sum = 0;
        d[i] = d[0];
        d[0] = tmp;
        for (j = 0; j < n; j++) {
          tmp = a[i][j];
          a[i][j] = a[0][j];
          sum += (a[0][j] = tmp);
        }
        for (j = 0; j < n; j++)
          a[0][j] /= sum;
      }
      break;
    }
  }
  for (i = 0; i < n; i++) {
    EIGN[i] = -d[i];
    for (j = 0; j < n; j++)
      EIGV[i][j] = a[j][i];
    invfreq[i] = 1 / EIGV[i][0];
  }
  for (l = 1; l < n; l++) {
    ext_EIGN[(l - 1)] = EIGN[l];
    assert(ext_EIGN[(l - 1)] > 0.0);
  }
  eptr = EV;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      *eptr++ = EIGV[i][j];
    }
  for (i = 0; i < n; i++)
    for (j = 1; j < n; j++)
      EI[i * (n - 1) + (j - 1)] = EV[i * n + j] * invfreq[i];
  for (i = 0; i < valueVectorLength; i++) {
    unsigned int value = valueVector[i];
    for (j = 0; j < n; j++)
      tipVector[i * n + j] = 0;
    if (value > 0) {
      for (j = 0; j < n; j++) {
        if ((value >> j) & 1) {
          int l;
          for (l = 0; l < n; l++)
            tipVector[i * n + l] += EIGV[j][l];
        }
      }
    }
  }
  for (i = 0; i < valueVectorLength; i++) {
    for (j = 0; j < n; j++)
      if (tipVector[i * n + j] > 0.999999999)
        tipVector[i * n + j] = 0.999999999;
  }
  for (i = 0; i < n; i++) {
    rax_free(EIGV[i]);
    rax_free(a[i]);
    rax_free(r[i]);
  }
  rax_free(r);
  rax_free(a);
  rax_free(EIGV);
  rax_free(f);
  rax_free(e);
  rax_free(d);
  rax_free(invfreq);
  rax_free(EIGN);
}


x86 assembly (clang, -O0):
<initGeneric>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x48(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    125b <initGeneric+0x10b>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
movslq %eax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
movslq %eax,%rdx
mov    -0x48(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
movslq %eax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    11d5 <initGeneric+0x85>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x58(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x60(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x68(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x70(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <rax_malloc@plt>
cltq
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1311 <initGeneric+0x1c1>
mov    0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    12ce <initGeneric+0x17e>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1398 <initGeneric+0x248>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    137f <initGeneric+0x22f>
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    133e <initGeneric+0x1ee>
jmp    1384 <initGeneric+0x234>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1325 <initGeneric+0x1d5>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1439 <initGeneric+0x2e9>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1420 <initGeneric+0x2d0>
mov    -0x50(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x84(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    13c5 <initGeneric+0x275>
jmp    1425 <initGeneric+0x2d5>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    13a2 <initGeneric+0x252>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14ef <initGeneric+0x39f>
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    14d6 <initGeneric+0x386>
mov    -0x38(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    147a <initGeneric+0x32a>
jmp    14db <initGeneric+0x38b>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1443 <initGeneric+0x2f3>
mov    -0x20(%rbp),%rax
movslq 0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15b3 <initGeneric+0x463>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    159a <initGeneric+0x44a>
mov    -0x58(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq 0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1522 <initGeneric+0x3d2>
jmp    159f <initGeneric+0x44f>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1509 <initGeneric+0x3b9>
movl   $0x0,-0x90(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1608 <initGeneric+0x4b8>
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    15c7 <initGeneric+0x477>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17b9 <initGeneric+0x669>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17a0 <initGeneric+0x650>
mov    -0x50(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x90(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x58(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x88(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1630 <initGeneric+0x4e0>
jmp    17a5 <initGeneric+0x655>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1612 <initGeneric+0x4c2>
mov    -0x40(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    $0x0,%al
call   1030 <makeEigen@plt>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1863 <initGeneric+0x713>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    184a <initGeneric+0x6fa>
mov    -0x58(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <sqrt@plt>
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    17f2 <initGeneric+0x6a2>
jmp    184f <initGeneric+0x6ff>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    17d9 <initGeneric+0x689>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a13 <initGeneric+0x8c3>
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x76c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19fa <initGeneric+0x8aa>
cmpl   $0x0,-0x84(%rbp)
je     19f5 <initGeneric+0x8a5>
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    199f <initGeneric+0x84f>
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1900 <initGeneric+0x7b0>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19f0 <initGeneric+0x8a0>
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    19a9 <initGeneric+0x859>
jmp    19f5 <initGeneric+0x8a5>
jmp    1a13 <initGeneric+0x8c3>
jmp    19ff <initGeneric+0x8af>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    186d <initGeneric+0x71d>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b05 <initGeneric+0x9b5>
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ac6 <initGeneric+0x976>
mov    -0x40(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1a6d <initGeneric+0x91d>
mov    -0x48(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x533(%rip),%xmm0
divsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1a1d <initGeneric+0x8cd>
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b82 <initGeneric+0xa32>
mov    -0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x94(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x94(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1060 <assert@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1b0f <initGeneric+0x9bf>
mov    -0x30(%rbp),%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c17 <initGeneric+0xac7>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bfe <initGeneric+0xaae>
mov    -0x48(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  %xmm0,(%rax)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1bad <initGeneric+0xa5d>
jmp    1c03 <initGeneric+0xab3>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1b94 <initGeneric+0xa44>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1cc8 <initGeneric+0xb78>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1caf <initGeneric+0xb5f>
mov    -0x30(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x84(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    -0x4(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    -0x88(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1c3a <initGeneric+0xaea>
jmp    1cb4 <initGeneric+0xb64>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1c21 <initGeneric+0xad1>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e26 <initGeneric+0xcd6>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb4(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1d41 <initGeneric+0xbf1>
mov    0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1cff <initGeneric+0xbaf>
cmpl   $0x0,-0xb4(%rbp)
jbe    1e0d <initGeneric+0xcbd>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e08 <initGeneric+0xcb8>
mov    -0xb4(%rbp),%eax
mov    -0x88(%rbp),%ecx
shr    %cl,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1def <initGeneric+0xc9f>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1dea <initGeneric+0xc9a>
mov    -0x48(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1d8b <initGeneric+0xc3b>
jmp    1def <initGeneric+0xc9f>
jmp    1df4 <initGeneric+0xca4>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1d58 <initGeneric+0xc08>
jmp    1e0d <initGeneric+0xcbd>
jmp    1e12 <initGeneric+0xcc2>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1cd2 <initGeneric+0xb82>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1edc <initGeneric+0xd8c>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ec3 <initGeneric+0xd73>
mov    0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x18c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1eaa <initGeneric+0xd5a>
mov    0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x163(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1eaf <initGeneric+0xd5f>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1e49 <initGeneric+0xcf9>
jmp    1ec8 <initGeneric+0xd78>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1e30 <initGeneric+0xce0>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f4b <initGeneric+0xdfb>
mov    -0x48(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x40(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1ee6 <initGeneric+0xd96>
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x48(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x58(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x60(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x68(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x70(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
mov    -0x78(%rbp),%rdi
mov    $0x0,%al
call   1050 <rax_free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<initGeneric>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x98(%rsp)
mov    %r8,0xa8(%rsp)
mov    %rcx,%r13
mov    %edx,0x94(%rsp)
mov    %rsi,0xd0(%rsp)
mov    0x130(%rsp),%eax
mov    %eax,0x20(%rsp)
mov    0x128(%rsp),%rax
mov    %rax,0xc8(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %rdi,0x10(%rsp)
movslq %edi,%rbx
lea    0x0(,%rbx,8),%r15
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
cltq
mov    %rax,0x50(%rsp)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
movslq %eax,%rbp
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
movslq %eax,%r12
mov    %ebx,%r14d
mov    %rbx,0x88(%rsp)
test   %ebx,%ebx
jle    126f <initGeneric+0x10f>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
cltq
mov    %rax,(%r12,%rbx,8)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
cltq
mov    %rax,0x0(%rbp,%rbx,8)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
cltq
mov    0x50(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1230 <initGeneric+0xd0>
mov    %r12,0x30(%rsp)
mov    %rbp,0x80(%rsp)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
mov    %eax,%ebx
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
mov    %eax,%r12d
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
mov    %eax,%ebp
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
mov    %eax,0x18(%rsp)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <rax_malloc@plt>
movslq %ebx,%rbx
movslq %r12d,%r8
movslq %ebp,%rdx
movslq 0x18(%rsp),%rcx
mov    %rcx,0x78(%rsp)
cltq
mov    %rax,0x68(%rsp)
mov    0x10(%rsp),%rsi
test   %esi,%esi
mov    %r15,0xc0(%rsp)
mov    %rbx,0x58(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %r8,0xb8(%rsp)
jle    14a5 <initGeneric+0x345>
cmp    $0x4,%esi
jae    130e <initGeneric+0x1ae>
xor    %eax,%eax
mov    0x8(%rsp),%rbp
jmp    1406 <initGeneric+0x2a6>
mov    0x8(%rsp),%rbp
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1333 <initGeneric+0x1d3>
lea    (%rbx,%r14,8),%rax
cmp    %rbp,%rax
jbe    1333 <initGeneric+0x1d3>
xor    %eax,%eax
jmp    1406 <initGeneric+0x2a6>
mov    %r14d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdi
mov    %rdi,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r9d
and    $0x3,%r9d
cmp    $0xc,%rdi
jae    1359 <initGeneric+0x1f9>
xor    %edi,%edi
jmp    13bd <initGeneric+0x25d>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
nop
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm0
movups 0x30(%rbp,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm0
movups 0x50(%rbp,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm0
movupd 0x70(%rbp,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movupd %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1360 <initGeneric+0x200>
test   %r9,%r9
je     1401 <initGeneric+0x2a1>
lea    (%rbx,%rdi,8),%r10
add    $0x10,%r10
lea    0x10(,%rdi,8),%rcx
add    %rbp,%rcx
shl    $0x5,%r9
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdi,1),%xmm0
movupd (%rcx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%r10,%rdi,1)
movupd %xmm1,(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    13e0 <initGeneric+0x280>
cmp    %r14,%rax
je     1478 <initGeneric+0x318>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
mov    %r14,%rdi
and    $0x3,%rdi
je     1435 <initGeneric+0x2d5>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1420 <initGeneric+0x2c0>
cmp    $0x3,%rcx
jb     1478 <initGeneric+0x318>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    1440 <initGeneric+0x2e0>
test   %esi,%esi
jle    14a5 <initGeneric+0x345>
lea    0x0(,%r14,8),%r15
lea    -0x1(%r14),%rax
mov    %r14d,%ecx
and    $0x7,%ecx
mov    %rcx,0x18(%rsp)
mov    %rax,0x28(%rsp)
cmp    $0x7,%rax
jae    14c7 <initGeneric+0x367>
xor    %ebp,%ebp
jmp    1560 <initGeneric+0x400>
movslq 0x20(%rsp),%rax
movq   $0x0,0x0(%r13,%rax,8)
mov    0x30(%rsp),%rdi
mov    %r8,%rcx
xor    %eax,%eax
call   1030 <makeEigen@plt>
jmp    2210 <initGeneric+0x10b0>
mov    %r14d,%ebx
and    $0xfffffff8,%ebx
xor    %ebp,%ebp
mov    0x50(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x8(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x10(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x18(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x20(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x28(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x30(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x38(%r12,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    14e0 <initGeneric+0x380>
mov    0x18(%rsp),%r12
test   %r12,%r12
je     1597 <initGeneric+0x437>
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rbp,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1580 <initGeneric+0x420>
mov    0x10(%rsp),%rsi
lea    -0x1(%rsi),%eax
mov    %eax,0x44(%rsp)
xor    %edx,%edx
cmp    $0x2,%esi
setge  %al
mov    0x68(%rsp),%r15
mov    0x38(%rsp),%r11
jl     17fc <initGeneric+0x69c>
mov    %al,0x60(%rsp)
mov    0x44(%rsp),%r9d
lea    0x30(%r11),%rax
mov    %rax,0x48(%rsp)
lea    -0x5(%r14),%rsi
lea    0x18(%r11),%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%ecx
mov    $0x7,%r10d
xor    %r12d,%r12d
mov    %r9,0x8(%rsp)
jmp    1605 <initGeneric+0x4a5>
nop
add    $0x1,%rcx
add    $0x1,%r10
add    $0xffffffffffffffff,%rsi
cmp    %r9,%r12
je     17f1 <initGeneric+0x691>
mov    %r12,%rax
add    $0x1,%r12
cmp    0x88(%rsp),%r12
jge    15f0 <initGeneric+0x490>
mov    %rax,%rbx
not    %rbx
add    %r14,%rbx
mov    0x50(%rsp),%rdi
mov    (%rdi,%rax,8),%rbp
movslq %edx,%rdx
cmp    $0x4,%rbx
jb     1665 <initGeneric+0x505>
lea    (%r11,%rbx,8),%rdi
lea    0x0(,%rcx,8),%r8
add    %rbp,%r8
lea    (%rdi,%rdx,8),%rdi
cmp    %rdi,%r8
jae    170f <initGeneric+0x5af>
lea    0x0(,%r14,8),%r8
add    %rbp,%r8
lea    (%r11,%rdx,8),%rdi
cmp    %r8,%rdi
jae    170f <initGeneric+0x5af>
mov    %rcx,%rax
mov    %r14d,%edi
sub    %eax,%edi
mov    %rax,%rbx
not    %rbx
add    %r14,%rbx
and    $0x3,%rdi
je     169a <initGeneric+0x53a>
nopl   0x0(%rax)
movsd  (%r11,%rdx,8),%xmm0
add    $0x1,%rdx
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1680 <initGeneric+0x520>
cmp    $0x3,%rbx
jb     15f0 <initGeneric+0x490>
mov    %r14,%rdi
sub    %rax,%rdi
lea    0x18(,%rax,8),%rax
add    %rbp,%rax
mov    0x18(%rsp),%rbp
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rbp,8)
movsd  -0x10(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rbp,8)
movsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    16d0 <initGeneric+0x570>
add    %rbp,%rdx
jmp    15f0 <initGeneric+0x490>
mov    0x28(%rsp),%rdi
sub    %rax,%rdi
add    $0xfffffffffffffffc,%rdi
mov    %rdi,%r15
shr    $0x2,%r15
add    $0x1,%r15
cmp    $0x4,%rdi
jae    1733 <initGeneric+0x5d3>
mov    %rdx,%r11
xor    %edi,%edi
jmp    179c <initGeneric+0x63c>
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
lea    0x0(,%r10,8),%r8
add    %rbp,%r8
mov    %rdx,%r11
mov    0x48(%rsp),%rdi
lea    (%rdi,%rdx,8),%r9
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%r9,%rdi,8),%xmm0
movups -0x20(%r9,%rdi,8),%xmm1
movups %xmm0,-0x30(%r8,%rdi,8)
movups %xmm1,-0x20(%r8,%rdi,8)
movupd -0x10(%r9,%rdi,8),%xmm0
movupd (%r9,%rdi,8),%xmm1
movupd %xmm0,-0x10(%r8,%rdi,8)
movupd %xmm1,(%r8,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    1760 <initGeneric+0x600>
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
test   $0x1,%r15b
mov    %r11,%rdx
mov    0x38(%rsp),%r11
je     17d3 <initGeneric+0x673>
lea    (%rcx,%rdi,1),%r8
add    %rdx,%rdi
movupd (%r11,%rdi,8),%xmm0
movupd 0x10(%r11,%rdi,8),%xmm1
movupd %xmm0,0x0(%rbp,%r8,8)
movupd %xmm1,0x10(%rbp,%r8,8)
add    %rax,%rdx
cmp    %rax,%rbx
mov    0x68(%rsp),%r15
mov    0x8(%rsp),%r9
je     15f0 <initGeneric+0x490>
add    %rcx,%rax
jmp    1668 <initGeneric+0x508>
mov    0x60(%rsp),%al
mov    %eax,%edx
mov    0x10(%rsp),%rsi
mov    %rdx,0x8(%rsp)
test   %esi,%esi
mov    0xa0(%rsp),%rdx
mov    0xb8(%rsp),%rcx
mov    0x28(%rsp),%r12
jle    19cc <initGeneric+0x86c>
xor    %eax,%eax
mov    0x50(%rsp),%r8
jmp    183d <initGeneric+0x6dd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r14,%rax
je     18ee <initGeneric+0x78e>
mov    (%r8,%rax,8),%rbx
movq   $0x0,(%rbx,%rax,8)
test   %rax,%rax
je     1830 <initGeneric+0x6d0>
lea    -0x1(%rax),%rdi
cmp    $0x3,%rdi
jae    1860 <initGeneric+0x700>
xor    %ebp,%ebp
jmp    18b7 <initGeneric+0x757>
nopl   0x0(%rax)
mov    %rax,%r9
and    $0xfffffffffffffffc,%r9
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r8,%rbp,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    0x8(%r8,%rbp,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
mov    0x10(%r8,%rbp,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rbp,8)
mov    0x18(%r8,%rbp,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r9
jne    1870 <initGeneric+0x710>
test   $0x3,%al
je     1830 <initGeneric+0x6d0>
mov    %eax,%r9d
and    $0x3,%r9d
lea    (%rbx,%rbp,8),%r10
lea    (%r8,%rbp,8),%rbx
xor    %edi,%edi
mov    (%rbx,%rdi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r9
jne    18d0 <initGeneric+0x770>
jmp    1830 <initGeneric+0x6d0>
movslq 0x20(%rsp),%rax
movq   $0x0,0x0(%r13,%rax,8)
test   %esi,%esi
mov    0x58(%rsp),%r10
jle    19da <initGeneric+0x87a>
mov    %r14d,%r9d
and    $0xfffffffe,%r9d
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    192d <initGeneric+0x7cd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r14,%rbx
je     19ac <initGeneric+0x84c>
mov    (%r8,%rbx,8),%rbp
xor    %edi,%edi
test   %r12,%r12
je     1984 <initGeneric+0x824>
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rbx,8),%xmm1
mulsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  (%r10,%rbx,8),%xmm0
mulsd  0x8(%rbp,%rdi,8),%xmm0
mulsd  0x8(%r10,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1940 <initGeneric+0x7e0>
test   $0x1,%r14b
je     1920 <initGeneric+0x7c0>
movsd  (%r10,%rbx,8),%xmm1
mulsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%r10,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
jmp    1920 <initGeneric+0x7c0>
test   %esi,%esi
jle    19da <initGeneric+0x87a>
mov    %r14d,%eax
and    $0x3,%eax
cmp    $0x3,%r12
jae    1e9a <initGeneric+0xd3a>
xor    %ebx,%ebx
mov    0x30(%rsp),%rdi
jmp    1ef0 <initGeneric+0xd90>
movslq 0x20(%rsp),%rax
movq   $0x0,0x0(%r13,%rax,8)
mov    0x30(%rsp),%rdi
xor    %eax,%eax
call   1030 <makeEigen@plt>
cmpb   $0x0,0x8(%rsp)
mov    0xa8(%rsp),%r13
je     2210 <initGeneric+0x10b0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r15,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
xor    %edi,%edi
ucomisd 0x1600(%rip),%xmm0
seta   %dil
xor    %eax,%eax
call   1070 <assert@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1a00 <initGeneric+0x8a0>
cmpl   $0x0,0x10(%rsp)
jle    2210 <initGeneric+0x10b0>
mov    %r14d,%r10d
and    $0xfffffffc,%r10d
add    $0xfffffffffffffffc,%r10
mov    %r10,%r8
shr    $0x2,%r8
add    $0x1,%r8
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
mov    %r8d,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%r8
mov    %r9,%rdi
shl    $0x5,%rdi
xor    %ebp,%ebp
mov    0x98(%rsp),%rbx
jmp    1a8d <initGeneric+0x92d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %r14,%rbp
je     1c24 <initGeneric+0xac4>
mov    0x80(%rsp),%rax
mov    (%rax,%rbp,8),%rcx
cmpl   $0x4,0x10(%rsp)
jb     1aba <initGeneric+0x95a>
lea    (%rcx,%r14,8),%rax
cmp    %rax,%rbx
jae    1b60 <initGeneric+0xa00>
lea    (%rbx,%r14,8),%rax
cmp    %rax,%rcx
jae    1b60 <initGeneric+0xa00>
xor    %edx,%edx
mov    %r14d,%esi
sub    %edx,%esi
mov    %rdx,%rax
not    %rax
add    %r14,%rax
and    $0x7,%rsi
je     1ae7 <initGeneric+0x987>
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx)
add    $0x8,%rbx
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1ad0 <initGeneric+0x970>
cmp    $0x7,%rax
jb     1a80 <initGeneric+0x920>
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx)
movsd  0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rbx)
movsd  0x20(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x20(%rbx)
movsd  0x28(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x28(%rbx)
movsd  0x30(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x30(%rbx)
movsd  0x38(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x38(%rbx)
add    $0x40,%rbx
add    $0x8,%rdx
cmp    %rdx,%r14
jne    1af0 <initGeneric+0x990>
jmp    1a80 <initGeneric+0x920>
nopl   0x0(%rax,%rax,1)
cmp    $0xc,%r10
jae    1b6a <initGeneric+0xa0a>
xor    %eax,%eax
jmp    1bcc <initGeneric+0xa6c>
mov    %r8,%rdx
xor    %eax,%eax
nop
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups 0x20(%rcx,%rax,8),%xmm0
movups 0x30(%rcx,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups 0x40(%rcx,%rax,8),%xmm0
movups 0x50(%rcx,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movupd 0x60(%rcx,%rax,8),%xmm0
movupd 0x70(%rcx,%rax,8),%xmm1
movupd %xmm0,0x60(%rbx,%rax,8)
movupd %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdx
jne    1b70 <initGeneric+0xa10>
test   %r9,%r9
je     1c0f <initGeneric+0xaaf>
lea    (%rcx,%rax,8),%rdx
add    $0x10,%rdx
lea    (%rbx,%rax,8),%rax
add    $0x10,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rdx,%rsi,1),%xmm0
movupd (%rdx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rax,%rsi,1)
movupd %xmm1,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    1bf0 <initGeneric+0xa90>
lea    (%rbx,%r11,8),%rbx
mov    %r11,%rdx
cmp    %r14,%r11
je     1a80 <initGeneric+0x920>
jmp    1abc <initGeneric+0x95c>
cmpl   $0x0,0x10(%rsp)
jle    2210 <initGeneric+0x10b0>
lea    -0x2(%r14),%r11
lea    -0x1(%r14),%r13
mov    0x70(%rsp),%rax
lea    (%rax,%r14,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rsp)
mov    %r13,0x18(%rsp)
and    $0xfffffffffffffffc,%r13
lea    0x1(%r13),%rax
mov    %rax,0xb0(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x8(%rsp)
mov    0x44(%rsp),%r12d
mov    0x98(%rsp),%rax
lea    0x18(%rax),%r15
lea    0x8(%rax),%rdx
mov    $0xffffffffffffffff,%r9
xor    %ebp,%ebp
xor    %ecx,%ecx
mov    %r11,0x28(%rsp)
mov    %r12,0x60(%rsp)
jmp    1cc1 <initGeneric+0xb61>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
add    %r12,%rbp
mov    0xc0(%rsp),%rsi
add    %rsi,%r15
add    %rsi,%rdx
add    %r12,%r9
cmp    %r14,%rcx
je     2210 <initGeneric+0x10b0>
cmpl   $0x1,0x10(%rsp)
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%rax
je     1ca0 <initGeneric+0xb40>
mov    %rcx,%r10
imul   0x88(%rsp),%r10
mov    $0x1,%r8d
cmpq   $0x4,0x18(%rsp)
jb     1e10 <initGeneric+0xcb0>
mov    0x44(%rsp),%esi
imul   %ecx,%esi
lea    (%rsi,%r11,1),%ebx
cmp    %esi,%ebx
jl     1e10 <initGeneric+0xcb0>
mov    %r11,%rbx
shr    $0x20,%rbx
jne    1e10 <initGeneric+0xcb0>
lea    (%r10,%r14,1),%rbx
mov    %rbx,0x38(%rsp)
mov    0x98(%rsp),%r12
lea    (%r12,%r10,8),%r11
add    $0x8,%r11
mov    %r11,0x20(%rsp)
mov    0x38(%rsp),%rbx
lea    (%r12,%rbx,8),%rbx
mov    %rbx,0x38(%rsp)
movslq %esi,%rsi
lea    (%rax,%rsi,8),%r11
mov    0x48(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
lea    (%rdi,%rcx,8),%rbx
lea    (%rdi,%rcx,8),%rdi
add    $0x8,%rdi
cmp    %rsi,0x20(%rsp)
setb   0x20(%rsp)
cmp    0x38(%rsp),%r11
setb   %al
cmp    %rsi,%rbx
setb   %sil
cmp    %rdi,%r11
setb   %bl
test   %al,0x20(%rsp)
jne    1df4 <initGeneric+0xc94>
and    %bl,%sil
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%rax
mov    0x28(%rsp),%r11
mov    0x60(%rsp),%r12
jne    1e10 <initGeneric+0xcb0>
movsd  (%rdi,%rcx,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r15,%rsi,8),%xmm1
movupd (%r15,%rsi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
lea    (%rsi,%rbp,1),%ebx
movslq %ebx,%rbx
movupd %xmm1,(%rax,%rbx,8)
movupd %xmm2,0x10(%rax,%rbx,8)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1db0 <initGeneric+0xc50>
mov    0xb0(%rsp),%r8
cmp    %r13,0x18(%rsp)
je     1ca0 <initGeneric+0xb40>
jmp    1e10 <initGeneric+0xcb0>
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%rax
mov    0x28(%rsp),%r11
mov    0x60(%rsp),%r12
nopl   0x0(%rax,%rax,1)
mov    %r8,%rsi
test   $0x1,%r14b
jne    1e48 <initGeneric+0xce8>
mov    0x44(%rsp),%esi
imul   %ecx,%esi
add    $0xffffffff,%esi
add    %r8,%r10
mov    0x98(%rsp),%rbx
movsd  (%rbx,%r10,8),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
add    %r8d,%esi
movslq %esi,%rsi
movsd  %xmm0,(%rax,%rsi,8)
lea    0x1(%r8),%rsi
not    %r8
cmp    0x8(%rsp),%r8
je     1ca0 <initGeneric+0xb40>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rsi,8),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
lea    (%r9,%rsi,1),%ebx
movslq %ebx,%rbx
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
lea    (%rsi,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  %xmm0,(%rax,%rbx,8)
add    $0x2,%rsi
cmp    %rsi,%r14
jne    1e60 <initGeneric+0xd00>
jmp    1ca0 <initGeneric+0xb40>
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
xor    %ebx,%ebx
mov    0x30(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rbx,8),%rbp
movq   $0x0,0x0(%rbp,%rbx,8)
mov    0x8(%rdi,%rbx,8),%rbp
movq   $0x0,0x8(%rbp,%rbx,8)
mov    0x10(%rdi,%rbx,8),%rbp
movq   $0x0,0x10(%rbp,%rbx,8)
mov    0x18(%rdi,%rbx,8),%rbp
movq   $0x0,0x18(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r8
jne    1eb0 <initGeneric+0xd50>
test   %rax,%rax
je     1f17 <initGeneric+0xdb7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rbx,8),%rbp
movq   $0x0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1f00 <initGeneric+0xda0>
test   %esi,%esi
jle    19da <initGeneric+0x87a>
mov    0x30(%rsp),%r15
lea    0x8(%r15),%r8
lea    0x8(%r10),%rbx
xor    %eax,%eax
mov    $0x8,%edi
xorpd  %xmm2,%xmm2
mov    %r12,%rbp
xor    %ecx,%ecx
jmp    1f6d <initGeneric+0xe0d>
xchg   %ax,%ax
mov    0xb0(%rsp),%ecx
add    %r13d,%ecx
mov    0x30(%rsp),%r15
mov    0x60(%rsp),%rax
add    $0x8,%rdi
add    $0x8,%r8
add    $0x8,%rbx
add    $0xffffffffffffffff,%rbp
cmp    %r14,%rax
je     2070 <initGeneric+0xf10>
mov    %rax,%r12
add    $0x1,%rax
cmp    0x88(%rsp),%rax
jge    1f54 <initGeneric+0xdf4>
mov    %rax,0x60(%rsp)
mov    %ecx,0xb0(%rsp)
movslq %ecx,%rax
lea    (%r11,%rax,8),%r9
xor    %r13d,%r13d
mov    %rbx,0x20(%rsp)
mov    %r9,0x48(%rsp)
jmp    204b <initGeneric+0xeeb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8,%r15
mov    %rdi,%rbx
movsd  %xmm3,0x18(%rsp)
call   1080 <sqrt@plt>
movsd  0x18(%rsp),%xmm3
mov    0x48(%rsp),%r9
mov    %rbx,%rdi
mov    0x20(%rsp),%rbx
xorpd  %xmm2,%xmm2
mov    %r15,%r8
mov    0x38(%rsp),%r11
mov    0x58(%rsp),%r10
mov    0x10(%rsp),%rsi
mulsd  %xmm3,%xmm0
mov    (%r8,%r13,8),%rax
movsd  %xmm0,(%rax,%r12,8)
mov    0x30(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
lea    (%rcx,%rdi,1),%rdx
movsd  %xmm0,(%rdx,%r13,8)
movsd  (%rcx,%r12,8),%xmm0
movsd  (%rbx,%r13,8),%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%r12,8)
add    %rdi,%rax
movsd  (%rax,%r13,8),%xmm0
mulsd  (%r10,%r12,8),%xmm3
subsd  %xmm3,%xmm0
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%r13
cmp    %r13,%rbp
je     1f40 <initGeneric+0xde0>
movsd  (%r9,%r13,8),%xmm3
movsd  (%r10,%r12,8),%xmm0
mulsd  (%rbx,%r13,8),%xmm0
ucomisd %xmm2,%xmm0
jb     1fb0 <initGeneric+0xe50>
sqrtsd %xmm0,%xmm0
jmp    1fea <initGeneric+0xe8a>
mov    %r15,%rdi
mov    0xa0(%rsp),%rdx
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
call   1030 <makeEigen@plt>
mov    0x10(%rsp),%rdi
test   %edi,%edi
mov    0xa8(%rsp),%r13
mov    0x8(%rsp),%rdx
jle    21fe <initGeneric+0x109e>
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
xor    %ebp,%ebp
xorpd  %xmm1,%xmm1
mov    0x58(%rsp),%rcx
jmp    20f3 <initGeneric+0xf93>
nopl   0x0(%rax,%rax,1)
call   1080 <sqrt@plt>
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%rdx
mov    0x58(%rsp),%rcx
mov    0x10(%rsp),%rdi
mov    (%r15,%rbp,8),%rax
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbp
cmp    %r14,%rbp
je     21b4 <initGeneric+0x1054>
cmpq   $0x0,0x28(%rsp)
je     2190 <initGeneric+0x1030>
xor    %ebx,%ebx
jmp    2141 <initGeneric+0xfe1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1080 <sqrt@plt>
xorpd  %xmm1,%xmm1
mov    0x58(%rsp),%rcx
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rdx
mov    (%r15,%rbp,8),%rax
mulsd  0x8(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r12
je     2192 <initGeneric+0x1032>
movsd  (%rcx,%rbx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     2160 <initGeneric+0x1000>
sqrtsd %xmm0,%xmm0
jmp    216e <initGeneric+0x100e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1080 <sqrt@plt>
xorpd  %xmm1,%xmm1
mov    0x58(%rsp),%rcx
mov    (%r15,%rbp,8),%rax
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x8(%rcx,%rbx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     2110 <initGeneric+0xfb0>
sqrtsd %xmm0,%xmm0
jmp    211e <initGeneric+0xfbe>
xchg   %ax,%ax
xor    %ebx,%ebx
test   $0x1,%r14b
je     20e6 <initGeneric+0xf86>
movsd  (%rcx,%rbx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     20c0 <initGeneric+0xf60>
sqrtsd %xmm0,%xmm0
jmp    20d8 <initGeneric+0xf78>
test   %edi,%edi
jle    21fe <initGeneric+0x109e>
xor    %eax,%eax
movsd  0xe3e(%rip),%xmm0
mov    0x80(%rsp),%r9
mov    0x78(%rsp),%r10
mov    0xa0(%rsp),%r11
mov    0x28(%rsp),%r12
nopl   0x0(%rax)
movsd  (%r11,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
ja     260c <initGeneric+0x14ac>
add    $0x1,%rax
cmp    %rax,%r14
jne    21e0 <initGeneric+0x1080>
jmp    2732 <initGeneric+0x15d2>
test   %dl,%dl
mov    0x68(%rsp),%r15
mov    0x28(%rsp),%r12
jne    19f9 <initGeneric+0x899>
mov    0x94(%rsp),%eax
test   %eax,%eax
mov    0x50(%rsp),%r15
mov    0x10(%rsp),%r10
mov    0xc8(%rsp),%r11
jle    2559 <initGeneric+0x13f9>
lea    0x0(,%r14,8),%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x1(%r14),%rax
mov    %rax,0x18(%rsp)
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    %rcx,%rdx
mov    %rdx,0x70(%rsp)
lea    0x30(%r11),%rbx
lea    0x8(%r11),%r12
xor    %r13d,%r13d
mov    0x80(%rsp),%rbp
jmp    22bd <initGeneric+0x115d>
add    $0x1,%r13
mov    0xc0(%rsp),%rax
add    %rax,%rbx
add    %rax,%r12
cmp    0x48(%rsp),%r13
je     2497 <initGeneric+0x1337>
mov    0xd0(%rsp),%rax
mov    (%rax,%r13,4),%r15d
test   %r10d,%r10d
jle    22fc <initGeneric+0x119c>
mov    %r13d,%eax
imul   %r10d,%eax
cltq
lea    (%r11,%rax,8),%rdi
xor    %esi,%esi
mov    0x28(%rsp),%rdx
call   1060 <memset@plt>
mov    0xc8(%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x80(%rsp),%rbp
test   %r15d,%r15d
je     22a0 <initGeneric+0x1140>
test   %r10d,%r10d
jle    22a0 <initGeneric+0x1140>
mov    %r13,%rax
imul   0x88(%rsp),%rax
lea    (%rax,%r14,1),%rcx
lea    (%r11,%rax,8),%r9
lea    (%r11,%rcx,8),%r8
xor    %esi,%esi
jmp    233d <initGeneric+0x11dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %r14,%rsi
je     22a0 <initGeneric+0x1140>
bt     %esi,%r15d
jae    2330 <initGeneric+0x11d0>
mov    0x0(%rbp,%rsi,8),%rdi
cmp    $0x4,%r10d
jb     235c <initGeneric+0x11fc>
lea    (%rdi,%r14,8),%rcx
cmp    %rcx,%r9
jae    23c3 <initGeneric+0x1263>
cmp    %r8,%rdi
jae    23c3 <initGeneric+0x1263>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r14b
je     2383 <initGeneric+0x1223>
movsd  (%rdi,%rdx,8),%xmm0
lea    (%rdx,%rax,1),%rcx
addsd  (%r11,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
cmp    %rdx,0x18(%rsp)
je     2330 <initGeneric+0x11d0>
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm0
addsd  -0x8(%r12,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm0
addsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    2390 <initGeneric+0x1230>
jmp    2330 <initGeneric+0x11d0>
cmpq   $0x0,0x38(%rsp)
je     248c <initGeneric+0x132c>
mov    0x70(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd (%rdi,%rdx,8),%xmm0
movupd 0x10(%rdi,%rdx,8),%xmm1
movupd -0x30(%rbx,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rbx,%rdx,8),%xmm1
movupd (%rbx,%rdx,8),%xmm3
movupd %xmm2,-0x30(%rbx,%rdx,8)
movupd %xmm0,-0x20(%rbx,%rdx,8)
movupd 0x20(%rdi,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x30(%rdi,%rdx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbx,%rdx,8)
movupd %xmm1,(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    23e0 <initGeneric+0x1280>
testb  $0x1,0x20(%rsp)
je     2476 <initGeneric+0x1316>
movupd (%rdi,%rdx,8),%xmm0
movupd 0x10(%rdi,%rdx,8),%xmm1
add    %rax,%rdx
movupd (%r11,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r11,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r11,%rdx,8)
movupd %xmm0,0x10(%r11,%rdx,8)
mov    0x8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r14,%rcx
je     2330 <initGeneric+0x11d0>
jmp    235e <initGeneric+0x11fe>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
jne    2446 <initGeneric+0x12e6>
jmp    2476 <initGeneric+0x1316>
cmpl   $0x0,0x94(%rsp)
mov    0x50(%rsp),%r15
mov    0xc0(%rsp),%rbx
jle    2559 <initGeneric+0x13f9>
mov    %r14d,%eax
and    $0xfffffffe,%eax
lea    0x8(%r11),%rcx
xor    %ebp,%ebp
movsd  0xb4a(%rip),%xmm0
movabs $0x3fefffffff768fa1,%rsi
ff ef 3f
jmp    24ee <initGeneric+0x138e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
add    %rbx,%rcx
cmp    0x48(%rsp),%rbp
je     2559 <initGeneric+0x13f9>
test   %r10d,%r10d
jle    24e0 <initGeneric+0x1380>
cmpq   $0x0,0x18(%rsp)
je     2530 <initGeneric+0x13d0>
xor    %edi,%edi
jmp    2509 <initGeneric+0x13a9>
nop
add    $0x2,%rdi
cmp    %rdi,%rax
je     2532 <initGeneric+0x13d2>
movsd  -0x8(%rcx,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    251a <initGeneric+0x13ba>
mov    %rsi,-0x8(%rcx,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    2500 <initGeneric+0x13a0>
mov    %rsi,(%rcx,%rdi,8)
jmp    2500 <initGeneric+0x13a0>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
test   $0x1,%r14b
je     24e0 <initGeneric+0x1380>
mov    %rbp,%rdx
imul   0x88(%rsp),%rdx
add    %rdx,%rdi
movsd  (%r11,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    24e0 <initGeneric+0x1380>
mov    %rsi,(%r11,%rdi,8)
jmp    24e0 <initGeneric+0x1380>
test   %r10d,%r10d
mov    0x80(%rsp),%r12
mov    0x30(%rsp),%rbp
jle    259b <initGeneric+0x143b>
xor    %ebx,%ebx
nopl   (%rax)
mov    (%r12,%rbx,8),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0x0(%rbp,%rbx,8),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    (%r15,%rbx,8),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    2570 <initGeneric+0x1410>
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0x58(%rsp),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0xb8(%rsp),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0xa0(%rsp),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0x78(%rsp),%rdi
xor    %eax,%eax
call   1050 <rax_free@plt>
mov    0x68(%rsp),%rdi
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <rax_free@plt>
test   %eax,%eax
je     2732 <initGeneric+0x15d2>
movsd  (%r11),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  %xmm1,(%r11)
mov    (%r15,%rax,8),%rax
mov    (%r15),%rcx
test   %r12,%r12
je     267b <initGeneric+0x151b>
mov    %r14d,%esi
and    $0xfffffffe,%esi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm1
movsd  (%rcx,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
movsd  %xmm1,(%rcx,%rdx,8)
addsd  %xmm1,%xmm0
movsd  0x8(%rax,%rdx,8),%xmm1
movsd  0x8(%rcx,%rdx,8),%xmm2
movsd  %xmm2,0x8(%rax,%rdx,8)
movsd  %xmm1,0x8(%rcx,%rdx,8)
addsd  %xmm1,%xmm0
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    263c <initGeneric+0x14dc>
jmp    2681 <initGeneric+0x1521>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
test   $0x1,%r14b
je     269f <initGeneric+0x153f>
movsd  (%rax,%rdx,8),%xmm1
movsd  (%rcx,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
movsd  %xmm1,(%rcx,%rdx,8)
addsd  %xmm1,%xmm0
mov    (%r15),%rax
cmp    $0x2,%r14d
jae    26ac <initGeneric+0x154c>
xor    %ecx,%ecx
jmp    271b <initGeneric+0x15bb>
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2700 <initGeneric+0x15a0>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %esi,%esi
movupd (%rax,%rsi,8),%xmm2
movupd 0x10(%rax,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdx
jne    26d6 <initGeneric+0x1576>
jmp    2702 <initGeneric+0x15a2>
xor    %esi,%esi
test   $0x1,%bpl
je     2716 <initGeneric+0x15b6>
movupd (%rax,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rsi,8)
cmp    %r14,%rcx
je     2732 <initGeneric+0x15d2>
movsd  (%rax,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    271b <initGeneric+0x15bb>
test   %edi,%edi
jle    281d <initGeneric+0x16bd>
mov    %r14d,%eax
and    $0x3,%eax
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
xor    %edx,%edx
movapd 0x8cf(%rip),%xmm0
movsd  0x8af(%rip),%xmm1
jmp    277b <initGeneric+0x161b>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm2
divsd  (%rsi),%xmm2
movsd  %xmm2,(%r10,%rdx,8)
add    $0x1,%rdx
cmp    %r14,%rdx
je     281d <initGeneric+0x16bd>
movsd  (%r11,%rdx,8),%xmm2
xorpd  %xmm0,%xmm2
mov    0x68(%rsp),%rcx
movlpd %xmm2,(%rcx,%rdx,8)
mov    (%r9,%rdx,8),%rsi
xor    %edi,%edi
cmp    $0x3,%r12
jb     27eb <initGeneric+0x168b>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rdi,8),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,(%rsi,%rdi,8)
mov    0x8(%r15,%rdi,8),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,0x8(%rsi,%rdi,8)
mov    0x10(%r15,%rdi,8),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,0x10(%rsi,%rdi,8)
mov    0x18(%r15,%rdi,8),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,0x18(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r8
jne    27a0 <initGeneric+0x1640>
test   %rax,%rax
je     2760 <initGeneric+0x1600>
lea    (%rsi,%rdi,8),%rbp
lea    (%r15,%rdi,8),%rdi
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%rdi,%rbx,8),%rcx
movsd  (%rcx,%rdx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rax
jne    2800 <initGeneric+0x16a0>
jmp    2760 <initGeneric+0x1600>
cmpb   $0x0,0x8(%rsp)
mov    0x68(%rsp),%r15
jne    19f9 <initGeneric+0x899>
jmp    1a2c <initGeneric+0x8cc>

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

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