void slasq2(int m__, float *q, float *e, float *qq, float *ee, float eps,
            float tol2, float small2, float *sup, int *kend, int *info) {
  float r__1, r__2, r__3, r__4;
  static float xinf;
  static int n;
  static float sigma, qemax;
  static int iconv;
  static int iphase;
  static float xx, yy;
  static int off, isp, off1;
  n = m__;
  off = 0;
  off1 = off + 1;
  sigma = 0.f;
  xinf = 0.f;
  iconv = 0;
  iphase = 2;
L10:
  if (n <= 2) {
    goto L20;
  }
  r__1 = qq[(n)-1], r__1 = (((r__1) > (xinf)) ? (r__1) : (xinf));
  if (ee[(n - 1) - 1] <= (((r__1) > (small2)) ? (r__1) : (small2)) * tol2) {
    q[(n)-1] = qq[(n)-1];
    --n;
    if (*kend > n) {
      *kend = n;
    }
    r__1 = qq[(n)-1], r__2 = qq[(n - 1) - 1];
    *sup = (((r__1) < (r__2)) ? (r__1) : (r__2));
    goto L10;
  }
  r__1 = (((xinf) > (small2)) ? (xinf) : (small2)),
  r__2 = qq[(n)-1] / (qq[(n)-1] + ee[(n - 1) - 1] + qq[(n - 1) - 1]) *
         qq[(n - 1) - 1];
  if (ee[(n - 2) - 1] <= (((r__1) > (r__2)) ? (r__1) : (r__2)) * tol2) {
    r__1 = qq[(n)-1], r__2 = qq[(n - 1) - 1],
    r__1 = (((r__1) > (r__2)) ? (r__1) : (r__2)), r__2 = ee[(n - 1) - 1];
    qemax = (((r__1) > (r__2)) ? (r__1) : (r__2));
    if (qemax != 0.f) {
      if (qemax == qq[(n - 1) - 1]) {
        r__1 = (qq[(n)-1] - qq[(n - 1) - 1] + ee[(n - 1) - 1]) / qemax;
        xx = (qq[(n)-1] + qq[(n - 1) - 1] + ee[(n - 1) - 1] +
              qemax * sqrt(r__1 * r__1 + ee[(n - 1) - 1] * 4.f / qemax)) *
             .5f;
      } else if (qemax == qq[(n)-1]) {
        r__1 = (qq[(n - 1) - 1] - qq[(n)-1] + ee[(n - 1) - 1]) / qemax;
        xx = (qq[(n)-1] + qq[(n - 1) - 1] + ee[(n - 1) - 1] +
              qemax * sqrt(r__1 * r__1 + ee[(n - 1) - 1] * 4.f / qemax)) *
             .5f;
      } else {
        r__1 = (qq[(n)-1] - qq[(n - 1) - 1] + ee[(n - 1) - 1]) / qemax;
        xx = (qq[(n)-1] + qq[(n - 1) - 1] + ee[(n - 1) - 1] +
              qemax * sqrt(r__1 * r__1 + qq[(n - 1) - 1] * 4.f / qemax)) *
             .5f;
      }
      r__1 = qq[(n)-1], r__2 = qq[(n - 1) - 1];
      r__3 = qq[(n)-1], r__4 = qq[(n - 1) - 1];
      yy = (((r__1) > (r__2)) ? (r__1) : (r__2)) / xx *
           (((r__3) < (r__4)) ? (r__3) : (r__4));
    } else {
      xx = 0.f;
      yy = 0.f;
    }
    q[(n - 1) - 1] = xx;
    q[(n)-1] = yy;
    n += -2;
    if (*kend > n) {
      *kend = n;
    }
    *sup = qq[(n)-1];
    goto L10;
  }
L20:
  if (n == 0) {
    if (off == 0) {
      return;
    } else {
      xinf = 0.f;
      if (ee[(off)-1] > 0.f) {
        isp = ((int)(((ee[(off)-1]) < 0.0) ? (ceil((ee[(off)-1]) - 0.5))
                                           : (floor((ee[(off)-1]) + 0.5))));
        iphase = 1;
      } else {
        isp = -((int)(((ee[(off)-1]) < 0.0) ? (ceil((ee[(off)-1]) - 0.5))
                                            : (floor((ee[(off)-1]) + 0.5))));
        iphase = 2;
      }
      sigma = e[(off)-1];
      n = off - isp + 1;
      off1 = isp;
      off = off1 - 1;
      if (n <= 2) {
        goto L20;
      }
      if (iphase == 1) {
        r__1 = q[(n + off) - 1], r__2 = q[(n - 1 + off) - 1],
        r__1 = (((r__1) < (r__2)) ? (r__1) : (r__2)),
        r__2 = q[(n - 2 + off) - 1];
        *sup = (((r__1) < (r__2)) ? (r__1) : (r__2));
      } else {
        r__1 = qq[(n + off) - 1], r__2 = qq[(n - 1 + off) - 1],
        r__1 = (((r__1) < (r__2)) ? (r__1) : (r__2)),
        r__2 = qq[(n - 2 + off) - 1];
        *sup = (((r__1) < (r__2)) ? (r__1) : (r__2));
      }
      *kend = 0;
      iconv = -3;
    }
  } else if (n == 1) {
    if (iphase == 1) {
      q[(off1)-1] += sigma;
    } else {
      q[(off1)-1] = qq[(off1)-1] + sigma;
    }
    n = 0;
    goto L20;
  } else if (n == 2) {
    if (iphase == 2) {
      r__1 = qq[(n + off) - 1], r__2 = qq[(n - 1 + off) - 1],
      r__1 = (((r__1) > (r__2)) ? (r__1) : (r__2)),
      r__2 = ee[(n - 1 + off) - 1];
      qemax = (((r__1) > (r__2)) ? (r__1) : (r__2));
      if (qemax != 0.f) {
        if (qemax == qq[(n - 1 + off) - 1]) {
          r__1 = (qq[(n + off) - 1] - qq[(n - 1 + off) - 1] +
                  ee[(n - 1 + off) - 1]) /
                 qemax;
          xx = (qq[(n + off) - 1] + qq[(n - 1 + off) - 1] +
                ee[(n - 1 + off) - 1] +
                qemax *
                    sqrt(r__1 * r__1 + ee[(off + n - 1) - 1] * 4.f / qemax)) *
               .5f;
        } else if (qemax == qq[(n + off) - 1]) {
          r__1 = (qq[(n - 1 + off) - 1] - qq[(n + off) - 1] +
                  ee[(n - 1 + off) - 1]) /
                 qemax;
          xx = (qq[(n + off) - 1] + qq[(n - 1 + off) - 1] +
                ee[(n - 1 + off) - 1] +
                qemax *
                    sqrt(r__1 * r__1 + ee[(n - 1 + off) - 1] * 4.f / qemax)) *
               .5f;
        } else {
          r__1 = (qq[(n + off) - 1] - qq[(n - 1 + off) - 1] +
                  ee[(n - 1 + off) - 1]) /
                 qemax;
          xx = (qq[(n + off) - 1] + qq[(n - 1 + off) - 1] +
                ee[(n - 1 + off) - 1] +
                qemax *
                    sqrt(r__1 * r__1 + qq[(n - 1 + off) - 1] * 4.f / qemax)) *
               .5f;
        }
        r__1 = qq[(n + off) - 1], r__2 = qq[(n - 1 + off) - 1];
        r__3 = qq[(n + off) - 1], r__4 = qq[(n - 1 + off) - 1];
        yy = (((r__1) > (r__2)) ? (r__1) : (r__2)) / xx *
             (((r__3) < (r__4)) ? (r__3) : (r__4));
      } else {
        xx = 0.f;
        yy = 0.f;
      }
    } else {
      r__1 = q[(n + off) - 1], r__2 = q[(n - 1 + off) - 1],
      r__1 = (((r__1) > (r__2)) ? (r__1) : (r__2)), r__2 = e[(n - 1 + off) - 1];
      qemax = (((r__1) > (r__2)) ? (r__1) : (r__2));
      if (qemax != 0.f) {
        if (qemax == q[(n - 1 + off) - 1]) {
          r__1 =
              (q[(n + off) - 1] - q[(n - 1 + off) - 1] + e[(n - 1 + off) - 1]) /
              qemax;
          xx =
              (q[(n + off) - 1] + q[(n - 1 + off) - 1] + e[(n - 1 + off) - 1] +
               qemax * sqrt(r__1 * r__1 + e[(n - 1 + off) - 1] * 4.f / qemax)) *
              .5f;
        } else if (qemax == q[(n + off) - 1]) {
          r__1 =
              (q[(n - 1 + off) - 1] - q[(n + off) - 1] + e[(n - 1 + off) - 1]) /
              qemax;
          xx =
              (q[(n + off) - 1] + q[(n - 1 + off) - 1] + e[(n - 1 + off) - 1] +
               qemax * sqrt(r__1 * r__1 + e[(n - 1 + off) - 1] * 4.f / qemax)) *
              .5f;
        } else {
          r__1 =
              (q[(n + off) - 1] - q[(n - 1 + off) - 1] + e[(n - 1 + off) - 1]) /
              qemax;
          xx =
              (q[(n + off) - 1] + q[(n - 1 + off) - 1] + e[(n - 1 + off) - 1] +
               qemax * sqrt(r__1 * r__1 + q[(n - 1 + off) - 1] * 4.f / qemax)) *
              .5f;
        }
        r__1 = q[(n + off) - 1], r__2 = q[(n - 1 + off) - 1];
        r__3 = q[(n + off) - 1], r__4 = q[(n - 1 + off) - 1];
        yy = (((r__1) > (r__2)) ? (r__1) : (r__2)) / xx *
             (((r__3) < (r__4)) ? (r__3) : (r__4));
      } else {
        xx = 0.f;
        yy = 0.f;
      }
    }
    q[(n - 1 + off) - 1] = sigma + xx;
    q[(n + off) - 1] = yy + sigma;
    n = 0;
    goto L20;
  }
  slasq3(&n, &q[(off1)-1], &e[(off1)-1], &qq[(off1)-1], &ee[(off1)-1], sup,
         &sigma, kend, &off, &iphase, iconv, eps, tol2, small2);
  if (*sup < 0.f) {
    *info = n + off;
    return;
  }
  off1 = off + 1;
  goto L20;
}


x86 assembly (clang, -O0):
<slasq2>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x190,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
movss  %xmm0,-0x3c(%rbp)
movss  %xmm1,-0x40(%rbp)
movss  %xmm2,-0x44(%rbp)
mov    %r9,-0x50(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,0x3ec3(%rip)
movl   $0x0,0x3ed5(%rip)
mov    0x3ecf(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3ece(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x3ea3(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x3e90(%rip)
movl   $0x0,0x3e96(%rip)
movl   $0x2,0x3e90(%rip)
cmpl   $0x2,0x3e79(%rip)
jg     11da <slasq2+0x9a>
jmp    1adf <slasq2+0x99f>
mov    -0x30(%rbp),%rax
mov    0x3e64(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss 0x3e44(%rip),%xmm0
jbe    1215 <slasq2+0xd5>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1222 <slasq2+0xe2>
movss  0x3e27(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
mov    0x3e12(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    1267 <slasq2+0x127>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1271 <slasq2+0x131>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x68(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1355 <slasq2+0x215>
mov    -0x30(%rbp),%rax
mov    0x3db5(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x3da0(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x3d8f(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3d86(%rip)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
cmp    0x3d7a(%rip),%eax
jle    12e0 <slasq2+0x1a0>
mov    0x3d6e(%rip),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x3d5e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3d44(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1339 <slasq2+0x1f9>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    1343 <slasq2+0x203>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
jmp    11c8 <slasq2+0x88>
movss  0x3ce7(%rip),%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    1379 <slasq2+0x239>
movss  0x3cd5(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
jmp    1383 <slasq2+0x243>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3cb1(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3c9c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
mov    0x3c87(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    0x3c6f(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    0x3c53(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    0x3c36(%rip),%ecx
sub    $0x2,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    1443 <slasq2+0x303>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    144d <slasq2+0x30d>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1ada <slasq2+0x99a>
mov    -0x30(%rbp),%rax
mov    0x3bd9(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3bbf(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    14ba <slasq2+0x37a>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    14c4 <slasq2+0x384>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
mov    0x3b70(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    150c <slasq2+0x3cc>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    1519 <slasq2+0x3d9>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,0x3b27(%rip)
movss  0x3b1f(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1548 <slasq2+0x408>
jp     1548 <slasq2+0x408>
jmp    1a38 <slasq2+0x8f8>
movss  0x3b00(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3aee(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    16a5 <slasq2+0x565>
jp     16a5 <slasq2+0x565>
mov    -0x30(%rbp),%rax
mov    0x3acb(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3ab6(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x3a9e(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x3a90(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x3a79(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3a64(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x3a4c(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  0x3a32(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x38(%rbp),%rax
mov    0x3a0a(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x19b9(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x39f4(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x98(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1970(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x39bc(%rip)
jmp    1931 <slasq2+0x7f1>
movss  0x39a3(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3991(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    17ff <slasq2+0x6bf>
jp     17ff <slasq2+0x6bf>
mov    -0x30(%rbp),%rax
mov    0x3971(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3959(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x3944(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x3936(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x391f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x390a(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x38f2(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movss  0x38d8(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x38(%rbp),%rax
mov    0x38b0(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x185f(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x389a(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1816(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x3862(%rip)
jmp    192c <slasq2+0x7ec>
mov    -0x30(%rbp),%rax
mov    0x383f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x382a(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x3812(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x3804(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x37ed(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x37d8(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x37c0(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movss  0x37a6(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    0x377e(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x172d(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x3768(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0xb8(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x16e4(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x3730(%rip)
jmp    1931 <slasq2+0x7f1>
mov    -0x30(%rbp),%rax
mov    0x370d(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x36f3(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    0x36d6(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x36bc(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    19c0 <slasq2+0x880>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
jmp    19cd <slasq2+0x88d>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
divss  0x367f(%rip),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0x5c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1a0a <slasq2+0x8ca>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
jmp    1a17 <slasq2+0x8d7>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,0x362d(%rip)
jmp    1a4e <slasq2+0x90e>
xorps  %xmm0,%xmm0
movss  %xmm0,0x3619(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x3612(%rip)
movss  0x3606(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x35e8(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x35ea(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x35c8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x35b7(%rip),%eax
add    $0xfffffffe,%eax
mov    %eax,0x35ae(%rip)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
cmp    0x35a2(%rip),%eax
jle    1ab8 <slasq2+0x978>
mov    0x3596(%rip),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x3586(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
jmp    11c8 <slasq2+0x88>
jmp    1adf <slasq2+0x99f>
cmpl   $0x0,0x3562(%rip)
jne    1ee1 <slasq2+0xda1>
cmpl   $0x0,0x3571(%rip)
jne    1afe <slasq2+0x9be>
jmp    2e3b <slasq2+0x1cfb>
xorps  %xmm0,%xmm0
movss  %xmm0,0x353b(%rip)
mov    -0x38(%rbp),%rax
mov    0x3551(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1bda <slasq2+0xa9a>
mov    -0x38(%rbp),%rax
mov    0x3530(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b87 <slasq2+0xa47>
mov    -0x38(%rbp),%rax
mov    0x350a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x148f(%rip),%xmm1
subsd  %xmm1,%xmm0
call   1030 <ceil@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1bb9 <slasq2+0xa79>
mov    -0x38(%rbp),%rax
mov    0x34d3(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1458(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <floor@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,0x349d(%rip)
movl   $0x1,0x3483(%rip)
jmp    1c89 <slasq2+0xb49>
mov    -0x38(%rbp),%rax
mov    0x3480(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1c37 <slasq2+0xaf7>
mov    -0x38(%rbp),%rax
mov    0x345a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13df(%rip),%xmm1
subsd  %xmm1,%xmm0
call   1030 <ceil@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1c69 <slasq2+0xb29>
mov    -0x38(%rbp),%rax
mov    0x3423(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13a8(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <floor@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,0x33e9(%rip)
movl   $0x2,0x33cf(%rip)
mov    -0x28(%rbp),%rax
mov    0x33d1(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x33a6(%rip)
mov    0x33b8(%rip),%eax
sub    0x33b6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x338d(%rip)
mov    0x33a7(%rip),%eax
mov    %eax,0x33a5(%rip)
mov    0x339f(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x338e(%rip)
cmpl   $0x2,0x336b(%rip)
jg     1ce8 <slasq2+0xba8>
jmp    1adf <slasq2+0x99f>
cmpl   $0x1,0x3369(%rip)
jne    1de1 <slasq2+0xca1>
mov    -0x20(%rbp),%rax
mov    0x3349(%rip),%ecx
add    0x335f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x3329(%rip),%ecx
sub    $0x1,%ecx
add    0x333c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d5d <slasq2+0xc1d>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
jmp    1d6a <slasq2+0xc2a>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x32c7(%rip),%ecx
sub    $0x2,%ecx
add    0x32da(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1dbf <slasq2+0xc7f>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
jmp    1dcc <slasq2+0xc8c>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1ec8 <slasq2+0xd88>
mov    -0x30(%rbp),%rax
mov    0x325d(%rip),%ecx
add    0x3273(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x323d(%rip),%ecx
sub    $0x1,%ecx
add    0x3250(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1e49 <slasq2+0xd09>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
jmp    1e56 <slasq2+0xd16>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x31db(%rip),%ecx
sub    $0x2,%ecx
add    0x31ee(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1eab <slasq2+0xd6b>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
jmp    1eb8 <slasq2+0xd78>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
movl   $0xfffffffd,0x3178(%rip)
ff ff ff
jmp    2d45 <slasq2+0x1c05>
cmpl   $0x1,0x3160(%rip)
jne    1f63 <slasq2+0xe23>
cmpl   $0x1,0x3163(%rip)
jne    1f22 <slasq2+0xde2>
movss  0x3149(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x315f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1f54 <slasq2+0xe14>
mov    -0x30(%rbp),%rax
mov    0x3140(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  0x310d(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x3123(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,0x30ea(%rip)
jmp    1adf <slasq2+0x99f>
cmpl   $0x2,0x30de(%rip)
jne    2d3b <slasq2+0x1bfb>
cmpl   $0x2,0x30e1(%rip)
jne    2628 <slasq2+0x14e8>
mov    -0x30(%rbp),%rax
mov    0x30c1(%rip),%ecx
add    0x30d7(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x30a1(%rip),%ecx
sub    $0x1,%ecx
add    0x30b4(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    1fe1 <slasq2+0xea1>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
jmp    1fee <slasq2+0xeae>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
mov    0x3043(%rip),%ecx
sub    $0x1,%ecx
add    0x3056(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    203f <slasq2+0xeff>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
jmp    204c <slasq2+0xf0c>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,0x2ff4(%rip)
movss  0x2fec(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    207b <slasq2+0xf3b>
jp     207b <slasq2+0xf3b>
jmp    260d <slasq2+0x14cd>
movss  0x2fcd(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2fbb(%rip),%ecx
sub    $0x1,%ecx
add    0x2fce(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    2208 <slasq2+0x10c8>
jp     2208 <slasq2+0x10c8>
mov    -0x30(%rbp),%rax
mov    0x2f92(%rip),%ecx
add    0x2fa8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2f77(%rip),%ecx
sub    $0x1,%ecx
add    0x2f8a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2f59(%rip),%ecx
sub    $0x1,%ecx
add    0x2f6c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x2f45(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2f2e(%rip),%ecx
add    0x2f44(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2f13(%rip),%ecx
sub    $0x1,%ecx
add    0x2f26(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2ef5(%rip),%ecx
sub    $0x1,%ecx
add    0x2f08(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movss  0x2ed5(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x38(%rbp),%rax
mov    0x2ec9(%rip),%ecx
add    0x2ea7(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0xe56(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x2e91(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x100(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe0d(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2e59(%rip)
jmp    24ee <slasq2+0x13ae>
movss  0x2e40(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2e2e(%rip),%ecx
add    0x2e44(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    2392 <slasq2+0x1252>
jp     2392 <slasq2+0x1252>
mov    -0x30(%rbp),%rax
mov    0x2e08(%rip),%ecx
sub    $0x1,%ecx
add    0x2e1b(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2dea(%rip),%ecx
add    0x2e00(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2dcf(%rip),%ecx
sub    $0x1,%ecx
add    0x2de2(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x2dbb(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2da4(%rip),%ecx
add    0x2dba(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2d89(%rip),%ecx
sub    $0x1,%ecx
add    0x2d9c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2d6b(%rip),%ecx
sub    $0x1,%ecx
add    0x2d7e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movss  0x2d4b(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x38(%rbp),%rax
mov    0x2d23(%rip),%ecx
sub    $0x1,%ecx
add    0x2d36(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0xccc(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x2d07(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x110(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x108(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc83(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2ccf(%rip)
jmp    24e9 <slasq2+0x13a9>
mov    -0x30(%rbp),%rax
mov    0x2cac(%rip),%ecx
add    0x2cc2(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2c91(%rip),%ecx
sub    $0x1,%ecx
add    0x2ca4(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2c73(%rip),%ecx
sub    $0x1,%ecx
add    0x2c86(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x2c5f(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2c48(%rip),%ecx
add    0x2c5e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    0x2c2d(%rip),%ecx
sub    $0x1,%ecx
add    0x2c40(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    0x2c0f(%rip),%ecx
sub    $0x1,%ecx
add    0x2c22(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movss  0x2bef(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    0x2bc7(%rip),%ecx
sub    $0x1,%ecx
add    0x2bda(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0xb70(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x2bab(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x120(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x118(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xb27(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2b73(%rip)
jmp    24ee <slasq2+0x13ae>
mov    -0x30(%rbp),%rax
mov    0x2b50(%rip),%ecx
add    0x2b66(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2b30(%rip),%ecx
sub    $0x1,%ecx
add    0x2b43(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2b0d(%rip),%ecx
add    0x2b23(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x2aed(%rip),%ecx
sub    $0x1,%ecx
add    0x2b00(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    2595 <slasq2+0x1455>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x124(%rbp)
ff
jmp    25a2 <slasq2+0x1462>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
divss  0x2aaa(%rip),%xmm0
movss  %xmm0,-0x128(%rbp)
ff
movss  -0x5c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    25df <slasq2+0x149f>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
jmp    25ec <slasq2+0x14ac>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x128(%rbp),%xmm0
ff
movss  -0x12c(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,0x2a58(%rip)
jmp    2623 <slasq2+0x14e3>
xorps  %xmm0,%xmm0
movss  %xmm0,0x2a44(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x2a3d(%rip)
jmp    2cd3 <slasq2+0x1b93>
mov    -0x20(%rbp),%rax
mov    0x2a16(%rip),%ecx
add    0x2a2c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x29f6(%rip),%ecx
sub    $0x1,%ecx
add    0x2a09(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    268c <slasq2+0x154c>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x130(%rbp)
ff
jmp    2699 <slasq2+0x1559>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    0x2998(%rip),%ecx
sub    $0x1,%ecx
add    0x29ab(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    26ea <slasq2+0x15aa>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x134(%rbp)
ff
jmp    26f7 <slasq2+0x15b7>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
movss  %xmm0,0x2949(%rip)
movss  0x2941(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2726 <slasq2+0x15e6>
jp     2726 <slasq2+0x15e6>
jmp    2cb8 <slasq2+0x1b78>
movss  0x2922(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2910(%rip),%ecx
sub    $0x1,%ecx
add    0x2923(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    28b3 <slasq2+0x1773>
jp     28b3 <slasq2+0x1773>
mov    -0x20(%rbp),%rax
mov    0x28e7(%rip),%ecx
add    0x28fd(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x28cc(%rip),%ecx
sub    $0x1,%ecx
add    0x28df(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x28ae(%rip),%ecx
sub    $0x1,%ecx
add    0x28c1(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x289a(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2883(%rip),%ecx
add    0x2899(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2868(%rip),%ecx
sub    $0x1,%ecx
add    0x287b(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x284a(%rip),%ecx
sub    $0x1,%ecx
add    0x285d(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movss  0x282a(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    0x2802(%rip),%ecx
sub    $0x1,%ecx
add    0x2815(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x7ab(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x27e6(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x148(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x762(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x27ae(%rip)
jmp    2b99 <slasq2+0x1a59>
movss  0x2795(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2783(%rip),%ecx
add    0x2799(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    2a3d <slasq2+0x18fd>
jp     2a3d <slasq2+0x18fd>
mov    -0x20(%rbp),%rax
mov    0x275d(%rip),%ecx
sub    $0x1,%ecx
add    0x2770(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x273f(%rip),%ecx
add    0x2755(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2724(%rip),%ecx
sub    $0x1,%ecx
add    0x2737(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x2710(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x26f9(%rip),%ecx
add    0x270f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x26de(%rip),%ecx
sub    $0x1,%ecx
add    0x26f1(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x26c0(%rip),%ecx
sub    $0x1,%ecx
add    0x26d3(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movss  0x26a0(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    0x2678(%rip),%ecx
sub    $0x1,%ecx
add    0x268b(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x621(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x265c(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x158(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x150(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x5d8(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2624(%rip)
jmp    2b94 <slasq2+0x1a54>
mov    -0x20(%rbp),%rax
mov    0x2601(%rip),%ecx
add    0x2617(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x25e6(%rip),%ecx
sub    $0x1,%ecx
add    0x25f9(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x25c8(%rip),%ecx
sub    $0x1,%ecx
add    0x25db(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
divss  0x25b4(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x259d(%rip),%ecx
add    0x25b3(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2582(%rip),%ecx
sub    $0x1,%ecx
add    0x2595(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2564(%rip),%ecx
sub    $0x1,%ecx
add    0x2577(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movss  0x2544(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    0x251c(%rip),%ecx
sub    $0x1,%ecx
add    0x252f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  0x4c5(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  0x2500(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movsd  -0x168(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x160(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x47c(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x24c8(%rip)
jmp    2b99 <slasq2+0x1a59>
mov    -0x20(%rbp),%rax
mov    0x24a5(%rip),%ecx
add    0x24bb(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2485(%rip),%ecx
sub    $0x1,%ecx
add    0x2498(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2462(%rip),%ecx
add    0x2478(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x2442(%rip),%ecx
sub    $0x1,%ecx
add    0x2455(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    2c40 <slasq2+0x1b00>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
jmp    2c4d <slasq2+0x1b0d>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
movss  -0x16c(%rbp),%xmm0
ff
divss  0x23ff(%rip),%xmm0
movss  %xmm0,-0x170(%rbp)
ff
movss  -0x5c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    2c8a <slasq2+0x1b4a>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x174(%rbp)
ff
jmp    2c97 <slasq2+0x1b57>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x174(%rbp)
ff
movss  -0x170(%rbp),%xmm0
ff
movss  -0x174(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,0x23ad(%rip)
jmp    2cce <slasq2+0x1b8e>
xorps  %xmm0,%xmm0
movss  %xmm0,0x2399(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x2392(%rip)
jmp    2cd3 <slasq2+0x1b93>
movss  0x2371(%rip),%xmm0
addss  0x2379(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x235b(%rip),%ecx
sub    $0x1,%ecx
add    0x236e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x2357(%rip),%xmm0
addss  0x233b(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x232d(%rip),%ecx
add    0x2343(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,0x2312(%rip)
jmp    1adf <slasq2+0x99f>
jmp    2d40 <slasq2+0x1c00>
jmp    2d45 <slasq2+0x1c05>
mov    -0x20(%rbp),%rsi
mov    0x231d(%rip),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x28(%rbp),%rdx
mov    0x2307(%rip),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rcx
mov    0x22f1(%rip),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x38(%rbp),%r8
mov    0x22db(%rip),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r8
mov    -0x50(%rbp),%r9
mov    0x10(%rbp),%rbx
mov    0x22a9(%rip),%eax
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x44(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x227b(%rip),%rdi
lea    0x2278(%rip),%r14
lea    0x2289(%rip),%r11
lea    0x2276(%rip),%r10
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x3,%al
call   1040 <slasq3@plt>
mov    -0x50(%rbp),%rax
xorps  %xmm0,%xmm0
ucomiss (%rax),%xmm0
jbe    2e27 <slasq2+0x1ce7>
mov    0x2232(%rip),%ecx
add    0x2248(%rip),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    2e3b <slasq2+0x1cfb>
mov    0x2237(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2236(%rip)
jmp    1adf <slasq2+0x99f>
add    $0x190,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<slasq2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r15
movss  %xmm0,0x34(%rsp)
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%r12
mov    %rsi,%rbx
mov    0x70(%rsp),%rbp
mov    %edi,0x2ed6(%rip)
movl   $0x0,0x2edc(%rip)
movl   $0x1,0x2ed6(%rip)
movl   $0x0,0x2ebc(%rip)
movb   $0x0,0x2eb9(%rip)
movl   $0x2,0x2eb3(%rip)
cmp    $0x3,%edi
jge    173d <slasq2+0x5fd>
movss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movsd  %xmm0,0x18(%rsp)
xorps  %xmm4,%xmm4
jmp    11fd <slasq2+0xbd>
movslq 0x2e7c(%rip),%rax
movss  -0x4(%r13,%rax,4),%xmm0
addss  0x2e5d(%rip),%xmm0
movss  %xmm0,-0x4(%rbx,%rax,4)
movl   $0x0,0x2e49(%rip)
xor    %edi,%edi
cmp    $0x2,%edi
je     1260 <slasq2+0x120>
cmp    $0x1,%edi
je     12d0 <slasq2+0x190>
test   %edi,%edi
jne    1300 <slasq2+0x1c0>
movslq 0x2e3a(%rip),%rbp
test   %rbp,%rbp
je     172e <slasq2+0x5ee>
movss  -0x4(%r14,%rbp,4),%xmm1
ucomiss %xmm4,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movss  %xmm1,0x8(%rsp)
jbe    137e <slasq2+0x23e>
ucomiss %xmm1,%xmm4
jbe    139f <slasq2+0x25f>
addsd  0xdbf(%rip),%xmm0
call   1030 <ceil@plt>
jmp    13ac <slasq2+0x26c>
nopl   0x0(%rax,%rax,1)
mov    0x2dee(%rip),%eax
lea    0x1(%rax),%edx
cmpl   $0x2,0x2de0(%rip)
movslq %eax,%rcx
movslq %edx,%rdx
jne    133e <slasq2+0x1fe>
movss  0x0(%r13,%rdx,4),%xmm6
movss  0x0(%r13,%rcx,4),%xmm2
movaps %xmm6,%xmm3
maxss  %xmm2,%xmm3
movss  (%r14,%rcx,4),%xmm5
maxss  %xmm5,%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jne    12a9 <slasq2+0x169>
jnp    1392 <slasq2+0x252>
ucomiss %xmm2,%xmm3
jne    1506 <slasq2+0x3c6>
jp     1506 <slasq2+0x3c6>
movaps %xmm6,%xmm0
subss  %xmm2,%xmm0
jmp    151c <slasq2+0x3dc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x1,0x2d79(%rip)
jne    11d5 <slasq2+0x95>
movss  0x2d63(%rip),%xmm0
movslq 0x2d6c(%rip),%rax
addss  -0x4(%rbx,%rax,4),%xmm0
jmp    11eb <slasq2+0xab>
nopw   0x0(%rax,%rax,1)
movslq 0x2d51(%rip),%rax
lea    (%rbx,%rax,4),%rsi
add    $0xfffffffffffffffc,%rsi
lea    (%r12,%rax,4),%rdx
add    $0xfffffffffffffffc,%rdx
lea    -0x4(,%rax,4),%rcx
ff
add    %r13,%rcx
lea    (%r14,%rax,4),%r8
add    $0xfffffffffffffffc,%r8
xor    %ebp,%ebp
cmpb   $0x1,0x2d19(%rip)
je     148f <slasq2+0x34f>
jmp    1494 <slasq2+0x354>
movss  (%rbx,%rdx,4),%xmm6
movss  (%rbx,%rcx,4),%xmm2
movaps %xmm6,%xmm3
maxss  %xmm2,%xmm3
movss  (%r12,%rcx,4),%xmm5
maxss  %xmm5,%xmm3
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jne    1363 <slasq2+0x223>
jnp    1392 <slasq2+0x252>
ucomiss %xmm2,%xmm3
jne    15dd <slasq2+0x49d>
jp     15dd <slasq2+0x49d>
movaps %xmm6,%xmm0
subss  %xmm2,%xmm0
jmp    15f3 <slasq2+0x4b3>
ucomiss %xmm1,%xmm4
jbe    13c0 <slasq2+0x280>
addsd  0xc85(%rip),%xmm0
call   1030 <ceil@plt>
jmp    13cd <slasq2+0x28d>
mov    $0x2,%ecx
xorps  %xmm1,%xmm1
jmp    16be <slasq2+0x57e>
addsd  0xc61(%rip),%xmm0
call   1060 <floor@plt>
movss  0x8(%rsp),%xmm1
xorps  %xmm4,%xmm4
cvttsd2si %xmm0,%eax
mov    $0x1,%ecx
jmp    13e1 <slasq2+0x2a1>
addsd  0xc40(%rip),%xmm0
call   1060 <floor@plt>
movss  0x8(%rsp),%xmm1
xorps  %xmm4,%xmm4
cvttsd2si %xmm0,%eax
neg    %eax
mov    $0x2,%ecx
mov    %ecx,0x2c69(%rip)
movss  -0x4(%r12,%rbp,4),%xmm0
movss  %xmm0,0x2c52(%rip)
mov    %ebp,%ecx
sub    %eax,%ecx
lea    0x1(%rcx),%edi
mov    %edi,0x2c41(%rip)
mov    %eax,0x2c4f(%rip)
add    $0xffffffff,%eax
mov    %eax,0x2c42(%rip)
cmp    $0x2,%ecx
jl     11fd <slasq2+0xbd>
ucomiss %xmm4,%xmm1
jbe    143e <slasq2+0x2fe>
movss  -0x4(%rbx,%rbp,4),%xmm0
lea    -0x2(%rbp),%ecx
movslq %ecx,%rcx
minss  (%rbx,%rcx,4),%xmm0
lea    -0x3(%rbp),%ecx
movslq %ecx,%rcx
minss  (%rbx,%rcx,4),%xmm0
jmp    145f <slasq2+0x31f>
movss  -0x4(%r13,%rbp,4),%xmm0
lea    -0x2(%rbp),%ecx
movslq %ecx,%rcx
minss  0x0(%r13,%rcx,4),%xmm0
lea    -0x3(%rbp),%ecx
movslq %ecx,%rcx
minss  0x0(%r13,%rcx,4),%xmm0
mov    0x70(%rsp),%rcx
movss  %xmm0,(%r15)
movl   $0x0,(%rcx)
movb   $0x1,0x2bd6(%rip)
cltq
lea    (%rbx,%rax,4),%rsi
lea    (%r12,%rax,4),%rdx
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
lea    (%r14,%rax,4),%r8
mov    $0xfffffffd,%ebp
sub    $0x8,%rsp
lea    0x2ba5(%rip),%rdi
mov    %r15,%r9
movsd  0x30(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
movsd  0x20(%rsp),%xmm2
mov    $0x3,%al
push   %rbp
lea    0x2b92(%rip),%rbp
push   %rbp
lea    0x2b8e(%rip),%rbp
push   %rbp
push   0x90(%rsp)
lea    0x2b73(%rip),%rbp
push   %rbp
call   1040 <slasq3@plt>
add    $0x30,%rsp
xorps  %xmm4,%xmm4
ucomiss (%r15),%xmm4
ja     171b <slasq2+0x5db>
mov    0x2b62(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b5d(%rip)
mov    0x2b43(%rip),%edi
jmp    11fd <slasq2+0xbd>
ucomiss %xmm6,%xmm3
jne    16ed <slasq2+0x5ad>
jp     16ed <slasq2+0x5ad>
movaps %xmm2,%xmm0
subss  %xmm6,%xmm0
addss  %xmm5,%xmm0
divss  %xmm3,%xmm0
movaps %xmm5,%xmm1
mulss  0xad1(%rip),%xmm1
divss  %xmm3,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd 0xad1(%rip),%xmm0
jb     154f <slasq2+0x40f>
sqrtsd %xmm0,%xmm0
jmp    1587 <slasq2+0x447>
movss  %xmm3,0x8(%rsp)
movss  %xmm2,0x14(%rsp)
movss  %xmm5,0x10(%rsp)
movss  %xmm6,0xc(%rsp)
call   1050 <sqrt@plt>
movss  0xc(%rsp),%xmm6
movss  0x10(%rsp),%xmm5
movss  0x14(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
xorps  %xmm4,%xmm4
addss  %xmm6,%xmm2
addss  %xmm5,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mulsd  0xa5e(%rip),%xmm1
cvtsd2ss %xmm1,%xmm1
mov    0x2a90(%rip),%ecx
mov    0x2a9a(%rip),%eax
lea    -0x1(%rax,%rcx,1),%edx
movslq %edx,%rdx
movss  0x0(%r13,%rdx,4),%xmm0
lea    (%rax,%rcx,1),%edx
add    $0xfffffffe,%edx
movslq %edx,%rdx
movss  0x0(%r13,%rdx,4),%xmm2
jmp    16ab <slasq2+0x56b>
ucomiss %xmm6,%xmm3
jne    1704 <slasq2+0x5c4>
jp     1704 <slasq2+0x5c4>
movaps %xmm2,%xmm0
subss  %xmm6,%xmm0
addss  %xmm5,%xmm0
divss  %xmm3,%xmm0
movaps %xmm5,%xmm1
mulss  0x9fa(%rip),%xmm1
divss  %xmm3,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd 0x9fa(%rip),%xmm0
jb     1626 <slasq2+0x4e6>
sqrtsd %xmm0,%xmm0
jmp    165e <slasq2+0x51e>
movss  %xmm3,0x8(%rsp)
movss  %xmm2,0x14(%rsp)
movss  %xmm5,0x10(%rsp)
movss  %xmm6,0xc(%rsp)
call   1050 <sqrt@plt>
movss  0xc(%rsp),%xmm6
movss  0x10(%rsp),%xmm5
movss  0x14(%rsp),%xmm2
movss  0x8(%rsp),%xmm3
xorps  %xmm4,%xmm4
addss  %xmm6,%xmm2
addss  %xmm5,%xmm2
cvtss2sd %xmm2,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
mulsd  0x987(%rip),%xmm1
cvtsd2ss %xmm1,%xmm1
mov    0x29b9(%rip),%ecx
mov    0x29c3(%rip),%eax
lea    -0x1(%rax,%rcx,1),%edx
movslq %edx,%rdx
movss  (%rbx,%rdx,4),%xmm0
lea    (%rax,%rcx,1),%edx
add    $0xfffffffe,%edx
movslq %edx,%rdx
movss  (%rbx,%rdx,4),%xmm2
movaps %xmm0,%xmm3
maxss  %xmm2,%xmm3
divss  %xmm1,%xmm3
minss  %xmm2,%xmm0
mulss  %xmm3,%xmm0
addss  0x2982(%rip),%xmm1
lea    (%rax,%rcx,1),%edx
add    $0xfffffffe,%edx
movslq %edx,%rdx
movss  %xmm1,(%rbx,%rdx,4)
addss  0x296c(%rip),%xmm0
add    %ecx,%eax
add    $0xffffffff,%eax
cltq
movss  %xmm0,(%rbx,%rax,4)
jmp    11f1 <slasq2+0xb1>
movaps %xmm6,%xmm0
subss  %xmm2,%xmm0
addss  %xmm5,%xmm0
divss  %xmm3,%xmm0
movaps %xmm2,%xmm1
jmp    1527 <slasq2+0x3e7>
movaps %xmm6,%xmm0
subss  %xmm2,%xmm0
addss  %xmm5,%xmm0
divss  %xmm3,%xmm0
movaps %xmm2,%xmm1
jmp    15fe <slasq2+0x4be>
mov    0x2933(%rip),%eax
add    0x291d(%rip),%eax
mov    0x78(%rsp),%rcx
mov    %eax,(%rcx)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorps  %xmm12,%xmm12
xorps  %xmm11,%xmm11
maxss  %xmm2,%xmm11
movss  0x8ad(%rip),%xmm8
xorpd  %xmm9,%xmm9
movsd  0x8a7(%rip),%xmm10
movss  %xmm2,0x14(%rsp)
movss  %xmm1,0x10(%rsp)
movss  %xmm11,0xc(%rsp)
jmp    17a1 <slasq2+0x661>
cs nopw 0x0(%rax,%rax,1)
movslq %ecx,%rax
movss  -0x4(%r13,%rax,4),%xmm0
minss  -0x8(%r13,%rax,4),%xmm0
mov    %ecx,%edi
movss  %xmm0,(%r15)
cmp    $0x3,%edi
jl     11a6 <slasq2+0x66>
lea    -0x1(%rdi),%ecx
movss  0x0(%r13,%rcx,4),%xmm6
movaps %xmm6,%xmm0
maxss  %xmm12,%xmm0
lea    -0x2(%rdi),%eax
movss  (%r14,%rax,4),%xmm5
maxss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
ucomiss %xmm5,%xmm0
jae    1830 <slasq2+0x6f0>
movaps %xmm6,%xmm0
addss  %xmm5,%xmm0
movss  0x0(%r13,%rax,4),%xmm7
addss  %xmm7,%xmm0
movaps %xmm6,%xmm3
divss  %xmm0,%xmm3
mulss  %xmm7,%xmm3
movaps %xmm11,%xmm0
maxss  %xmm3,%xmm0
lea    -0x3(%rdi),%edx
mulss  %xmm1,%xmm0
ucomiss (%r14,%rdx,4),%xmm0
jb     11a6 <slasq2+0x66>
movaps %xmm6,%xmm4
maxss  %xmm7,%xmm4
maxss  %xmm5,%xmm4
ucomiss %xmm12,%xmm4
jne    1813 <slasq2+0x6d3>
jnp    1852 <slasq2+0x712>
ucomiss %xmm7,%xmm4
jne    1861 <slasq2+0x721>
jp     1861 <slasq2+0x721>
movaps %xmm6,%xmm0
subss  %xmm7,%xmm0
jmp    1877 <slasq2+0x737>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm6,(%rbx,%rcx,4)
mov    %ecx,0x2809(%rip)
cmp    %edi,0x0(%rbp)
jl     1780 <slasq2+0x640>
mov    %ecx,0x0(%rbp)
mov    0x27f7(%rip),%ecx
jmp    1780 <slasq2+0x640>
mov    %eax,%edx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
xorps  %xmm5,%xmm5
jmp    1960 <slasq2+0x820>
ucomiss %xmm6,%xmm4
jne    198f <slasq2+0x84f>
jp     198f <slasq2+0x84f>
movaps %xmm7,%xmm0
subss  %xmm6,%xmm0
addss  %xmm5,%xmm0
divss  %xmm4,%xmm0
movaps %xmm5,%xmm3
mulss  %xmm8,%xmm3
divss  %xmm4,%xmm3
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm9,%xmm0
jb     18a4 <slasq2+0x764>
sqrtsd %xmm0,%xmm0
jmp    1907 <slasq2+0x7c7>
movss  %xmm6,0x8(%rsp)
movss  %xmm5,0x28(%rsp)
movss  %xmm7,0x20(%rsp)
movss  %xmm4,0x18(%rsp)
call   1050 <sqrt@plt>
movss  0x18(%rsp),%xmm4
movss  0x20(%rsp),%xmm7
movss  0x28(%rsp),%xmm5
movss  0x8(%rsp),%xmm6
movsd  0x726(%rip),%xmm10
xorpd  %xmm9,%xmm9
movss  0x710(%rip),%xmm8
movss  0xc(%rsp),%xmm11
xorps  %xmm12,%xmm12
movss  0x10(%rsp),%xmm1
movss  0x14(%rsp),%xmm2
addss  %xmm6,%xmm7
addss  %xmm5,%xmm7
xorps  %xmm3,%xmm3
cvtss2sd %xmm7,%xmm3
cvtss2sd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm10,%xmm4
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
movslq 0x270f(%rip),%rdx
lea    -0x1(%rdx),%rcx
movss  -0x8(%r13,%rdx,4),%xmm4
movss  -0x4(%r13,%rdx,4),%xmm5
add    $0xfffffffffffffffe,%rdx
movaps %xmm5,%xmm3
maxss  %xmm4,%xmm3
divss  %xmm0,%xmm3
minss  %xmm4,%xmm5
mulss  %xmm3,%xmm5
mov    %edx,%eax
movss  %xmm0,(%rbx,%rdx,4)
movss  %xmm5,(%rbx,%rcx,4)
mov    %eax,0x26d4(%rip)
cmp    %eax,0x0(%rbp)
jle    197e <slasq2+0x83e>
mov    %eax,0x0(%rbp)
mov    0x26c6(%rip),%eax
movslq %eax,%rcx
movss  -0x4(%r13,%rcx,4),%xmm0
mov    %eax,%edi
jmp    1793 <slasq2+0x653>
movaps %xmm6,%xmm0
subss  %xmm7,%xmm0
addss  %xmm5,%xmm0
divss  %xmm4,%xmm0
movaps %xmm7,%xmm3
jmp    1882 <slasq2+0x742>

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

LLVM IR (-O2):
@slasq2.n = internal global i32 0
@slasq2.sigma = internal global float 0.000000e+00
@slasq2.iconv = internal unnamed_addr global i1 false
@slasq2.iphase = internal global i32 0
@slasq2.off = internal global i32 0
@slasq2.off1 = internal unnamed_addr global i32 0
define void @slasq2(i32 %0, float* %1, float* %2, float* %3, float* %4, float %5, float %6, float %7, float* %8, i32* %9, i32* nocapture writeonly %10) {
store i32 %0, i32* @slasq2.n
store i32 0, i32* @slasq2.off
store i32 1, i32* @slasq2.off1
store float 0.000000e+00, float* @slasq2.sigma
store i1 false, i1* @slasq2.iconv
store i32 2, i32* @slasq2.iphase
%12 = icmp slt i32 %0, 3
br i1 %12, label %69, label %13
13: ; preds = %11
%14 = fcmp olt float %7, 0.000000e+00
%15 = select i1 %14, float 0.000000e+00, float %7
br label %16
16: ; preds = %13, %50
%17 = phi i32 [ %0, %13 ], [ %51, %50 ]
%18 = add nsw i32 %17, -1
%19 = zext i32 %18 to i64
%20 = getelementptr inbounds float, float* %3, i64 %19
%21 = load float, float* %20
%22 = fcmp ogt float %21, 0.000000e+00
%23 = select i1 %22, float %21, float 0.000000e+00
%24 = add nsw i32 %17, -2
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds float, float* %4, i64 %25
%27 = load float, float* %26
%28 = fcmp ogt float %23, %7
%29 = select i1 %28, float %23, float %7
%30 = fmul float %29, %6
%31 = fcmp ugt float %27, %30
br i1 %31, label %54, label %32
32: ; preds = %16
%33 = getelementptr inbounds float, float* %1, i64 %19
store float %21, float* %33
store i32 %18, i32* @slasq2.n
%34 = load i32, i32* %9
%35 = icmp slt i32 %34, %17
br i1 %35, label %38, label %36
36: ; preds = %32
store i32 %18, i32* %9
%37 = load i32, i32* @slasq2.n
br label %38
38: ; preds = %36, %32
%39 = phi i32 [ %37, %36 ], [ %18, %32 ]
%40 = add nsw i32 %39, -1
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %3, i64 %41
%43 = load float, float* %42
%44 = add nsw i32 %39, -2
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %3, i64 %45
%47 = load float, float* %46
%48 = fcmp olt float %43, %47
%49 = select i1 %48, float %43, float %47
br label %50
50: ; preds = %38, %160
%51 = phi i32 [ %39, %38 ], [ %161, %160 ]
%52 = phi float [ %49, %38 ], [ %165, %160 ]
store float %52, float* %8
%53 = icmp slt i32 %51, 3
br i1 %53, label %69, label %16
54: ; preds = %16
%55 = fadd float %21, %27
%56 = getelementptr inbounds float, float* %3, i64 %25
%57 = load float, float* %56
%58 = fadd float %55, %57
%59 = fdiv float %21, %58
%60 = fmul float %57, %59
%61 = add nsw i32 %17, -3
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds float, float* %4, i64 %62
%64 = load float, float* %63
%65 = fcmp ogt float %15, %60
%66 = select i1 %65, float %15, float %60
%67 = fmul float %66, %6
%68 = fcmp ugt float %64, %67
br i1 %68, label %69, label %74
69: ; preds = %50, %54, %11
%70 = phi i32 [ %0, %11 ], [ %17, %54 ], [ %51, %50 ]
%71 = fpext float %5 to double
%72 = fpext float %6 to double
%73 = fpext float %7 to double
br label %166
74: ; preds = %54
%75 = fcmp ogt float %21, %57
%76 = select i1 %75, float %21, float %57
%77 = fcmp ogt float %76, %27
%78 = select i1 %77, float %76, float %27
%79 = fcmp une float %78, 0.000000e+00
br i1 %79, label %80, label %145
80: ; preds = %74
%81 = fcmp oeq float %78, %57
br i1 %81, label %82, label %96
82: ; preds = %80
%83 = fsub float %21, %57
%84 = fadd float %83, %27
%85 = fdiv float %84, %78
%86 = fadd float %57, %21
%87 = fadd float %86, %27
%88 = fpext float %87 to double
%89 = fpext float %78 to double
%90 = fmul float %27, 4.000000e+00
%91 = fdiv float %90, %78
%92 = tail call float @llvm.fmuladd.f32(float %85, float %85, float %91)
%93 = fpext float %92 to double
%94 = tail call double @sqrt(double %93)
%95 = tail call double @llvm.fmuladd.f64(double %89, double %94, double %88)
br label %126
96: ; preds = %80
%97 = fcmp oeq float %78, %21
br i1 %97, label %98, label %112
98: ; preds = %96
%99 = fsub float %57, %21
%100 = fadd float %99, %27
%101 = fdiv float %100, %78
%102 = fadd float %57, %21
%103 = fadd float %102, %27
%104 = fpext float %103 to double
%105 = fpext float %78 to double
%106 = fmul float %27, 4.000000e+00
%107 = fdiv float %106, %78
%108 = tail call float @llvm.fmuladd.f32(float %101, float %101, float %107)
%109 = fpext float %108 to double
%110 = tail call double @sqrt(double %109)
%111 = tail call double @llvm.fmuladd.f64(double %105, double %110, double %104)
br label %126
112: ; preds = %96
%113 = fsub float %21, %57
%114 = fadd float %113, %27
%115 = fdiv float %114, %78
%116 = fadd float %57, %21
%117 = fadd float %116, %27
%118 = fpext float %117 to double
%119 = fpext float %78 to double
%120 = fmul float %57, 4.000000e+00
%121 = fdiv float %120, %78
%122 = tail call float @llvm.fmuladd.f32(float %115, float %115, float %121)
%123 = fpext float %122 to double
%124 = tail call double @sqrt(double %123)
%125 = tail call double @llvm.fmuladd.f64(double %119, double %124, double %118)
br label %126
126: ; preds = %98, %112, %82
%127 = phi double [ %111, %98 ], [ %125, %112 ], [ %95, %82 ]
%128 = fmul double %127, 5.000000e-01
%129 = fptrunc double %128 to float
%130 = load i32, i32* @slasq2.n
%131 = add nsw i32 %130, -1
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %3, i64 %132
%134 = load float, float* %133
%135 = add nsw i32 %130, -2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %3, i64 %136
%138 = load float, float* %137
%139 = fcmp ogt float %134, %138
%140 = select i1 %139, float %134, float %138
%141 = fdiv float %140, %129
%142 = fcmp olt float %134, %138
%143 = select i1 %142, float %134, float %138
%144 = fmul float %143, %141
br label %148
145: ; preds = %74
%146 = zext i32 %24 to i64
%147 = zext i32 %18 to i64
br label %148
148: ; preds = %145, %126
%149 = phi i64 [ %147, %145 ], [ %132, %126 ]
%150 = phi i64 [ %146, %145 ], [ %136, %126 ]
%151 = phi i32 [ %24, %145 ], [ %135, %126 ]
%152 = phi float [ 0.000000e+00, %145 ], [ %129, %126 ]
%153 = phi float [ 0.000000e+00, %145 ], [ %144, %126 ]
%154 = getelementptr inbounds float, float* %1, i64 %150
store float %152, float* %154
%155 = getelementptr inbounds float, float* %1, i64 %149
store float %153, float* %155
store i32 %151, i32* @slasq2.n
%156 = load i32, i32* %9
%157 = icmp sgt i32 %156, %151
br i1 %157, label %158, label %160
158: ; preds = %148
store i32 %151, i32* %9
%159 = load i32, i32* @slasq2.n
br label %160
160: ; preds = %158, %148
%161 = phi i32 [ %159, %158 ], [ %151, %148 ]
%162 = add nsw i32 %161, -1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %3, i64 %163
%165 = load float, float* %164
br label %50
166: ; preds = %484, %69
%167 = phi i32 [ %70, %69 ], [ %485, %484 ]
switch i32 %167, label %453 [
i32 0, label %168
i32 1, label %247
i32 2, label %268
]
168: ; preds = %166
%169 = load i32, i32* @slasq2.off
%170 = icmp eq i32 %169, 0
br i1 %170, label %486, label %171
171: ; preds = %168
%172 = add nsw i32 %169, -1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %4, i64 %173
%175 = load float, float* %174
%176 = fcmp ogt float %175, 0.000000e+00
%177 = fpext float %175 to double
%178 = fcmp olt float %175, 0.000000e+00
br i1 %176, label %179, label %189
179: ; preds = %171
br i1 %178, label %180, label %183
180: ; preds = %179
%181 = fadd double %177, -5.000000e-01
%182 = tail call double @llvm.ceil.f64(double %181)
br label %186
183: ; preds = %179
%184 = fadd double %177, 5.000000e-01
%185 = tail call double @llvm.floor.f64(double %184)
br label %186
186: ; preds = %183, %180
%187 = phi double [ %182, %180 ], [ %185, %183 ]
%188 = fptosi double %187 to i32
br label %200
189: ; preds = %171
br i1 %178, label %190, label %193
190: ; preds = %189
%191 = fadd double %177, -5.000000e-01
%192 = tail call double @llvm.ceil.f64(double %191)
br label %196
193: ; preds = %189
%194 = fadd double %177, 5.000000e-01
%195 = tail call double @llvm.floor.f64(double %194)
br label %196
196: ; preds = %193, %190
%197 = phi double [ %192, %190 ], [ %195, %193 ]
%198 = fptosi double %197 to i32
%199 = sub nsw i32 0, %198
br label %200
200: ; preds = %196, %186
%201 = phi i32 [ %199, %196 ], [ %188, %186 ]
%202 = phi i32 [ 2, %196 ], [ 1, %186 ]
store i32 %202, i32* @slasq2.iphase
%203 = getelementptr inbounds float, float* %2, i64 %173
%204 = load float, float* %203
store float %204, float* @slasq2.sigma
%205 = sub nsw i32 %169, %201
%206 = add nsw i32 %205, 1
store i32 %206, i32* @slasq2.n
store i32 %201, i32* @slasq2.off1
%207 = add nsw i32 %201, -1
store i32 %207, i32* @slasq2.off
%208 = icmp slt i32 %205, 2
br i1 %208, label %484, label %209
209: ; preds = %200
br i1 %176, label %210, label %225
210: ; preds = %209
%211 = getelementptr inbounds float, float* %1, i64 %173
%212 = load float, float* %211
%213 = add i32 %169, -2
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %1, i64 %214
%216 = load float, float* %215
%217 = fcmp olt float %212, %216
%218 = select i1 %217, float %212, float %216
%219 = add i32 %169, -3
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %1, i64 %220
%222 = load float, float* %221
%223 = fcmp olt float %218, %222
%224 = select i1 %223, float %218, float %222
br label %240
225: ; preds = %209
%226 = getelementptr inbounds float, float* %3, i64 %173
%227 = load float, float* %226
%228 = add i32 %169, -2
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %3, i64 %229
%231 = load float, float* %230
%232 = fcmp olt float %227, %231
%233 = select i1 %232, float %227, float %231
%234 = add i32 %169, -3
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float, float* %3, i64 %235
%237 = load float, float* %236
%238 = fcmp olt float %233, %237
%239 = select i1 %238, float %233, float %237
br label %240
240: ; preds = %210, %225
%241 = phi float [ %239, %225 ], [ %224, %210 ]
store float %241, float* %8
store i32 0, i32* %9
store i1 true, i1* @slasq2.iconv
%242 = sext i32 %207 to i64
%243 = getelementptr inbounds float, float* %1, i64 %242
%244 = getelementptr inbounds float, float* %2, i64 %242
%245 = getelementptr inbounds float, float* %3, i64 %242
%246 = getelementptr inbounds float, float* %4, i64 %242
br label %462
247: ; preds = %166
%248 = load i32, i32* @slasq2.iphase
%249 = icmp eq i32 %248, 1
br i1 %249, label %250, label %258
250: ; preds = %247
%251 = load float, float* @slasq2.sigma
%252 = load i32, i32* @slasq2.off1
%253 = add nsw i32 %252, -1
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds float, float* %1, i64 %254
%256 = load float, float* %255
%257 = fadd float %251, %256
store float %257, float* %255
br label %267
258: ; preds = %247
%259 = load i32, i32* @slasq2.off1
%260 = add nsw i32 %259, -1
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %3, i64 %261
%263 = load float, float* %262
%264 = load float, float* @slasq2.sigma
%265 = fadd float %263, %264
%266 = getelementptr inbounds float, float* %1, i64 %261
store float %265, float* %266
br label %267
267: ; preds = %250, %258, %436
store i32 0, i32* @slasq2.n
br label %484
268: ; preds = %166
%269 = load i32, i32* @slasq2.iphase
%270 = icmp eq i32 %269, 2
%271 = load i32, i32* @slasq2.off
%272 = add i32 %271, 1
%273 = sext i32 %272 to i64
br i1 %270, label %274, label %355
274: ; preds = %268
%275 = getelementptr inbounds float, float* %3, i64 %273
%276 = load float, float* %275
%277 = sext i32 %271 to i64
%278 = getelementptr inbounds float, float* %3, i64 %277
%279 = load float, float* %278
%280 = fcmp ogt float %276, %279
%281 = select i1 %280, float %276, float %279
%282 = getelementptr inbounds float, float* %4, i64 %277
%283 = load float, float* %282
%284 = fcmp ogt float %281, %283
%285 = select i1 %284, float %281, float %283
%286 = fcmp une float %285, 0.000000e+00
br i1 %286, label %287, label %436
287: ; preds = %274
%288 = fcmp oeq float %285, %279
br i1 %288, label %289, label %303
289: ; preds = %287
%290 = fsub float %276, %279
%291 = fadd float %290, %283
%292 = fdiv float %291, %285
%293 = fadd float %279, %276
%294 = fadd float %293, %283
%295 = fpext float %294 to double
%296 = fpext float %285 to double
%297 = fmul float %283, 4.000000e+00
%298 = fdiv float %297, %285
%299 = tail call float @llvm.fmuladd.f32(float %292, float %292, float %298)
%300 = fpext float %299 to double
%301 = tail call double @sqrt(double %300)
%302 = tail call double @llvm.fmuladd.f64(double %296, double %301, double %295)
br label %333
303: ; preds = %287
%304 = fcmp oeq float %285, %276
br i1 %304, label %305, label %319
305: ; preds = %303
%306 = fsub float %279, %276
%307 = fadd float %306, %283
%308 = fdiv float %307, %285
%309 = fadd float %279, %276
%310 = fadd float %309, %283
%311 = fpext float %310 to double
%312 = fpext float %285 to double
%313 = fmul float %283, 4.000000e+00
%314 = fdiv float %313, %285
%315 = tail call float @llvm.fmuladd.f32(float %308, float %308, float %314)
%316 = fpext float %315 to double
%317 = tail call double @sqrt(double %316)
%318 = tail call double @llvm.fmuladd.f64(double %312, double %317, double %311)
br label %333
319: ; preds = %303
%320 = fsub float %276, %279
%321 = fadd float %320, %283
%322 = fdiv float %321, %285
%323 = fadd float %279, %276
%324 = fadd float %323, %283
%325 = fpext float %324 to double
%326 = fpext float %285 to double
%327 = fmul float %279, 4.000000e+00
%328 = fdiv float %327, %285
%329 = tail call float @llvm.fmuladd.f32(float %322, float %322, float %328)
%330 = fpext float %329 to double
%331 = tail call double @sqrt(double %330)
%332 = tail call double @llvm.fmuladd.f64(double %326, double %331, double %325)
br label %333
333: ; preds = %305, %319, %289
%334 = phi double [ %318, %305 ], [ %332, %319 ], [ %302, %289 ]
%335 = fmul double %334, 5.000000e-01
%336 = fptrunc double %335 to float
%337 = load i32, i32* @slasq2.n
%338 = load i32, i32* @slasq2.off
%339 = add i32 %337, -1
%340 = add i32 %339, %338
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %3, i64 %341
%343 = load float, float* %342
%344 = add i32 %338, %337
%345 = add i32 %344, -2
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %3, i64 %346
%348 = load float, float* %347
%349 = fcmp ogt float %343, %348
%350 = select i1 %349, float %343, float %348
%351 = fdiv float %350, %336
%352 = fcmp olt float %343, %348
%353 = select i1 %352, float %343, float %348
%354 = fmul float %353, %351
br label %436
355: ; preds = %268
%356 = getelementptr inbounds float, float* %1, i64 %273
%357 = load float, float* %356
%358 = sext i32 %271 to i64
%359 = getelementptr inbounds float, float* %1, i64 %358
%360 = load float, float* %359
%361 = fcmp ogt float %357, %360
%362 = select i1 %361, float %357, float %360
%363 = getelementptr inbounds float, float* %2, i64 %358
%364 = load float, float* %363
%365 = fcmp ogt float %362, %364
%366 = select i1 %365, float %362, float %364
%367 = fcmp une float %366, 0.000000e+00
br i1 %367, label %368, label %436
368: ; preds = %355
%369 = fcmp oeq float %366, %360
br i1 %369, label %370, label %384
370: ; preds = %368
%371 = fsub float %357, %360
%372 = fadd float %371, %364
%373 = fdiv float %372, %366
%374 = fadd float %360, %357
%375 = fadd float %374, %364
%376 = fpext float %375 to double
%377 = fpext float %366 to double
%378 = fmul float %364, 4.000000e+00
%379 = fdiv float %378, %366
%380 = tail call float @llvm.fmuladd.f32(float %373, float %373, float %379)
%381 = fpext float %380 to double
%382 = tail call double @sqrt(double %381)
%383 = tail call double @llvm.fmuladd.f64(double %377, double %382, double %376)
br label %414
384: ; preds = %368
%385 = fcmp oeq float %366, %357
br i1 %385, label %386, label %400
386: ; preds = %384
%387 = fsub float %360, %357
%388 = fadd float %387, %364
%389 = fdiv float %388, %366
%390 = fadd float %360, %357
%391 = fadd float %390, %364
%392 = fpext float %391 to double
%393 = fpext float %366 to double
%394 = fmul float %364, 4.000000e+00
%395 = fdiv float %394, %366
%396 = tail call float @llvm.fmuladd.f32(float %389, float %389, float %395)
%397 = fpext float %396 to double
%398 = tail call double @sqrt(double %397)
%399 = tail call double @llvm.fmuladd.f64(double %393, double %398, double %392)
br label %414
400: ; preds = %384
%401 = fsub float %357, %360
%402 = fadd float %401, %364
%403 = fdiv float %402, %366
%404 = fadd float %360, %357
%405 = fadd float %404, %364
%406 = fpext float %405 to double
%407 = fpext float %366 to double
%408 = fmul float %360, 4.000000e+00
%409 = fdiv float %408, %366
%410 = tail call float @llvm.fmuladd.f32(float %403, float %403, float %409)
%411 = fpext float %410 to double
%412 = tail call double @sqrt(double %411)
%413 = tail call double @llvm.fmuladd.f64(double %407, double %412, double %406)
br label %414
414: ; preds = %386, %400, %370
%415 = phi double [ %399, %386 ], [ %413, %400 ], [ %383, %370 ]
%416 = fmul double %415, 5.000000e-01
%417 = fptrunc double %416 to float
%418 = load i32, i32* @slasq2.n
%419 = load i32, i32* @slasq2.off
%420 = add i32 %418, -1
%421 = add i32 %420, %419
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float, float* %1, i64 %422
%424 = load float, float* %423
%425 = add i32 %419, %418
%426 = add i32 %425, -2
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float, float* %1, i64 %427
%429 = load float, float* %428
%430 = fcmp ogt float %424, %429
%431 = select i1 %430, float %424, float %429
%432 = fdiv float %431, %417
%433 = fcmp olt float %424, %429
%434 = select i1 %433, float %424, float %429
%435 = fmul float %434, %432
br label %436
436: ; preds = %355, %274, %414, %333
%437 = phi float [ %435, %414 ], [ %354, %333 ], [ 0.000000e+00, %274 ], [ 0.000000e+00, %355 ]
%438 = phi i32 [ %419, %414 ], [ %338, %333 ], [ %271, %274 ], [ %271, %355 ]
%439 = phi i32 [ %418, %414 ], [ %337, %333 ], [ 2, %274 ], [ 2, %355 ]
%440 = phi float [ %417, %414 ], [ %336, %333 ], [ 0.000000e+00, %274 ], [ 0.000000e+00, %355 ]
%441 = load float, float* @slasq2.sigma
%442 = fadd float %441, %440
%443 = add i32 %438, %439
%444 = add i32 %443, -2
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds float, float* %1, i64 %445
store float %442, float* %446
%447 = load float, float* @slasq2.sigma
%448 = fadd float %437, %447
%449 = add i32 %439, -1
%450 = add i32 %449, %438
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds float, float* %1, i64 %451
store float %448, float* %452
br label %267
453: ; preds = %166
%454 = load i32, i32* @slasq2.off1
%455 = load i1, i1* @slasq2.iconv
%456 = add nsw i32 %454, -1
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds float, float* %1, i64 %457
%459 = getelementptr inbounds float, float* %2, i64 %457
%460 = getelementptr inbounds float, float* %3, i64 %457
%461 = getelementptr inbounds float, float* %4, i64 %457
br i1 %455, label %462, label %467
462: ; preds = %240, %453
%463 = phi float* [ %246, %240 ], [ %461, %453 ]
%464 = phi float* [ %245, %240 ], [ %460, %453 ]
%465 = phi float* [ %244, %240 ], [ %459, %453 ]
%466 = phi float* [ %243, %240 ], [ %458, %453 ]
br label %467
467: ; preds = %453, %462
%468 = phi float* [ %463, %462 ], [ %461, %453 ]
%469 = phi float* [ %464, %462 ], [ %460, %453 ]
%470 = phi float* [ %465, %462 ], [ %459, %453 ]
%471 = phi float* [ %466, %462 ], [ %458, %453 ]
%472 = phi i32 [ -3, %462 ], [ 0, %453 ]
%473 = tail call i32 (i32*, float*, float*, float*, float*, float*, float*, i32*, i32*, i32*, i32, double, double, double, ...) bitcast (i32 (...)* @slasq3 to i32 (i32*, float*, float*, float*, float*, float*, float*, i32*, i32*, i32*, i32, double, double, double, ...)*)(i32* @slasq2.n, float* %471, float* %470, float* %469, float* %468, float* %8, float* @slasq2.sigma, i32* %9, i32* @slasq2.off, i32* @slasq2.iphase, i32 %472, double %71, double %72, double %73)
%474 = load float, float* %8
%475 = fcmp olt float %474, 0.000000e+00
br i1 %475, label %476, label %480
476: ; preds = %467
%477 = load i32, i32* @slasq2.n
%478 = load i32, i32* @slasq2.off
%479 = add nsw i32 %478, %477
store i32 %479, i32* %10
br label %486
480: ; preds = %467
%481 = load i32, i32* @slasq2.off
%482 = add nsw i32 %481, 1
store i32 %482, i32* @slasq2.off1
%483 = load i32, i32* @slasq2.n
br label %484
484: ; preds = %480, %267, %200
%485 = phi i32 [ %483, %480 ], [ %206, %200 ], [ 0, %267 ]
br label %166
486: ; preds = %168, %476
ret void
}