int glassofast(const int n, double **S, double **L, const double thr,
               const int maxit, int approxflg, int warm, double **X,
               double **W) {
  int i, j, ii, iter, jj;
  double a, b, c, delta, dlx, dw, shr, sum, thrlasso, tmp, wd[5000 * 21],
      wxj[5000 * 21];
  for (shr = ii = 0; ii < n; ii++)
    for (jj = 0; jj < n; jj++)
      shr += fabs(S[ii][jj]);
  for (i = 0; i < n; i++)
    shr -= fabs(S[i][i]);
  if (shr == 0.0) {
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++)
        W[ii][jj] = X[ii][jj] = 0.0;
    for (i = 0; i < n; i++)
      W[i][i] = W[i][i] + L[i][i];
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++)
        X[ii][jj] = 0.0;
    for (i = 0; i < n; i++)
      X[i][i] = 1.0 / ((W[i][i]) > ((1.1e-15)) ? (W[i][i]) : ((1.1e-15)));
    return 0;
  }
  shr *= thr / (n - 1);
  thrlasso = shr / n;
  if (thrlasso < 2 * (1.1e-15))
    thrlasso = 2 * (1.1e-15);
  if (!warm) {
    for (ii = 0; ii < n; ii++)
      for (jj = 0; jj < n; jj++) {
        W[ii][jj] = S[ii][jj];
        X[ii][jj] = 0.0;
      }
  } else {
    for (i = 0; i < n; i++) {
      for (ii = 0; ii < n; ii++)
        X[i][ii] = -X[i][ii] / X[i][i];
      X[i][i] = 0.0;
    }
  }
  for (i = 0; i < n; i++) {
    wd[i] = S[i][i] + L[i][i];
    W[i][i] = wd[i];
  }
  for (iter = 1; iter <= maxit; iter++) {
    dw = 0.0;
#pragma omp parallel for default(shared) private(i, j, ii, wxj, a, b, c, dlx,  \
                                                 delta, sum)
    for (j = 0; j < n; j++) {
      for (ii = 0; ii < n; ii++)
        wxj[ii] = 0.0;
      for (i = 0; i < n; i++)
        if (X[j][i] != 0.0)
          for (ii = 0; ii < n; ii++)
            wxj[ii] += W[i][ii] * X[j][i];
      for (;;) {
        dlx = 0.0;
        for (i = 0; i < n; i++) {
          if (i != j && L[j][i] < (1e9)) {
            a = S[j][i] - wxj[i] + wd[i] * X[j][i];
            b = fabs(a) - L[j][i];
            if (b <= 0.0)
              c = 0.0;
            else if (a >= 0.0)
              c = b / wd[i];
            else
              c = -b / wd[i];
            delta = c - X[j][i];
            if (delta != 0.0 && (!approxflg || fabs(delta) > 1e-6)) {
              X[j][i] = c;
              for (ii = 0; ii < n; ii++)
                wxj[ii] += W[i][ii] * delta;
              if (fabs(delta) > dlx)
                dlx = fabs(delta);
            }
          }
        }
        if (dlx < thrlasso)
          break;
      }
      wxj[j] = wd[j];
      for (sum = ii = 0; ii < n; ii++)
        sum += fabs(wxj[ii] - W[j][ii]);
#pragma omp critical
      if (sum > dw)
        dw = sum;
      for (ii = 0; ii < n; ii++)
        W[j][ii] = wxj[ii];
      for (ii = 0; ii < n; ii++)
        W[ii][j] = wxj[ii];
    }
    if (dw <= shr)
      break;
  }
  for (i = 0; i < n; i++) {
    for (sum = ii = 0; ii < n; ii++)
      sum += X[i][ii] * W[i][ii];
    tmp = 1.0 / (wd[i] - sum);
    for (ii = 0; ii < n; ii++)
      X[i][ii] = -tmp * X[i][ii];
    X[i][i] = tmp;
  }
  for (i = 0; i < n - 1; i++) {
    for (ii = i + 1; ii < n; ii++) {
      X[i][ii] = 0.5 * (X[i][ii] + X[ii][i]);
      X[ii][i] = X[i][ii];
    }
  }
  return iter;
}


x86 assembly (clang, -O0):
<glassofast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x19a2a0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11a7 <glassofast+0xa7>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1194 <glassofast+0x94>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xeb8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1150 <glassofast+0x50>
jmp    1199 <glassofast+0x99>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    113d <glassofast+0x3d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f6 <glassofast+0xf6>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe5a(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ae <glassofast+0xae>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13f8 <glassofast+0x2f8>
jp     13f8 <glassofast+0x2f8>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1285 <glassofast+0x185>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1272 <glassofast+0x172>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1228 <glassofast+0x128>
jmp    1277 <glassofast+0x177>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1215 <glassofast+0x115>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12e5 <glassofast+0x1e5>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    128c <glassofast+0x18c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1344 <glassofast+0x244>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1331 <glassofast+0x231>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12ff <glassofast+0x1ff>
jmp    1336 <glassofast+0x236>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12ec <glassofast+0x1ec>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ec <glassofast+0x2ec>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xcb4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13a0 <glassofast+0x2a0>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x19a318(%rbp)
ff
jmp    13b5 <glassofast+0x2b5>
movsd  0xc80(%rip),%xmm0
movsd  %xmm0,-0x19a318(%rbp)
ff
jmp    13b5 <glassofast+0x2b5>
movsd  -0x19a318(%rbp),%xmm1
ff
movsd  0xc4b(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    134b <glassofast+0x24b>
movl   $0x0,-0x4(%rbp)
jmp    1d1c <glassofast+0xc1c>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xbcd(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1451 <glassofast+0x351>
movsd  0xbb7(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x2c(%rbp)
jne    14e9 <glassofast+0x3e9>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14e4 <glassofast+0x3e4>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d1 <glassofast+0x3d1>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1475 <glassofast+0x375>
jmp    14d6 <glassofast+0x3d6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1462 <glassofast+0x362>
jmp    159e <glassofast+0x49e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1599 <glassofast+0x499>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1573 <glassofast+0x473>
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1503 <glassofast+0x403>
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14f0 <glassofast+0x3f0>
jmp    159e <glassofast+0x49e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1618 <glassofast+0x518>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0xcd1d0(%rbp,%rax,8)
f3 ff
movslq -0x30(%rbp),%rax
movsd  -0xcd1d0(%rbp,%rax,8),%xmm0
f3 ff
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15a5 <glassofast+0x4a5>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1b20 <glassofast+0xa20>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1af4 <glassofast+0x9f4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1677 <glassofast+0x577>
movslq -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x19a310(%rbp,%rax,8)
e6 ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    164d <glassofast+0x54d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1738 <glassofast+0x638>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16b7 <glassofast+0x5b7>
jp     16b7 <glassofast+0x5b7>
jmp    1725 <glassofast+0x625>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1720 <glassofast+0x620>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x38(%rbp),%rax
movsd  -0x19a310(%rbp,%rax,8),%xmm1
e6 ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x19a310(%rbp,%rax,8)
e6 ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16be <glassofast+0x5be>
jmp    1725 <glassofast+0x625>
jmp    172a <glassofast+0x62a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    167e <glassofast+0x57e>
jmp    173d <glassofast+0x63d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19a6 <glassofast+0x8a6>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1993 <glassofast+0x893>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  0x89c(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1993 <glassofast+0x893>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x30(%rbp),%rax
subsd  -0x19a310(%rbp,%rax,8),%xmm1
e6 ff
movslq -0x30(%rbp),%rax
movsd  -0xcd1d0(%rbp,%rax,8),%xmm0
f3 ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x84c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jb     181d <glassofast+0x71d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    187e <glassofast+0x77e>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     184b <glassofast+0x74b>
movsd  -0x50(%rbp),%xmm0
movslq -0x30(%rbp),%rax
divsd  -0xcd1d0(%rbp,%rax,8),%xmm0
f3 ff
movsd  %xmm0,-0x58(%rbp)
jmp    1879 <glassofast+0x779>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movslq -0x30(%rbp),%rax
divsd  -0xcd1d0(%rbp,%rax,8),%xmm0
f3 ff
movsd  %xmm0,-0x58(%rbp)
jmp    187e <glassofast+0x77e>
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18ba <glassofast+0x7ba>
jp     18ba <glassofast+0x7ba>
jmp    198e <glassofast+0x88e>
cmpl   $0x0,-0x28(%rbp)
je     18e6 <glassofast+0x7e6>
movsd  -0x60(%rbp),%xmm0
movaps 0x760(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x744(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    198e <glassofast+0x88e>
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1959 <glassofast+0x859>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
movslq -0x38(%rbp),%rax
movsd  -0x19a310(%rbp,%rax,8),%xmm1
e6 ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x19a310(%rbp,%rax,8)
e6 ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1907 <glassofast+0x807>
movsd  -0x60(%rbp),%xmm0
movaps 0x6cb(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1989 <glassofast+0x889>
movsd  -0x60(%rbp),%xmm0
movaps 0x6b0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    198e <glassofast+0x88e>
jmp    1993 <glassofast+0x893>
jmp    1998 <glassofast+0x898>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    174c <glassofast+0x64c>
movsd  -0x68(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    19c2 <glassofast+0x8c2>
jmp    19c7 <glassofast+0x8c7>
jmp    173d <glassofast+0x63d>
movslq -0x34(%rbp),%rax
movsd  -0xcd1d0(%rbp,%rax,8),%xmm0
f3 ff
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x19a310(%rbp,%rax,8)
e6 ff
movl   $0x0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a41 <glassofast+0x941>
movslq -0x38(%rbp),%rax
movsd  -0x19a310(%rbp,%rax,8),%xmm0
e6 ff
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x60b(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19f0 <glassofast+0x8f0>
movsd  -0x80(%rbp),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1a5b <glassofast+0x95b>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a9e <glassofast+0x99e>
movslq -0x38(%rbp),%rax
movsd  -0x19a310(%rbp,%rax,8),%xmm0
e6 ff
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a62 <glassofast+0x962>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1ae1 <glassofast+0x9e1>
movslq -0x38(%rbp),%rax
movsd  -0x19a310(%rbp,%rax,8),%xmm0
e6 ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1aa5 <glassofast+0x9a5>
jmp    1ae6 <glassofast+0x9e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    163a <glassofast+0x53a>
movsd  -0x70(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1b0d <glassofast+0xa0d>
jmp    1b20 <glassofast+0xa20>
jmp    1b12 <glassofast+0xa12>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    161f <glassofast+0x51f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c53 <glassofast+0xb53>
movl   $0x0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b98 <glassofast+0xa98>
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b42 <glassofast+0xa42>
movslq -0x30(%rbp),%rax
movsd  -0xcd1d0(%rbp,%rax,8),%xmm1
f3 ff
subsd  -0x80(%rbp),%xmm1
movsd  0x45e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c28 <glassofast+0xb28>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bc5 <glassofast+0xac5>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b27 <glassofast+0xa27>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d16 <glassofast+0xc16>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1d03 <glassofast+0xc03>
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x356(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c74 <glassofast+0xb74>
jmp    1d08 <glassofast+0xc08>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c5a <glassofast+0xb5a>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x19a2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<glassofast>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x19a318,%rsp
test   %edi,%edi
jle    24db <glassofast+0x13bb>
mov    %rdx,%r10
mov    %r8d,0x4c(%rsp)
mov    0x19a358(%rsp),%r8
mov    0x19a350(%rsp),%r11
mov    %edi,%ebp
lea    -0x1(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %ebp,%edx
and    $0xfffffffc,%edx
xorpd  %xmm5,%xmm5
xor    %r14d,%r14d
movapd 0x1e8b(%rip),%xmm6
movapd 0x1e83(%rip),%xmm7
mov    %rsi,0x10(%rsp)
jmp    11a2 <glassofast+0x82>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
cmp    %rbp,%r14
mov    0x10(%rsp),%rsi
je     124b <glassofast+0x12b>
mov    (%rsi,%r14,8),%rsi
cmpq   $0x3,0x18(%rsp)
jae    11c0 <glassofast+0xa0>
xor    %ebx,%ebx
jmp    1214 <glassofast+0xf4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
movapd %xmm5,%xmm1
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm2
movsd  0x8(%rsi,%rbx,8),%xmm3
movsd  0x10(%rsi,%rbx,8),%xmm4
movsd  0x18(%rsi,%rbx,8),%xmm5
andpd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
andpd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
andpd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
andpd  %xmm7,%xmm5
addsd  %xmm4,%xmm5
add    $0x4,%rbx
movapd %xmm5,%xmm1
cmp    %rbx,%rdx
jne    11d0 <glassofast+0xb0>
test   %rax,%rax
je     1190 <glassofast+0x70>
lea    (%rsi,%rbx,8),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rbx,8),%xmm1
andpd  %xmm6,%xmm1
addsd  %xmm1,%xmm5
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1230 <glassofast+0x110>
jmp    1190 <glassofast+0x70>
test   %edi,%edi
mov    %rdi,0x8(%rsp)
mov    %r10,0x20(%rsp)
jle    126d <glassofast+0x14d>
mov    %ebp,%eax
and    $0x3,%eax
cmpq   $0x3,0x18(%rsp)
jae    1288 <glassofast+0x168>
xor    %ebx,%ebx
jmp    130c <glassofast+0x1ec>
xor    %eax,%eax
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm5
jne    1540 <glassofast+0x420>
jnp    24dd <glassofast+0x13bd>
jmp    1540 <glassofast+0x420>
mov    %ebp,%r14d
and    $0xfffffffc,%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdx
mov    (%rdx,%rbx,8),%rsi
mov    0x10(%rsp),%rdx
mov    0x8(%rdx,%rbx,8),%rdx
movsd  (%rsi,%rbx,8),%xmm1
andpd  %xmm7,%xmm1
subsd  %xmm1,%xmm5
movsd  0x8(%rdx,%rbx,8),%xmm1
andpd  %xmm7,%xmm1
subsd  %xmm1,%xmm5
mov    0x10(%rsp),%rdx
mov    0x10(%rdx,%rbx,8),%rsi
movsd  0x10(%rsi,%rbx,8),%xmm1
andpd  %xmm7,%xmm1
subsd  %xmm1,%xmm5
mov    0x10(%rsp),%rdx
mov    0x18(%rdx,%rbx,8),%rsi
movsd  0x18(%rsi,%rbx,8),%xmm1
mov    0x10(%rsp),%rsi
andpd  %xmm7,%xmm1
subsd  %xmm1,%xmm5
add    $0x4,%rbx
cmp    %rbx,%r14
jne    12a0 <glassofast+0x180>
test   %rax,%rax
je     133b <glassofast+0x21b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rbx,8),%rdx
movsd  (%rdx,%rbx,8),%xmm1
andpd  %xmm6,%xmm1
subsd  %xmm1,%xmm5
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1320 <glassofast+0x200>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm5
jne    1540 <glassofast+0x420>
jp     1540 <glassofast+0x420>
test   %edi,%edi
jle    24db <glassofast+0x13bb>
mov    %ebp,%r10d
and    $0xfffffffc,%r10d
add    $0xfffffffffffffffc,%r10
mov    %r10,%r9
shr    $0x2,%r9
add    $0x1,%r9
mov    %ebp,%r11d
and    $0xfffffffc,%r11d
movabs $0x7ffffffffffffffe,%r8
ff ff 7f
add    $0xfffffffffffffffe,%r8
and    %r9,%r8
and    $0x3,%r9d
mov    %ebp,%r14d
and    $0x3,%r14d
mov    %r9,%r15
shl    $0x5,%r15
xor    %r12d,%r12d
xorpd  %xmm0,%xmm0
jmp    13ad <glassofast+0x28d>
add    $0x1,%r12
cmp    %rbp,%r12
je     1610 <glassofast+0x4f0>
mov    0x19a350(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    0x19a358(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
cmpl   $0x4,0x8(%rsp)
jb     13e6 <glassofast+0x2c6>
lea    (%rcx,%rbp,8),%rdx
cmp    %rdx,%rax
jae    1480 <glassofast+0x360>
lea    (%rax,%rbp,8),%rdx
cmp    %rdx,%rcx
jae    1480 <glassofast+0x360>
xor    %edi,%edi
mov    %rdi,%rsi
not    %rsi
add    %rbp,%rsi
test   %r14,%r14
je     141a <glassofast+0x2fa>
mov    %r14,%rdx
nopl   0x0(%rax)
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,(%rcx,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1400 <glassofast+0x2e0>
cmp    $0x3,%rsi
jb     13a0 <glassofast+0x280>
movq   $0x0,(%rax,%rdi,8)
movq   $0x0,(%rcx,%rdi,8)
movq   $0x0,0x8(%rax,%rdi,8)
movq   $0x0,0x8(%rcx,%rdi,8)
movq   $0x0,0x10(%rax,%rdi,8)
movq   $0x0,0x10(%rcx,%rdi,8)
movq   $0x0,0x18(%rax,%rdi,8)
movq   $0x0,0x18(%rcx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1420 <glassofast+0x300>
jmp    13a0 <glassofast+0x280>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0xc,%r10
jae    148a <glassofast+0x36a>
xor    %edi,%edi
jmp    14f8 <glassofast+0x3d8>
mov    %r8,%rsi
xor    %edi,%edi
nop
movupd %xmm0,(%rax,%rdi,8)
movupd %xmm0,0x10(%rax,%rdi,8)
movupd %xmm0,(%rcx,%rdi,8)
movupd %xmm0,0x10(%rcx,%rdi,8)
movupd %xmm0,0x20(%rax,%rdi,8)
movupd %xmm0,0x30(%rax,%rdi,8)
movupd %xmm0,0x20(%rcx,%rdi,8)
movupd %xmm0,0x30(%rcx,%rdi,8)
movupd %xmm0,0x40(%rax,%rdi,8)
movupd %xmm0,0x50(%rax,%rdi,8)
movupd %xmm0,0x40(%rcx,%rdi,8)
movupd %xmm0,0x50(%rcx,%rdi,8)
movupd %xmm0,0x60(%rax,%rdi,8)
movupd %xmm0,0x70(%rax,%rdi,8)
movupd %xmm0,0x60(%rcx,%rdi,8)
movupd %xmm0,0x70(%rcx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1490 <glassofast+0x370>
test   %r9,%r9
je     152f <glassofast+0x40f>
lea    (%rcx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,8),%rdx
add    $0x10,%rdx
xor    %edi,%edi
nop
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm0,(%rdx,%rdi,1)
movupd %xmm0,-0x10(%rsi,%rdi,1)
movupd %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r15
jne    1510 <glassofast+0x3f0>
mov    %r11,%rdi
cmp    %rbp,%r11
je     13a0 <glassofast+0x280>
jmp    13e8 <glassofast+0x2c8>
movabs $0x7ffffffffffffffe,%r14
ff ff 7f
test   %r9d,%r9d
mov    %rcx,0x50(%rsp)
je     16c2 <glassofast+0x5a2>
test   %edi,%edi
jle    19c1 <glassofast+0x8a1>
mov    %ebp,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
movapd 0x1aa1(%rip),%xmm1
movapd 0x1a99(%rip),%xmm2
jmp    159a <glassofast+0x47a>
nopl   0x0(%rax)
movq   $0x0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rbp,%rcx
mov    0x10(%rsp),%rsi
je     1906 <glassofast+0x7e6>
mov    0x19a350(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
cmpq   $0x0,0x18(%rsp)
je     15f0 <glassofast+0x4d0>
xor    %esi,%esi
movsd  (%rdx,%rsi,8),%xmm3
movsd  0x8(%rdx,%rsi,8),%xmm4
xorpd  %xmm2,%xmm3
divsd  (%rdx,%rcx,8),%xmm3
movsd  %xmm3,(%rdx,%rsi,8)
xorpd  %xmm2,%xmm4
divsd  (%rdx,%rcx,8),%xmm4
movsd  %xmm4,0x8(%rdx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    15b0 <glassofast+0x490>
test   $0x1,%bpl
je     1580 <glassofast+0x460>
jmp    15f8 <glassofast+0x4d8>
nopl   0x0(%rax)
xor    %esi,%esi
test   $0x1,%bpl
je     1580 <glassofast+0x460>
movsd  (%rdx,%rsi,8),%xmm3
xorpd  %xmm1,%xmm3
divsd  (%rdx,%rcx,8),%xmm3
movsd  %xmm3,(%rdx,%rsi,8)
jmp    1580 <glassofast+0x460>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
jle    24db <glassofast+0x13bb>
cmpq   $0x0,0x18(%rsp)
je     2347 <glassofast+0x1227>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
mov    0x19a358(%rsp),%rdi
mov    0x20(%rsp),%rbx
xchg   %ax,%ax
mov    (%rdi,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm0
mov    (%rbx,%rax,8),%rsi
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    0x8(%rdi,%rax,8),%rdx
movsd  0x8(%rdx,%rax,8),%xmm0
mov    0x8(%rbx,%rax,8),%rsi
addsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1640 <glassofast+0x520>
test   $0x1,%bpl
je     1699 <glassofast+0x579>
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    (%rbx,%rax,8),%rdx
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
test   %r8d,%r8d
jle    24db <glassofast+0x13bb>
mov    %rbp,%r14
shl    $0x3,%r14
mov    %ebp,%ebx
and    $0x7,%ebx
cmpq   $0x7,0x18(%rsp)
jae    2376 <glassofast+0x1256>
xor    %r12d,%r12d
jmp    2410 <glassofast+0x12f0>
test   %edi,%edi
jle    19c1 <glassofast+0x8a1>
mov    %ebp,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    %r14,%rcx
mov    %rcx,0x30(%rsp)
mov    %ebp,%r14d
and    $0x3,%r14d
xor    %r15d,%r15d
xorpd  %xmm1,%xmm1
jmp    171d <glassofast+0x5fd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
cmp    %rbp,%r15
je     1906 <glassofast+0x7e6>
mov    (%rsi,%r15,8),%rcx
mov    (%r8,%r15,8),%rdx
mov    0x19a350(%rsp),%rax
mov    (%rax,%r15,8),%rax
cmp    $0x4,%edi
jae    17e0 <glassofast+0x6c0>
xor    %ebx,%ebx
mov    %rbx,%r12
not    %r12
add    %rbp,%r12
test   %r14,%r14
je     176c <glassofast+0x64c>
mov    %r14,%rsi
nopl   (%rax)
movsd  (%rcx,%rbx,8),%xmm2
movsd  %xmm2,(%rdx,%rbx,8)
movq   $0x0,(%rax,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rsi
jne    1750 <glassofast+0x630>
cmp    $0x3,%r12
mov    0x10(%rsp),%rsi
jb     1710 <glassofast+0x5f0>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm2
movsd  %xmm2,(%rdx,%rbx,8)
movq   $0x0,(%rax,%rbx,8)
movsd  0x8(%rcx,%rbx,8),%xmm2
movsd  %xmm2,0x8(%rdx,%rbx,8)
movq   $0x0,0x8(%rax,%rbx,8)
movsd  0x10(%rcx,%rbx,8),%xmm2
movsd  %xmm2,0x10(%rdx,%rbx,8)
movq   $0x0,0x10(%rax,%rbx,8)
movsd  0x18(%rcx,%rbx,8),%xmm2
movsd  %xmm2,0x18(%rdx,%rbx,8)
movq   $0x0,0x18(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    1780 <glassofast+0x660>
jmp    1710 <glassofast+0x5f0>
nop
lea    (%rdx,%rbp,8),%rsi
lea    (%rax,%rbp,8),%r12
lea    (%rcx,%rbp,8),%rdi
cmp    %r12,%rdx
setb   %r9b
cmp    %rsi,%rax
setb   %r10b
cmp    %rdi,%rdx
setb   %r8b
cmp    %rsi,%rcx
setb   %r13b
cmp    %rdi,%rax
setb   %sil
cmp    %r12,%rcx
setb   %r12b
test   %r10b,%r9b
jne    18ad <glassofast+0x78d>
and    %r13b,%r8b
jne    18ad <glassofast+0x78d>
mov    $0x0,%ebx
and    %r12b,%sil
mov    0x19a358(%rsp),%r8
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%r10
jne    173c <glassofast+0x61c>
cmpq   $0x0,0x40(%rsp)
je     18c6 <glassofast+0x7a6>
mov    0x30(%rsp),%rsi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rbx,8),%xmm2
movups 0x10(%rcx,%rbx,8),%xmm3
movups %xmm2,(%rdx,%rbx,8)
movups %xmm3,0x10(%rdx,%rbx,8)
movupd %xmm1,(%rax,%rbx,8)
movupd %xmm1,0x10(%rax,%rbx,8)
movupd 0x20(%rcx,%rbx,8),%xmm2
movupd 0x30(%rcx,%rbx,8),%xmm3
movupd %xmm2,0x20(%rdx,%rbx,8)
movupd %xmm3,0x30(%rdx,%rbx,8)
movupd %xmm1,0x20(%rax,%rbx,8)
movupd %xmm1,0x30(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1860 <glassofast+0x740>
jmp    18c8 <glassofast+0x7a8>
xor    %ebx,%ebx
mov    0x19a358(%rsp),%r8
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%r10
jmp    173c <glassofast+0x61c>
xor    %ebx,%ebx
testb  $0x1,0x38(%rsp)
mov    0x10(%rsp),%rsi
je     18f5 <glassofast+0x7d5>
movupd (%rcx,%rbx,8),%xmm2
movupd 0x10(%rcx,%rbx,8),%xmm3
movupd %xmm2,(%rdx,%rbx,8)
movupd %xmm3,0x10(%rdx,%rbx,8)
movupd %xmm1,(%rax,%rbx,8)
movupd %xmm1,0x10(%rax,%rbx,8)
mov    %r11,%rbx
cmp    %rbp,%r11
je     1710 <glassofast+0x5f0>
jmp    173c <glassofast+0x61c>
test   %edi,%edi
mov    0x19a350(%rsp),%r11
mov    0x50(%rsp),%rcx
movabs $0x7ffffffffffffffe,%r14
ff ff 7f
jle    19c1 <glassofast+0x8a1>
cmpq   $0x0,0x18(%rsp)
je     2365 <glassofast+0x1245>
mov    %ebp,%ebx
and    $0xfffffffe,%ebx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
mov    (%r10,%rax,8),%rdx
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,0xcd1d0(%rsp,%rax,8)
mov    (%r8,%rax,8),%rdx
movsd  %xmm1,(%rdx,%rax,8)
mov    0x8(%rsi,%rax,8),%rdx
movsd  0x8(%rdx,%rax,8),%xmm1
mov    0x8(%r10,%rax,8),%rdx
addsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,0xcd1d8(%rsp,%rax,8)
mov    0x8(%r8,%rax,8),%rdx
movsd  %xmm1,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1940 <glassofast+0x820>
test   $0x1,%bpl
je     19c1 <glassofast+0x8a1>
mov    (%rsi,%rax,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
mov    (%r10,%rax,8),%rdx
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,0xcd1d0(%rsp,%rax,8)
mov    (%r8,%rax,8),%rdx
movsd  %xmm1,(%rdx,%rax,8)
lea    -0x1(%rdi),%r15d
test   %ecx,%ecx
jle    2096 <glassofast+0xf76>
mov    %r15d,0x2c(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm5,%xmm2
cvtsi2sd %edi,%xmm0
movsd  %xmm2,0x70(%rsp)
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  0x1620(%rip),%xmm2
maxsd  %xmm1,%xmm2
lea    0x0(,%rbp,8),%rbx
lea    0x1(%rcx),%eax
mov    %eax,0x48(%rsp)
mov    %ebp,%r12d
and    $0xfffffffc,%r12d
lea    -0x4(%r12),%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    %r14,%rcx
mov    %rcx,0x30(%rsp)
mov    %ebp,%r15d
and    $0xfffffffe,%r15d
mov    %ebp,%r14d
and    $0x3,%r14d
mov    $0x1,%eax
movsd  %xmm2,0x78(%rsp)
mov    %rbx,0x60(%rsp)
nopl   (%rax)
mov    %rax,0x58(%rsp)
xorpd  %xmm3,%xmm3
test   %edi,%edi
jle    2060 <glassofast+0xf40>
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
jmp    1a95 <glassofast+0x975>
nopw   0x0(%rax,%rax,1)
maxsd  %xmm1,%xmm3
add    $0x1,%r13
movapd %xmm3,%xmm0
cmp    %rbp,%r13
je     2060 <glassofast+0xf40>
movsd  %xmm0,0x68(%rsp)
lea    0x90(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
movsd  0x78(%rsp),%xmm8
mov    0x8(%rsp),%r9
mov    0x19a358(%rsp),%r10
mov    0x19a350(%rsp),%r8
mov    (%r8,%r13,8),%rax
xor    %ecx,%ecx
mov    0x20(%rsp),%rbx
mov    0x4c(%rsp),%r11d
movapd 0x151e(%rip),%xmm9
movapd 0x1515(%rip),%xmm10
xorpd  %xmm6,%xmm6
jmp    1b0d <glassofast+0x9ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rbp,%rcx
je     1c60 <glassofast+0xb40>
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm6,%xmm0
jne    1b1a <glassofast+0x9fa>
jnp    1b00 <glassofast+0x9e0>
test   %r9d,%r9d
jle    1b00 <glassofast+0x9e0>
mov    (%r10,%rcx,8),%rdx
cmp    $0x4,%r9d
jae    1b30 <glassofast+0xa10>
xor    %esi,%esi
jmp    1c20 <glassofast+0xb00>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x40(%rsp)
je     1c49 <glassofast+0xb29>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x90(%rsp,%rsi,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0xa0(%rsp,%rsi,8),%xmm3
movapd %xmm2,0x90(%rsp,%rsi,8)
movapd %xmm3,0xa0(%rsp,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0xb0(%rsp,%rsi,8),%xmm2
movupd 0x30(%rdx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0xc0(%rsp,%rsi,8),%xmm3
movapd %xmm2,0xb0(%rsp,%rsi,8)
movapd %xmm3,0xc0(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b50 <glassofast+0xa30>
testb  $0x1,0x38(%rsp)
je     1c07 <glassofast+0xae7>
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  0x90(%rsp,%rsi,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0xa0(%rsp,%rsi,8),%xmm3
movapd %xmm2,0x90(%rsp,%rsi,8)
movapd %xmm3,0xa0(%rsp,%rsi,8)
mov    %r12,%rsi
cmp    %rbp,%r12
je     1b00 <glassofast+0x9e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x90(%rsp,%rsi,8),%xmm1
movsd  %xmm1,0x90(%rsp,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1c20 <glassofast+0xb00>
jmp    1b00 <glassofast+0x9e0>
xor    %esi,%esi
testb  $0x1,0x38(%rsp)
jne    1bd0 <glassofast+0xab0>
jmp    1c07 <glassofast+0xae7>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x10(%rsp),%rsi
movsd  0x13b5(%rip),%xmm7
movapd 0x1394(%rip),%xmm11
movsd  0x13ab(%rip),%xmm12
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r13,%rax
je     1e70 <glassofast+0xd50>
mov    (%rbx,%r13,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
ucomisd %xmm3,%xmm7
jbe    1e70 <glassofast+0xd50>
mov    (%rsi,%r13,8),%rcx
movsd  (%rcx,%rax,8),%xmm4
subsd  0x90(%rsp,%rax,8),%xmm4
movsd  0xcd1d0(%rsp,%rax,8),%xmm1
mov    (%r8,%r13,8),%rcx
movsd  (%rcx,%rax,8),%xmm2
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm5,%xmm4
andpd  %xmm9,%xmm4
subsd  %xmm3,%xmm4
xorpd  %xmm3,%xmm3
ucomisd %xmm4,%xmm3
jae    1d06 <glassofast+0xbe6>
ucomisd %xmm6,%xmm5
jae    1cfe <glassofast+0xbde>
xorpd  %xmm11,%xmm4
divsd  %xmm1,%xmm4
movapd %xmm4,%xmm3
movapd %xmm3,%xmm1
subsd  %xmm2,%xmm1
ucomisd %xmm6,%xmm1
jne    1d1a <glassofast+0xbfa>
jnp    1e70 <glassofast+0xd50>
movapd %xmm1,%xmm2
andpd  %xmm9,%xmm2
test   %r11d,%r11d
je     1d33 <glassofast+0xc13>
ucomisd %xmm12,%xmm2
jbe    1e70 <glassofast+0xd50>
movsd  %xmm3,(%rcx,%rax,8)
mov    (%r10,%rax,8),%rcx
cmp    $0x4,%r9d
jae    1d49 <glassofast+0xc29>
xor    %edx,%edx
jmp    1e40 <glassofast+0xd20>
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
cmpq   $0x0,0x40(%rsp)
je     1e93 <glassofast+0xd73>
mov    0x30(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rcx,%rdx,8),%xmm4
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  0x90(%rsp,%rdx,8),%xmm4
mulpd  %xmm3,%xmm5
addpd  0xa0(%rsp,%rdx,8),%xmm5
movapd %xmm4,0x90(%rsp,%rdx,8)
movapd %xmm5,0xa0(%rsp,%rdx,8)
movupd 0x20(%rcx,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
addpd  0xb0(%rsp,%rdx,8),%xmm4
movupd 0x30(%rcx,%rdx,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  0xc0(%rsp,%rdx,8),%xmm5
movapd %xmm4,0xb0(%rsp,%rdx,8)
movapd %xmm5,0xc0(%rsp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1d70 <glassofast+0xc50>
testb  $0x1,0x38(%rsp)
je     1e27 <glassofast+0xd07>
movupd (%rcx,%rdx,8),%xmm4
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  0x90(%rsp,%rdx,8),%xmm4
mulpd  %xmm3,%xmm5
addpd  0xa0(%rsp,%rdx,8),%xmm5
movapd %xmm4,0x90(%rsp,%rdx,8)
movapd %xmm5,0xa0(%rsp,%rdx,8)
mov    %r12,%rdx
cmp    %rbp,%r12
mov    0x10(%rsp),%rsi
je     1e64 <glassofast+0xd44>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  0x90(%rsp,%rdx,8),%xmm3
movsd  %xmm3,0x90(%rsp,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1e40 <glassofast+0xd20>
ucomisd %xmm0,%xmm2
jbe    1e70 <glassofast+0xd50>
movapd %xmm2,%xmm0
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rbp,%rax
jne    1c90 <glassofast+0xb70>
ucomisd %xmm0,%xmm8
mov    $0x0,%eax
xorpd  %xmm0,%xmm0
jbe    1c90 <glassofast+0xb70>
jmp    1eb0 <glassofast+0xd90>
xor    %edx,%edx
testb  $0x1,0x38(%rsp)
jne    1df0 <glassofast+0xcd0>
jmp    1e27 <glassofast+0xd07>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0xcd1d0(%rsp,%r13,8),%xmm0
movsd  %xmm0,0x90(%rsp,%r13,8)
mov    (%r10,%r13,8),%rax
cmpq   $0x0,0x18(%rsp)
je     2040 <glassofast+0xf20>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x60(%rsp),%rbx
nop
movsd  0x90(%rsp,%rcx,8),%xmm1
movsd  0x98(%rsp,%rcx,8),%xmm2
subsd  (%rax,%rcx,8),%xmm1
andpd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm2
andpd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
add    $0x2,%rcx
movapd %xmm2,%xmm0
cmp    %rcx,%r15
jne    1ee0 <glassofast+0xdc0>
test   $0x1,%bpl
je     1f39 <glassofast+0xe19>
movsd  0x90(%rsp,%rcx,8),%xmm0
subsd  (%rax,%rcx,8),%xmm0
andpd  %xmm9,%xmm0
addsd  %xmm0,%xmm2
movapd %xmm2,0x80(%rsp)
mov    (%r10,%r13,8),%rdi
lea    0x90(%rsp),%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
cmpq   $0x3,0x18(%rsp)
jae    1f80 <glassofast+0xe60>
xor    %eax,%eax
mov    0x19a358(%rsp),%rdx
mov    0x8(%rsp),%rdi
movsd  0x68(%rsp),%xmm1
movapd 0x80(%rsp),%xmm3
jmp    1ff8 <glassofast+0xed8>
xchg   %ax,%ax
xor    %eax,%eax
mov    0x19a358(%rsp),%rdx
mov    0x8(%rsp),%rdi
movsd  0x68(%rsp),%xmm1
movapd 0x80(%rsp),%xmm3
xchg   %ax,%ax
movsd  0x90(%rsp,%rax,8),%xmm0
mov    (%rdx,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r13,8)
movsd  0x98(%rsp,%rax,8),%xmm0
mov    0x8(%rdx,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r13,8)
movsd  0xa0(%rsp,%rax,8),%xmm0
mov    0x10(%rdx,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r13,8)
movsd  0xa8(%rsp,%rax,8),%xmm0
mov    0x18(%rdx,%rax,8),%rcx
movsd  %xmm0,(%rcx,%r13,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1fa0 <glassofast+0xe80>
test   %r14,%r14
je     1a80 <glassofast+0x960>
lea    (%rdx,%rax,8),%rcx
lea    (%rsp,%rax,8),%rax
add    $0x90,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mov    (%rcx,%rdx,8),%rsi
movsd  %xmm0,(%rsi,%r13,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2020 <glassofast+0xf00>
jmp    1a80 <glassofast+0x960>
nopl   (%rax)
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
mov    0x60(%rsp),%rbx
test   $0x1,%bpl
jne    1f22 <glassofast+0xe02>
jmp    1f39 <glassofast+0xe19>
nopw   0x0(%rax,%rax,1)
movsd  0x70(%rsp),%xmm0
ucomisd %xmm3,%xmm0
jae    20a4 <glassofast+0xf84>
mov    0x58(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x50(%rsp),%ecx
jne    1a60 <glassofast+0x940>
mov    0x48(%rsp),%eax
mov    0x19a350(%rsp),%r11
movabs $0x7ffffffffffffffe,%r14
ff ff 7f
jmp    20bb <glassofast+0xf9b>
mov    $0x1,%eax
test   %edi,%edi
jg     20c8 <glassofast+0xfa8>
jmp    24dd <glassofast+0x13bd>
mov    0x19a350(%rsp),%r11
movabs $0x7ffffffffffffffe,%r14
ff ff 7f
mov    0x58(%rsp),%rax
mov    0x2c(%rsp),%r15d
test   %edi,%edi
jle    24dd <glassofast+0x13bd>
mov    %ebp,%ebx
and    $0xfffffffc,%ebx
lea    -0x4(%rbx),%r8
mov    %r8,%r9
shr    $0x2,%r9
add    $0x1,%r9
mov    %ebp,%esi
and    $0x3,%esi
and    %r9,%r14
xor    %r10d,%r10d
movsd  0xf49(%rip),%xmm0
movapd 0xf18(%rip),%xmm8
jmp    2113 <glassofast+0xff3>
nopw   0x0(%rax,%rax,1)
movsd  %xmm2,(%rcx,%r10,8)
add    $0x1,%r10
cmp    %rbp,%r10
je     22c6 <glassofast+0x11a6>
mov    (%r11,%r10,8),%rcx
mov    0x19a358(%rsp),%rdx
mov    (%rdx,%r10,8),%rdx
cmpq   $0x3,0x18(%rsp)
jae    2140 <glassofast+0x1020>
xorpd  %xmm2,%xmm2
xor    %edi,%edi
jmp    2197 <glassofast+0x1077>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm2,%xmm2
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm3
movsd  0x8(%rcx,%rdi,8),%xmm4
mulsd  (%rdx,%rdi,8),%xmm3
mulsd  0x8(%rdx,%rdi,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x10(%rcx,%rdi,8),%xmm5
mulsd  0x10(%rdx,%rdi,8),%xmm5
addsd  %xmm3,%xmm4
movsd  0x18(%rcx,%rdi,8),%xmm2
mulsd  0x18(%rdx,%rdi,8),%xmm2
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm2
add    $0x4,%rdi
cmp    %rdi,%rbx
jne    2150 <glassofast+0x1030>
test   %rsi,%rsi
je     21c7 <glassofast+0x10a7>
lea    (%rdx,%rdi,8),%rdx
lea    (%rcx,%rdi,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm3
mulsd  (%rdx,%rdi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    21b0 <glassofast+0x1090>
movsd  0xcd1d0(%rsp,%r10,8),%xmm3
subsd  %xmm2,%xmm3
movapd %xmm0,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm8,%xmm3
mov    (%r11,%r10,8),%rcx
cmpl   $0x4,0x8(%rsp)
jae    2200 <glassofast+0x10e0>
xor    %edx,%edx
jmp    22a0 <glassofast+0x1180>
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
test   %r8,%r8
je     22bc <glassofast+0x119c>
mov    %r14,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd (%rcx,%rdx,8),%xmm5
movupd 0x10(%rcx,%rdx,8),%xmm6
movupd 0x20(%rcx,%rdx,8),%xmm7
movupd 0x30(%rcx,%rdx,8),%xmm1
mulpd  %xmm4,%xmm5
mulpd  %xmm4,%xmm6
movupd %xmm5,(%rcx,%rdx,8)
movupd %xmm6,0x10(%rcx,%rdx,8)
mulpd  %xmm4,%xmm7
mulpd  %xmm4,%xmm1
movupd %xmm7,0x20(%rcx,%rdx,8)
movupd %xmm1,0x30(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2220 <glassofast+0x1100>
test   $0x1,%r9b
je     228c <glassofast+0x116c>
movupd (%rcx,%rdx,8),%xmm1
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm4,%xmm1
mulpd  %xmm4,%xmm5
movupd %xmm1,(%rcx,%rdx,8)
movupd %xmm5,0x10(%rcx,%rdx,8)
mov    %rbx,%rdx
cmp    %rbp,%rbx
je     2100 <glassofast+0xfe0>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    22a0 <glassofast+0x1180>
jmp    2100 <glassofast+0xfe0>
xor    %edx,%edx
test   $0x1,%r9b
jne    226e <glassofast+0x114e>
jmp    228c <glassofast+0x116c>
cmpl   $0x2,0x8(%rsp)
jl     24dd <glassofast+0x13bd>
mov    %r15d,%r8d
xor    %r9d,%r9d
movsd  0xd61(%rip),%xmm0
mov    %rbp,%r10
mov    %r11,%rsi
jmp    2301 <glassofast+0x11e1>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%r10
cmp    %r8,%r9
je     24dd <glassofast+0x13bd>
mov    %r9,%rdi
add    $0x1,%r9
cmp    %rbp,%r9
jae    22f0 <glassofast+0x11d0>
lea    0x0(,%rdi,8),%rbx
add    (%r11,%rdi,8),%rbx
mov    $0x1,%ecx
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm1
mov    (%rsi,%rcx,8),%rdx
addsd  (%rdx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  %xmm1,(%rdx,%rdi,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    2320 <glassofast+0x1200>
jmp    22f0 <glassofast+0x11d0>
xor    %eax,%eax
mov    0x19a358(%rsp),%rdi
mov    0x20(%rsp),%rbx
test   $0x1,%bpl
jne    1682 <glassofast+0x562>
jmp    1699 <glassofast+0x579>
xor    %eax,%eax
test   $0x1,%bpl
jne    199d <glassofast+0x87d>
jmp    19c1 <glassofast+0x8a1>
mov    %ebp,%r13d
and    $0xfffffff8,%r13d
xor    %r12d,%r12d
mov    0x19a350(%rsp),%r15
nopl   0x0(%rax,%rax,1)
mov    (%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x8(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x10(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x18(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x20(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x28(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x30(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x38(%r15,%r12,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
add    $0x8,%r12
cmp    %r12,%r13
jne    2390 <glassofast+0x1270>
test   %rbx,%rbx
je     2447 <glassofast+0x1327>
mov    0x19a350(%rsp),%rax
lea    (%rax,%r12,8),%r12
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%r13,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
add    $0x1,%r13
cmp    %r13,%rbx
jne    2430 <glassofast+0x1310>
cmpl   $0x0,0x8(%rsp)
jle    24db <glassofast+0x13bb>
xor    %eax,%eax
cmpq   $0x0,0x18(%rsp)
je     24ef <glassofast+0x13cf>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
xor    %ebx,%ebx
movsd  0xbd9(%rip),%xmm0
movsd  0xbc1(%rip),%xmm1
mov    0x19a350(%rsp),%rsi
mov    0x19a358(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rbx,8),%rdx
movsd  (%rdx,%rbx,8),%xmm2
maxsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
divsd  %xmm2,%xmm3
mov    (%rsi,%rbx,8),%rdx
movsd  %xmm3,(%rdx,%rbx,8)
mov    0x8(%rdi,%rbx,8),%rdx
movsd  0x8(%rdx,%rbx,8),%xmm2
maxsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
divsd  %xmm2,%xmm3
mov    0x8(%rsi,%rbx,8),%rdx
movsd  %xmm3,0x8(%rdx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    2490 <glassofast+0x1370>
jmp    2501 <glassofast+0x13e1>
xor    %eax,%eax
add    $0x19a318,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
mov    0x19a350(%rsp),%rsi
mov    0x19a358(%rsp),%rdi
test   $0x1,%bpl
je     24dd <glassofast+0x13bd>
mov    (%rdi,%rbx,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
maxsd  0xb30(%rip),%xmm0
movsd  0xb18(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    (%rsi,%rbx,8),%rcx
movsd  %xmm1,(%rcx,%rbx,8)
jmp    24dd <glassofast+0x13bd>

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

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