void slasq1(int n__, float *d, float *e, float *work, int *info) {
  static double c_b8 = .125;
  static int c__1 = 1;
  static int c__0 = 0;
  int i__1, i__2;
  float r__1, r__2, r__3, r__4;
  double d__1;
  static int kend, ierr;
  static int i, j, m;
  static float sfmin, sigmn, sigmx;
  static float small2;
  static int ke;
  static float dm, dx;
  static int ny;
  static float thresh;
  static float tolmul;
  static int restrt;
  static float scl, eps, tol, sig1, sig2, tol2;
  *info = 0;
  if (n__ < 0) {
    *info = -2;
    i__1 = -(*info);
    return;
  } else if (n__ == 0) {
    return;
  } else if (n__ == 1) {
    d[(1) - 1] = fabs(d[(1) - 1]);
    return;
  } else if (n__ == 2) {
    slas2(d[(1) - 1], e[(1) - 1], d[(2) - 1], &sigmn, &sigmx);
    d[(1) - 1] = sigmx;
    d[(2) - 1] = sigmn;
    return;
  }
  sigmx = 0.f;
  i__1 = n__ - 1;
  for (i = 1; i <= n__ - 1; ++i) {
    r__2 = sigmx, r__3 = (r__1 = e[(i)-1], fabs(r__1));
    sigmx = (((r__2) > (r__3)) ? (r__2) : (r__3));
  }
  if (sigmx == 0.f) {
    goto L70;
  }
  i__1 = n__;
  for (i = 1; i <= n__; ++i) {
    d[(i)-1] = (r__1 = d[(i)-1], fabs(r__1));
    r__1 = sigmx, r__2 = d[(i)-1];
    sigmx = (((r__1) > (r__2)) ? (r__1) : (r__2));
  }
  eps = slamch("EPSILON");
  sfmin = slamch("SAFE MINIMUM");
  d__1 = (double)eps;
  r__3 = 100.f, r__4 = pow(d__1, c_b8);
  r__1 = 10.f, r__2 = (((r__3) < (r__4)) ? (r__3) : (r__4));
  tolmul = (((r__1) > (r__2)) ? (r__1) : (r__2));
  tol = tolmul * eps;
  r__1 = tol;
  tol2 = r__1 * r__1;
  thresh = sigmx * sqrt(sfmin) * tol;
  scl = sqrt(1.f / (sfmin * 256.f));
  r__1 = tolmul;
  small2 = 1.f / (r__1 * r__1 * 256.f);
  scopy(n__, &d[(1) - 1], c__1, &work[(1) - 1], c__1);
  i__1 = n__ - 1;
  scopy(i__1, &e[(1) - 1], c__1, &work[(n__ + 1) - 1], c__1);
  slascl("G", c__0, c__0, sigmx, scl, n__, c__1, &work[(1) - 1], n__, &ierr);
  i__1 = n__ - 1;
  i__2 = n__ - 1;
  slascl("G", c__0, c__0, sigmx, scl, i__1, c__1, &work[(n__ + 1) - 1], i__2,
         &ierr);
  i__1 = (n__ << 1) - 1;
  for (j = 1; j <= (n__ << 1) - 1; ++j) {
    r__1 = work[(j)-1];
    work[(j)-1] = r__1 * r__1;
  }
  m = 0;
  e[(n__)-1] = 0.f;
  dx = work[(1) - 1];
  dm = dx;
  ke = 0;
  restrt = 0;
  i__1 = n__;
  for (i = 1; i <= n__; ++i) {
    if ((r__1 = e[(i)-1], fabs(r__1)) <= thresh ||
        work[(n__ + i) - 1] <= tol2 * (dm / (float)(i - m))) {
      ny = i - m;
      if (ny == 1) {
        goto L50;
      } else if (ny == 2) {
        slas2(d[(m + 1) - 1], e[(m + 1) - 1], d[(m + 2) - 1], &sig1, &sig2);
        d[(m + 1) - 1] = sig1;
        d[(m + 2) - 1] = sig2;
      } else {
        kend = ke + 1 - m;
        slasq2(ny, &d[(m + 1) - 1], &e[(m + 1) - 1], &work[(m + 1) - 1],
               &work[(m + n__ + 1) - 1], eps, tol2, small2, &dm, &kend, info);
        if (*info != 0) {
          *info += i;
          return;
        }
        i__2 = m + ny;
        for (j = m + 1; j <= m + ny; ++j) {
          d[(j)-1] = sqrt(d[(j)-1]);
        }
        slascl("G", c__0, c__0, scl, sigmx, ny, c__1, &d[(m + 1) - 1], ny,
               &ierr);
      }
    L50:
      m = i;
      if (i != n__) {
        dx = work[(i + 1) - 1];
        dm = dx;
        ke = i;
        restrt = 1;
      }
    }
    if (i != n__ && !restrt) {
      dx = work[(i + 1) - 1] * (dx / (dx + work[(n__ + i) - 1]));
      if (dm > dx) {
        dm = dx;
        ke = i;
      }
    }
    restrt = 0;
  }
  kend = ke + 1;
L70:
  slasrt("D", n__, &d[(1) - 1], info);
}


x86 assembly (clang, -O0):
<slasq1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
cmpl   $0x0,-0x4(%rbp)
jge    11c9 <slasq1+0x49>
mov    -0x28(%rbp),%rax
movl   $0xfffffffe,(%rax)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x2c(%rbp)
jmp    1cb4 <slasq1+0xb34>
cmpl   $0x0,-0x4(%rbp)
jne    11d8 <slasq1+0x58>
jmp    1cb4 <slasq1+0xb34>
cmpl   $0x1,-0x4(%rbp)
jne    120a <slasq1+0x8a>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xe1b(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1cb4 <slasq1+0xb34>
cmpl   $0x2,-0x4(%rbp)
jne    1274 <slasq1+0xf4>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x2e4c(%rip),%rdi
lea    0x2e49(%rip),%rsi
mov    $0x3,%al
call   1070 <slas2@plt>
movss  0x2e3a(%rip),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  0x2e26(%rip),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    1cb4 <slasq1+0xb34>
jmp    1279 <slasq1+0xf9>
jmp    127e <slasq1+0xfe>
jmp    1283 <slasq1+0x103>
xorps  %xmm0,%xmm0
movss  %xmm0,0x2e02(%rip)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2ddb(%rip)
mov    0x2dd5(%rip),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1342 <slasq1+0x1c2>
movss  0x2dd3(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    0x2db0(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xd24(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x3c(%rbp),%xmm0
jbe    1317 <slasq1+0x197>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1321 <slasq1+0x1a1>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,0x2d62(%rip)
mov    0x2d48(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d3f(%rip)
jmp    12a1 <slasq1+0x121>
movss  0x2d46(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1361 <slasq1+0x1e1>
jp     1361 <slasq1+0x1e1>
jmp    1c9b <slasq1+0xb1b>
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2d0b(%rip)
mov    0x2d05(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1437 <slasq1+0x2b7>
mov    -0x10(%rbp),%rax
mov    0x2cf2(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xc66(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    0x2cc0(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x2cc1(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2c9e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
ucomiss -0x38(%rbp),%xmm0
jbe    140c <slasq1+0x28c>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    1416 <slasq1+0x296>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,0x2c6d(%rip)
mov    0x2c53(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c4a(%rip)
jmp    1371 <slasq1+0x1f1>
lea    0xbe2(%rip),%rdi
mov    $0x0,%al
call   1060 <slamch@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2c67(%rip)
lea    0xbd0(%rip),%rdi
mov    $0x0,%al
call   1060 <slamch@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2c1d(%rip)
movss  0x2c45(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  0xb80(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x2bca(%rip),%xmm1
call   1080 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xb54(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    14d3 <slasq1+0x353>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    14dd <slasq1+0x35d>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
ucomiss -0x38(%rbp),%xmm0
jbe    1505 <slasq1+0x385>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    150f <slasq1+0x38f>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,0x2b90(%rip)
movss  0x2b88(%rip),%xmm0
mulss  0x2b8c(%rip),%xmm0
movss  %xmm0,0x2b88(%rip)
movss  0x2b80(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,0x2b75(%rip)
movss  0x2b35(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  0x2b1c(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movss  0x2b33(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2b0b(%rip)
movss  0xa67(%rip),%xmm1
mulss  0x2adb(%rip),%xmm1
movss  0xa53(%rip),%xmm0
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2ae6(%rip)
movss  0x2ad6(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movss  0xa1f(%rip),%xmm0
mulss  %xmm0,%xmm1
movss  0xa0f(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x2a8f(%rip)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    0x2a56(%rip),%edx
mov    -0x20(%rbp),%rcx
mov    0x2a4b(%rip),%r8d
mov    $0x0,%al
call   1040 <scopy@plt>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    0x2a2e(%rip),%edx
mov    -0x20(%rbp),%rcx
mov    -0x4(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    0x2a11(%rip),%r8d
mov    $0x0,%al
call   1040 <scopy@plt>
mov    0x2a0c(%rip),%esi
mov    0x2a06(%rip),%edx
movss  0x2a1e(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2a36(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x4(%rbp),%ecx
mov    0x29dc(%rip),%r8d
mov    -0x20(%rbp),%r9
mov    -0x4(%rbp),%r10d
lea    0x99a(%rip),%rdi
lea    0x29d6(%rip),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   10a0 <slascl@plt>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    0x29a6(%rip),%esi
mov    0x29a0(%rip),%edx
movss  0x29b8(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x29d0(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x2c(%rbp),%ecx
mov    0x2976(%rip),%r8d
mov    -0x20(%rbp),%r9
mov    -0x4(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r9
mov    -0x30(%rbp),%r10d
lea    0x922(%rip),%rdi
lea    0x295e(%rip),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   10a0 <slascl@plt>
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2940(%rip)
mov    0x293a(%rip),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     17a4 <slasq1+0x624>
mov    -0x20(%rbp),%rax
mov    0x291f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x28fb(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28ea(%rip),%eax
add    $0x1,%eax
mov    %eax,0x28e1(%rip)
jmp    1740 <slasq1+0x5c0>
movl   $0x0,0x28d6(%rip)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x28cd(%rip)
movss  0x28c5(%rip),%xmm0
movss  %xmm0,0x28b9(%rip)
movl   $0x0,0x28ab(%rip)
movl   $0x0,0x28b9(%rip)
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2875(%rip)
mov    0x286f(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1c8c <slasq1+0xb0c>
mov    -0x18(%rbp),%rax
mov    0x285c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x7d0(%rip),%xmm0
pand   %xmm0,%xmm1
movss  0x285c(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jae    18a3 <slasq1+0x723>
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    0x2815(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x284e(%rip),%xmm0
movss  0x281a(%rip),%xmm2
mov    0x27f4(%rip),%eax
sub    0x27f6(%rip),%eax
cvtsi2ss %eax,%xmm3
divss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
jb     1bcc <slasq1+0xa4c>
mov    0x27d3(%rip),%eax
sub    0x27d5(%rip),%eax
mov    %eax,0x27ef(%rip)
cmpl   $0x1,0x27e8(%rip)
jne    18c7 <slasq1+0x747>
jmp    1b66 <slasq1+0x9e6>
cmpl   $0x2,0x27d6(%rip)
jne    1982 <slasq1+0x802>
mov    -0x10(%rbp),%rax
mov    0x27a6(%rip),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x278a(%rip),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    0x276e(%rip),%ecx
add    $0x2,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x2791(%rip),%rdi
lea    0x278e(%rip),%rsi
mov    $0x3,%al
call   1070 <slas2@plt>
movss  0x277b(%rip),%xmm0
mov    -0x10(%rbp),%rax
mov    0x2735(%rip),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x275f(%rip),%xmm0
mov    -0x10(%rbp),%rax
mov    0x2715(%rip),%ecx
add    $0x2,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b5c <slasq1+0x9dc>
mov    0x2710(%rip),%eax
add    $0x1,%eax
sub    0x26f3(%rip),%eax
mov    %eax,0x26dd(%rip)
mov    0x2707(%rip),%edi
mov    -0x10(%rbp),%rsi
mov    0x26dd(%rip),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    0x26c4(%rip),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rcx
mov    0x26ab(%rip),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%r8
mov    0x2692(%rip),%eax
add    -0x4(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r8
movss  0x26ac(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x26b0(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x2670(%rip),%xmm2
cvtss2sd %xmm2,%xmm2
mov    -0x28(%rbp),%rax
lea    0x2669(%rip),%r9
lea    0x263a(%rip),%r10
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x3,%al
call   1030 <slasq2@plt>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     1a6a <slasq1+0x8ea>
mov    0x261f(%rip),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    1cb4 <slasq1+0xb34>
mov    0x2614(%rip),%eax
add    0x262e(%rip),%eax
mov    %eax,-0x30(%rbp)
mov    0x2605(%rip),%eax
add    $0x1,%eax
mov    %eax,0x25f8(%rip)
mov    0x25f2(%rip),%eax
mov    0x25f0(%rip),%ecx
add    0x260a(%rip),%ecx
cmp    %ecx,%eax
jg     1aed <slasq1+0x96d>
mov    -0x10(%rbp),%rax
mov    0x25d4(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    0x25b2(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x25a1(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2598(%rip)
jmp    1a88 <slasq1+0x908>
mov    0x257d(%rip),%esi
mov    0x2577(%rip),%edx
movss  0x25b3(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2583(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mov    0x258d(%rip),%ecx
mov    0x254a(%rip),%r8d
mov    -0x10(%rbp),%r9
mov    0x255c(%rip),%eax
add    $0x1,%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r9
mov    0x2566(%rip),%r10d
lea    0x4f0(%rip),%rdi
lea    0x252c(%rip),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   10a0 <slascl@plt>
jmp    1b61 <slasq1+0x9e1>
jmp    1b66 <slasq1+0x9e6>
mov    0x2510(%rip),%eax
mov    %eax,0x2512(%rip)
mov    0x2504(%rip),%eax
cmp    -0x4(%rbp),%eax
je     1bc7 <slasq1+0xa47>
mov    -0x20(%rbp),%rax
mov    0x24f1(%rip),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x24ff(%rip)
movss  0x24f7(%rip),%xmm0
movss  %xmm0,0x24eb(%rip)
mov    0x24c5(%rip),%eax
mov    %eax,0x24db(%rip)
movl   $0x1,0x24e9(%rip)
jmp    1bcc <slasq1+0xa4c>
mov    0x24aa(%rip),%eax
cmp    -0x4(%rbp),%eax
je     1c6e <slasq1+0xaee>
cmpl   $0x0,0x24ce(%rip)
jne    1c6e <slasq1+0xaee>
mov    -0x20(%rbp),%rax
mov    0x248a(%rip),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0x2498(%rip),%xmm1
movss  0x2490(%rip),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    0x245f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,0x2468(%rip)
movss  0x245c(%rip),%xmm0
ucomiss 0x2459(%rip),%xmm0
jbe    1c69 <slasq1+0xae9>
movss  0x244b(%rip),%xmm0
movss  %xmm0,0x243f(%rip)
mov    0x2419(%rip),%eax
mov    %eax,0x242f(%rip)
jmp    1c6e <slasq1+0xaee>
movl   $0x0,0x2438(%rip)
mov    0x23fe(%rip),%eax
add    $0x1,%eax
mov    %eax,0x23f5(%rip)
jmp    1807 <slasq1+0x687>
mov    0x2406(%rip),%eax
add    $0x1,%eax
mov    %eax,0x23d9(%rip)
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rcx
lea    0x38a(%rip),%rdi
mov    $0x0,%al
call   1050 <slasrt@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slasq1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%r14
movl   $0x0,(%r8)
test   %edi,%edi
js     11db <slasq1+0x4b>
je     1233 <slasq1+0xa3>
mov    %rdx,%rbx
mov    %rsi,%r12
mov    %edi,%r15d
cmp    $0x2,%edi
je     11e4 <slasq1+0x54>
cmp    $0x1,%r15d
jne    1242 <slasq1+0xb2>
movss  (%r12),%xmm0
andps  0xe2d(%rip),%xmm0
movss  %xmm0,(%r12)
jmp    1233 <slasq1+0xa3>
movl   $0xfffffffe,(%r14)
jmp    1233 <slasq1+0xa3>
movss  (%r12),%xmm0
movss  0x4(%r12),%xmm2
cvtss2sd %xmm0,%xmm0
movss  (%rbx),%xmm1
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
lea    0x2e7c(%rip),%rdi
lea    0x2e79(%rip),%rsi
mov    $0x3,%al
call   1080 <slas2@plt>
movss  0x2e6a(%rip),%xmm0
movss  %xmm0,(%r12)
movss  0x2e58(%rip),%xmm0
movss  %xmm0,0x4(%r12)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,%r13
movl   $0x0,0x2e39(%rip)
mov    %r15d,%eax
lea    -0x1(%rax),%rcx
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xorps  %xmm0,%xmm0
xor    %edx,%edx
movaps 0xd97(%rip),%xmm2
nopl   0x0(%rax)
movss  (%rbx,%rdx,4),%xmm1
andps  %xmm2,%xmm1
maxss  %xmm1,%xmm0
movss  %xmm0,0x2e04(%rip)
movss  0x4(%rbx,%rdx,4),%xmm1
andps  %xmm2,%xmm1
maxss  %xmm1,%xmm0
movss  %xmm0,0x2def(%rip)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1270 <slasq1+0xe0>
test   $0x1,%cl
je     12bf <slasq1+0x12f>
movss  (%rbx,%rdx,4),%xmm1
andps  0xd4d(%rip),%xmm1
maxss  %xmm1,%xmm0
movss  %xmm0,0x2dc9(%rip)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
mov    %r15d,0x2da8(%rip)
jne    12d4 <slasq1+0x144>
jnp    19c3 <slasq1+0x833>
test   %r15d,%r15d
jle    12e6 <slasq1+0x156>
lea    0x1(%r15),%ecx
cmp    $0x2,%ecx
jne    12f0 <slasq1+0x160>
xor    %edx,%edx
jmp    1351 <slasq1+0x1c1>
mov    $0x1,%ecx
jmp    137c <slasq1+0x1ec>
mov    %eax,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rdx,4),%xmm0
andps  %xmm2,%xmm0
movss  %xmm0,(%r12,%rdx,4)
movss  0x2d71(%rip),%xmm1
maxss  %xmm0,%xmm1
movss  %xmm1,0x2d65(%rip)
movss  0x4(%r12,%rdx,4),%xmm0
andps  %xmm2,%xmm0
movss  %xmm0,0x4(%r12,%rdx,4)
movss  0x2d4c(%rip),%xmm1
maxss  %xmm0,%xmm1
movss  %xmm1,0x2d40(%rip)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1300 <slasq1+0x170>
test   $0x1,%al
je     137c <slasq1+0x1ec>
movss  (%r12,%rdx,4),%xmm0
andps  0xc9e(%rip),%xmm0
movss  %xmm0,(%r12,%rdx,4)
movss  0x2d18(%rip),%xmm1
maxss  %xmm0,%xmm1
movss  %xmm1,0x2d0c(%rip)
mov    %ecx,0x2cf2(%rip)
lea    0xca3(%rip),%rdi
xor    %eax,%eax
call   1070 <slamch@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2d0d(%rip)
lea    0xc8e(%rip),%rdi
xor    %eax,%eax
call   1070 <slamch@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2cc4(%rip)
movss  0x2ce8(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc40(%rip),%xmm1
call   1090 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  0xc37(%rip),%xmm1
minss  %xmm0,%xmm1
movss  0xc2f(%rip),%xmm0
maxss  %xmm1,%xmm0
movss  %xmm0,0x2cab(%rip)
mulss  0x2cab(%rip),%xmm0
movss  %xmm0,0x2ca7(%rip)
mulss  %xmm0,%xmm0
movss  %xmm0,0x2ca7(%rip)
movss  0x2c6b(%rip),%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movss  0x2c54(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     143f <slasq1+0x2af>
sqrtsd %xmm0,%xmm0
jmp    1450 <slasq1+0x2c0>
movsd  %xmm2,0x8(%rsp)
call   10a0 <sqrt@plt>
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
lea    -0x1(%r15),%eax
mov    %rax,0x8(%rsp)
movss  0x2c4b(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x2c24(%rip)
movss  0x2bfc(%rip),%xmm1
mulss  0xb94(%rip),%xmm1
movss  0xb90(%rip),%xmm2
movaps %xmm2,%xmm0
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     14a9 <slasq1+0x319>
sqrtss %xmm0,%xmm0
jmp    14b6 <slasq1+0x326>
call   1060 <sqrtf@plt>
movss  0xb6e(%rip),%xmm2
movss  %xmm0,0x2bea(%rip)
movss  0x2bde(%rip),%xmm0
mulss  %xmm0,%xmm0
mulss  0xb4e(%rip),%xmm0
divss  %xmm0,%xmm2
movss  %xmm2,0x2bae(%rip)
mov    %r15d,%edi
mov    %r12,%rsi
mov    $0x1,%edx
mov    %r13,%rcx
mov    $0x1,%r8d
xor    %eax,%eax
call   1040 <scopy@plt>
movslq %r15d,%rax
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
mov    %rcx,0x10(%rsp)
mov    0x8(%rsp),%rdi
mov    %rdi,%rbp
mov    %rbx,%rsi
mov    $0x1,%edx
mov    $0x1,%r8d
xor    %eax,%eax
call   1040 <scopy@plt>
movss  0x2b57(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2b6b(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x2b28(%rip),%r10
lea    0xaf2(%rip),%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    %r15d,%ecx
mov    $0x1,%r8d
mov    %r13,%r9
mov    $0x2,%al
push   %r10
push   %r15
call   10b0 <slascl@plt>
add    $0x10,%rsp
movss  0x2b12(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2b26(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xab4(%rip),%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    %rbp,%rcx
mov    $0x1,%r8d
mov    0x10(%rsp),%r9
mov    $0x2,%al
lea    0x2ac8(%rip),%rbp
push   %rbp
push   %rcx
call   10b0 <slascl@plt>
add    $0x10,%rsp
lea    (%r15,%r15,1),%eax
mov    $0x1,%ecx
cmp    $0x2,%eax
movaps 0xa3a(%rip),%xmm4
jl     16ad <slasq1+0x51d>
mov    %eax,%ecx
lea    -0x1(%rcx),%rdx
mov    $0x1,%esi
cmp    $0x8,%rdx
jb     1690 <slasq1+0x500>
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1658 <slasq1+0x4c8>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%r13,%rdi,4),%xmm0
movups 0x10(%r13,%rdi,4),%xmm1
movups 0x20(%r13,%rdi,4),%xmm2
movups 0x30(%r13,%rdi,4),%xmm3
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
movups %xmm0,0x0(%r13,%rdi,4)
movups %xmm1,0x10(%r13,%rdi,4)
mulps  %xmm2,%xmm2
mulps  %xmm3,%xmm3
movups %xmm2,0x20(%r13,%rdi,4)
movups %xmm3,0x30(%r13,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1610 <slasq1+0x480>
jmp    165a <slasq1+0x4ca>
xor    %edi,%edi
or     $0x1,%rdx
test   $0x1,%bpl
je     1682 <slasq1+0x4f2>
movups 0x0(%r13,%rdi,4),%xmm0
movups 0x10(%r13,%rdi,4),%xmm1
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
movups %xmm0,0x0(%r13,%rdi,4)
movups %xmm1,0x10(%r13,%rdi,4)
mov    %rdx,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%r13,%rsi,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,-0x4(%r13,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1690 <slasq1+0x500>
mov    %eax,%ecx
mov    %ecx,0x29c5(%rip)
movl   $0x0,0x29bf(%rip)
movslq 0x8(%rsp),%rax
movl   $0x0,(%rbx,%rax,4)
movss  0x0(%r13),%xmm0
movss  %xmm0,0x29c1(%rip)
movss  %xmm0,0x29b5(%rip)
movl   $0x0,0x29a7(%rip)
movl   $0x1,0x2981(%rip)
test   %r15d,%r15d
mov    $0x1,%eax
jle    19bd <slasq1+0x82d>
mov    $0x1,%ecx
xor    %eax,%eax
jmp    17b8 <slasq1+0x628>
cltq
movss  (%r12,%rax,4),%xmm0
movss  0x4(%r12,%rax,4),%xmm2
cvtss2sd %xmm0,%xmm0
movss  (%rbx,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
lea    0x2980(%rip),%rdi
lea    0x297d(%rip),%rsi
mov    $0x3,%al
call   1080 <slas2@plt>
movaps 0x8b7(%rip),%xmm4
movss  0x2963(%rip),%xmm0
movslq 0x2924(%rip),%rax
movss  %xmm0,(%r12,%rax,4)
movss  0x2952(%rip),%xmm0
movss  %xmm0,0x4(%r12,%rax,4)
mov    0x2901(%rip),%ecx
mov    %ecx,0x2903(%rip)
cmp    %r15d,%ecx
je     19aa <slasq1+0x81a>
movslq %ecx,%rax
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x2904(%rip)
mov    %ecx,%eax
movss  %xmm0,0x28f6(%rip)
mov    %ecx,0x28ec(%rip)
lea    0x1(%rcx),%edx
mov    %edx,0x28c7(%rip)
cmp    %r15d,%ecx
mov    %edx,%ecx
jge    19b4 <slasq1+0x824>
movslq %ecx,%rdx
movss  -0x4(%rbx,%rdx,4),%xmm0
andps  %xmm4,%xmm0
movss  0x28d4(%rip),%xmm1
ucomiss %xmm0,%xmm1
jae    1850 <slasq1+0x6c0>
mov    0x8(%rsp),%rsi
add    %ecx,%esi
mov    %ecx,%edi
sub    %eax,%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movss  0x28a9(%rip),%xmm1
divss  %xmm0,%xmm1
mulss  0x28c5(%rip),%xmm1
movslq %esi,%rsi
ucomiss 0x0(%r13,%rsi,4),%xmm1
jae    1854 <slasq1+0x6c4>
cmp    %r15d,%ecx
je     17a4 <slasq1+0x614>
movss  0x2889(%rip),%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
addss  %xmm0,%xmm1
divss  %xmm1,%xmm0
mulss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,0x286b(%rip)
movss  0x285f(%rip),%xmm1
ucomiss %xmm0,%xmm1
ja     1796 <slasq1+0x606>
jmp    17a4 <slasq1+0x614>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    %eax,%ecx
mov    %ecx,%edi
mov    %edi,0x2842(%rip)
cmp    $0x1,%edi
je     176d <slasq1+0x5dd>
cmp    $0x2,%edi
je     170d <slasq1+0x57d>
mov    0x281e(%rip),%ecx
sub    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,0x27ef(%rip)
movslq %eax,%rcx
lea    (%r12,%rcx,4),%rsi
lea    (%rbx,%rcx,4),%rdx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
add    %r15d,%eax
cltq
lea    0x0(,%rax,4),%r8
add    %r13,%r8
movss  0x2801(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2805(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x27c9(%rip),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0x27c6(%rip),%r9
mov    $0x3,%al
push   %r14
lea    0x2793(%rip),%rbp
push   %rbp
call   1030 <slasq2@plt>
add    $0x10,%rsp
mov    (%r14),%eax
test   %eax,%eax
jne    19e8 <slasq1+0x858>
mov    0x2788(%rip),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x277b(%rip)
mov    0x2799(%rip),%ecx
mov    %eax,%edx
test   %ecx,%ecx
jg     1993 <slasq1+0x803>
movss  0x2793(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2767(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movslq %edx,%rax
lea    (%r12,%rax,4),%r9
lea    0x70e(%rip),%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    $0x1,%r8d
mov    $0x2,%al
lea    0x272a(%rip),%rbp
push   %rbp
push   %rcx
call   10b0 <slascl@plt>
add    $0x10,%rsp
movaps 0x6a8(%rip),%xmm4
jmp    176d <slasq1+0x5dd>
nopl   (%rax)
call   1060 <sqrtf@plt>
movslq 0x270c(%rip),%rax
movss  %xmm0,-0x4(%r12,%rax,4)
lea    0x1(%rax),%ecx
mov    %ecx,0x26fc(%rip)
mov    0x26fa(%rip),%edx
mov    0x2714(%rip),%ecx
lea    (%rcx,%rdx,1),%esi
cmp    %esi,%eax
jge    190d <slasq1+0x77d>
cltq
movss  (%r12,%rax,4),%xmm0
ucomiss 0x686(%rip),%xmm0
jb     1960 <slasq1+0x7d0>
sqrtss %xmm0,%xmm0
jmp    1965 <slasq1+0x7d5>
lea    0x1(%r15),%eax
mov    %eax,0x26c0(%rip)
mov    0x26d6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26a9(%rip)
lea    0x679(%rip),%rdi
mov    %r15d,%esi
mov    %r12,%rdx
mov    %r14,%rcx
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <slasrt@plt>
add    0x2686(%rip),%eax
mov    %eax,(%r14)
jmp    1233 <slasq1+0xa3>

LLVM IR (-O0):
@slasq1.c_b8 = internal global double 1.250000e-01
@slasq1.c__1 = internal global i32 1
@slasq1.c__0 = internal global i32 0
@slasq1.kend = internal global i32 0
@slasq1.ierr = internal global i32 0
@slasq1.i = internal global i32 0
@slasq1.j = internal global i32 0
@slasq1.m = internal global i32 0
@slasq1.sfmin = internal global float 0.000000e+00
@slasq1.sigmn = internal global float 0.000000e+00
@slasq1.sigmx = internal global float 0.000000e+00
@slasq1.small2 = internal global float 0.000000e+00
@slasq1.ke = internal global i32 0
@slasq1.dm = internal global float 0.000000e+00
@slasq1.dx = internal global float 0.000000e+00
@slasq1.ny = internal global i32 0
@slasq1.thresh = internal global float 0.000000e+00
@slasq1.tolmul = internal global float 0.000000e+00
@slasq1.restrt = internal global i32 0
@slasq1.scl = internal global float 0.000000e+00
@slasq1.eps = internal global float 0.000000e+00
@slasq1.tol = internal global float 0.000000e+00
@slasq1.sig1 = internal global float 0.000000e+00
@slasq1.sig2 = internal global float 0.000000e+00
@slasq1.tol2 = internal global float 0.000000e+00
@.str = [8 x i8] c"EPSILON\00"
@.str.1 = [13 x i8] c"SAFE MINIMUM\00"
@.str.2 = [2 x i8] c"G\00"
@.str.3 = [2 x i8] c"D\00"
define void @slasq1(i32 %0, float* %1, float* %2, float* %3, i32* %4) {
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca double
store i32 %0, i32* %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store i32* %4, i32** %10
%18 = load i32*, i32** %10
store i32 0, i32* %18
%19 = load i32, i32* %6
%20 = icmp slt i32 %19, 0
br i1 %20, label %21, label %26
21: ; preds = %5
%22 = load i32*, i32** %10
store i32 -2, i32* %22
%23 = load i32*, i32** %10
%24 = load i32, i32* %23
%25 = sub nsw i32 0, %24
store i32 %25, i32* %11
br label %541
26: ; preds = %5
%27 = load i32, i32* %6
%28 = icmp eq i32 %27, 0
br i1 %28, label %29, label %30
29: ; preds = %26
br label %541
30: ; preds = %26
%31 = load i32, i32* %6
%32 = icmp eq i32 %31, 1
br i1 %32, label %33, label %42
33: ; preds = %30
%34 = load float*, float** %7
%35 = getelementptr inbounds float, float* %34, i64 0
%36 = load float, float* %35
%37 = fpext float %36 to double
%38 = call double @llvm.fabs.f64(double %37)
%39 = fptrunc double %38 to float
%40 = load float*, float** %7
%41 = getelementptr inbounds float, float* %40, i64 0
store float %39, float* %41
br label %541
42: ; preds = %30
%43 = load i32, i32* %6
%44 = icmp eq i32 %43, 2
br i1 %44, label %45, label %65
45: ; preds = %42
%46 = load float*, float** %7
%47 = getelementptr inbounds float, float* %46, i64 0
%48 = load float, float* %47
%49 = fpext float %48 to double
%50 = load float*, float** %8
%51 = getelementptr inbounds float, float* %50, i64 0
%52 = load float, float* %51
%53 = fpext float %52 to double
%54 = load float*, float** %7
%55 = getelementptr inbounds float, float* %54, i64 1
%56 = load float, float* %55
%57 = fpext float %56 to double
%58 = call i32 (double, double, double, float*, float*, ...) bitcast (i32 (...)* @slas2 to i32 (double, double, double, float*, float*, ...)*)(double %49, double %53, double %57, float* @slasq1.sigmn, float* @slasq1.sigmx)
%59 = load float, float* @slasq1.sigmx
%60 = load float*, float** %7
%61 = getelementptr inbounds float, float* %60, i64 0
store float %59, float* %61
%62 = load float, float* @slasq1.sigmn
%63 = load float*, float** %7
%64 = getelementptr inbounds float, float* %63, i64 1
store float %62, float* %64
br label %541
65: ; preds = %42
br label %66
66: ; preds = %65
br label %67
67: ; preds = %66
br label %68
68: ; preds = %67
store float 0.000000e+00, float* @slasq1.sigmx
%69 = load i32, i32* %6
%70 = sub nsw i32 %69, 1
store i32 %70, i32* %11
store i32 1, i32* @slasq1.i
br label %71
71: ; preds = %97, %68
%72 = load i32, i32* @slasq1.i
%73 = load i32, i32* %6
%74 = sub nsw i32 %73, 1
%75 = icmp sle i32 %72, %74
br i1 %75, label %76, label %100
76: ; preds = %71
%77 = load float, float* @slasq1.sigmx
store float %77, float* %14
%78 = load float*, float** %8
%79 = load i32, i32* @slasq1.i
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %78, i64 %81
%83 = load float, float* %82
store float %83, float* %13
%84 = load float, float* %13
%85 = fpext float %84 to double
%86 = call double @llvm.fabs.f64(double %85)
%87 = fptrunc double %86 to float
store float %87, float* %15
%88 = load float, float* %14
%89 = load float, float* %15
%90 = fcmp ogt float %88, %89
br i1 %90, label %91, label %93
91: ; preds = %76
%92 = load float, float* %14
br label %95
93: ; preds = %76
%94 = load float, float* %15
br label %95
95: ; preds = %93, %91
%96 = phi float [ %92, %91 ], [ %94, %93 ]
store float %96, float* @slasq1.sigmx
br label %97
97: ; preds = %95
%98 = load i32, i32* @slasq1.i
%99 = add nsw i32 %98, 1
store i32 %99, i32* @slasq1.i
br label %71
100: ; preds = %71
%101 = load float, float* @slasq1.sigmx
%102 = fcmp oeq float %101, 0.000000e+00
br i1 %102, label %103, label %104
103: ; preds = %100
br label %535
104: ; preds = %100
%105 = load i32, i32* %6
store i32 %105, i32* %11
store i32 1, i32* @slasq1.i
br label %106
106: ; preds = %142, %104
%107 = load i32, i32* @slasq1.i
%108 = load i32, i32* %6
%109 = icmp sle i32 %107, %108
br i1 %109, label %110, label %145
110: ; preds = %106
%111 = load float*, float** %7
%112 = load i32, i32* @slasq1.i
%113 = sub nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %111, i64 %114
%116 = load float, float* %115
store float %116, float* %13
%117 = load float, float* %13
%118 = fpext float %117 to double
%119 = call double @llvm.fabs.f64(double %118)
%120 = fptrunc double %119 to float
%121 = load float*, float** %7
%122 = load i32, i32* @slasq1.i
%123 = sub nsw i32 %122, 1
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %121, i64 %124
store float %120, float* %125
%126 = load float, float* @slasq1.sigmx
store float %126, float* %13
%127 = load float*, float** %7
%128 = load i32, i32* @slasq1.i
%129 = sub nsw i32 %128, 1
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %127, i64 %130
%132 = load float, float* %131
store float %132, float* %14
%133 = load float, float* %13
%134 = load float, float* %14
%135 = fcmp ogt float %133, %134
br i1 %135, label %136, label %138
136: ; preds = %110
%137 = load float, float* %13
br label %140
138: ; preds = %110
%139 = load float, float* %14
br label %140
140: ; preds = %138, %136
%141 = phi float [ %137, %136 ], [ %139, %138 ]
store float %141, float* @slasq1.sigmx
br label %142
142: ; preds = %140
%143 = load i32, i32* @slasq1.i
%144 = add nsw i32 %143, 1
store i32 %144, i32* @slasq1.i
br label %106
145: ; preds = %106
%146 = call i32 (i8*, ...) bitcast (i32 (...)* @slamch to i32 (i8*, ...)*)(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%147 = sitofp i32 %146 to float
store float %147, float* @slasq1.eps
%148 = call i32 (i8*, ...) bitcast (i32 (...)* @slamch to i32 (i8*, ...)*)(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%149 = sitofp i32 %148 to float
store float %149, float* @slasq1.sfmin
%150 = load float, float* @slasq1.eps
%151 = fpext float %150 to double
store double %151, double* %17
store float 1.000000e+02, float* %15
%152 = load double, double* %17
%153 = load double, double* @slasq1.c_b8
%154 = call double @pow(double %152, double %153)
%155 = fptrunc double %154 to float
store float %155, float* %16
store float 1.000000e+01, float* %13
%156 = load float, float* %15
%157 = load float, float* %16
%158 = fcmp olt float %156, %157
br i1 %158, label %159, label %161
159: ; preds = %145
%160 = load float, float* %15
br label %163
161: ; preds = %145
%162 = load float, float* %16
br label %163
163: ; preds = %161, %159
%164 = phi float [ %160, %159 ], [ %162, %161 ]
store float %164, float* %14
%165 = load float, float* %13
%166 = load float, float* %14
%167 = fcmp ogt float %165, %166
br i1 %167, label %168, label %170
168: ; preds = %163
%169 = load float, float* %13
br label %172
170: ; preds = %163
%171 = load float, float* %14
br label %172
172: ; preds = %170, %168
%173 = phi float [ %169, %168 ], [ %171, %170 ]
store float %173, float* @slasq1.tolmul
%174 = load float, float* @slasq1.tolmul
%175 = load float, float* @slasq1.eps
%176 = fmul float %174, %175
store float %176, float* @slasq1.tol
%177 = load float, float* @slasq1.tol
store float %177, float* %13
%178 = load float, float* %13
%179 = load float, float* %13
%180 = fmul float %178, %179
store float %180, float* @slasq1.tol2
%181 = load float, float* @slasq1.sigmx
%182 = fpext float %181 to double
%183 = load float, float* @slasq1.sfmin
%184 = fpext float %183 to double
%185 = call double @sqrt(double %184)
%186 = fmul double %182, %185
%187 = load float, float* @slasq1.tol
%188 = fpext float %187 to double
%189 = fmul double %186, %188
%190 = fptrunc double %189 to float
store float %190, float* @slasq1.thresh
%191 = load float, float* @slasq1.sfmin
%192 = fmul float %191, 2.560000e+02
%193 = fdiv float 1.000000e+00, %192
%194 = fpext float %193 to double
%195 = call double @sqrt(double %194)
%196 = fptrunc double %195 to float
store float %196, float* @slasq1.scl
%197 = load float, float* @slasq1.tolmul
store float %197, float* %13
%198 = load float, float* %13
%199 = load float, float* %13
%200 = fmul float %198, %199
%201 = fmul float %200, 2.560000e+02
%202 = fdiv float 1.000000e+00, %201
store float %202, float* @slasq1.small2
%203 = load i32, i32* %6
%204 = load float*, float** %7
%205 = getelementptr inbounds float, float* %204, i64 0
%206 = load i32, i32* @slasq1.c__1
%207 = load float*, float** %9
%208 = getelementptr inbounds float, float* %207, i64 0
%209 = load i32, i32* @slasq1.c__1
%210 = call i32 (i32, float*, i32, float*, i32, ...) bitcast (i32 (...)* @scopy to i32 (i32, float*, i32, float*, i32, ...)*)(i32 %203, float* %205, i32 %206, float* %208, i32 %209)
%211 = load i32, i32* %6
%212 = sub nsw i32 %211, 1
store i32 %212, i32* %11
%213 = load i32, i32* %11
%214 = load float*, float** %8
%215 = getelementptr inbounds float, float* %214, i64 0
%216 = load i32, i32* @slasq1.c__1
%217 = load float*, float** %9
%218 = load i32, i32* %6
%219 = add nsw i32 %218, 1
%220 = sub nsw i32 %219, 1
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %217, i64 %221
%223 = load i32, i32* @slasq1.c__1
%224 = call i32 (i32, float*, i32, float*, i32, ...) bitcast (i32 (...)* @scopy to i32 (i32, float*, i32, float*, i32, ...)*)(i32 %213, float* %215, i32 %216, float* %222, i32 %223)
%225 = load i32, i32* @slasq1.c__0
%226 = load i32, i32* @slasq1.c__0
%227 = load float, float* @slasq1.sigmx
%228 = fpext float %227 to double
%229 = load float, float* @slasq1.scl
%230 = fpext float %229 to double
%231 = load i32, i32* %6
%232 = load i32, i32* @slasq1.c__1
%233 = load float*, float** %9
%234 = getelementptr inbounds float, float* %233, i64 0
%235 = load i32, i32* %6
%236 = call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %225, i32 %226, double %228, double %230, i32 %231, i32 %232, float* %234, i32 %235, i32* @slasq1.ierr)
%237 = load i32, i32* %6
%238 = sub nsw i32 %237, 1
store i32 %238, i32* %11
%239 = load i32, i32* %6
%240 = sub nsw i32 %239, 1
store i32 %240, i32* %12
%241 = load i32, i32* @slasq1.c__0
%242 = load i32, i32* @slasq1.c__0
%243 = load float, float* @slasq1.sigmx
%244 = fpext float %243 to double
%245 = load float, float* @slasq1.scl
%246 = fpext float %245 to double
%247 = load i32, i32* %11
%248 = load i32, i32* @slasq1.c__1
%249 = load float*, float** %9
%250 = load i32, i32* %6
%251 = add nsw i32 %250, 1
%252 = sub nsw i32 %251, 1
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds float, float* %249, i64 %253
%255 = load i32, i32* %12
%256 = call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %241, i32 %242, double %244, double %246, i32 %247, i32 %248, float* %254, i32 %255, i32* @slasq1.ierr)
%257 = load i32, i32* %6
%258 = shl i32 %257, 1
%259 = sub nsw i32 %258, 1
store i32 %259, i32* %11
store i32 1, i32* @slasq1.j
br label %260
260: ; preds = %281, %172
%261 = load i32, i32* @slasq1.j
%262 = load i32, i32* %6
%263 = shl i32 %262, 1
%264 = sub nsw i32 %263, 1
%265 = icmp sle i32 %261, %264
br i1 %265, label %266, label %284
266: ; preds = %260
%267 = load float*, float** %9
%268 = load i32, i32* @slasq1.j
%269 = sub nsw i32 %268, 1
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float, float* %267, i64 %270
%272 = load float, float* %271
store float %272, float* %13
%273 = load float, float* %13
%274 = load float, float* %13
%275 = fmul float %273, %274
%276 = load float*, float** %9
%277 = load i32, i32* @slasq1.j
%278 = sub nsw i32 %277, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %276, i64 %279
store float %275, float* %280
br label %281
281: ; preds = %266
%282 = load i32, i32* @slasq1.j
%283 = add nsw i32 %282, 1
store i32 %283, i32* @slasq1.j
br label %260
284: ; preds = %260
store i32 0, i32* @slasq1.m
%285 = load float*, float** %8
%286 = load i32, i32* %6
%287 = sub nsw i32 %286, 1
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %285, i64 %288
store float 0.000000e+00, float* %289
%290 = load float*, float** %9
%291 = getelementptr inbounds float, float* %290, i64 0
%292 = load float, float* %291
store float %292, float* @slasq1.dx
%293 = load float, float* @slasq1.dx
store float %293, float* @slasq1.dm
store i32 0, i32* @slasq1.ke
store i32 0, i32* @slasq1.restrt
%294 = load i32, i32* %6
store i32 %294, i32* %11
store i32 1, i32* @slasq1.i
br label %295
295: ; preds = %529, %284
%296 = load i32, i32* @slasq1.i
%297 = load i32, i32* %6
%298 = icmp sle i32 %296, %297
br i1 %298, label %299, label %532
299: ; preds = %295
%300 = load float*, float** %8
%301 = load i32, i32* @slasq1.i
%302 = sub nsw i32 %301, 1
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds float, float* %300, i64 %303
%305 = load float, float* %304
store float %305, float* %13
%306 = load float, float* %13
%307 = fpext float %306 to double
%308 = call double @llvm.fabs.f64(double %307)
%309 = load float, float* @slasq1.thresh
%310 = fpext float %309 to double
%311 = fcmp ole double %308, %310
br i1 %311, label %330, label %312
312: ; preds = %299
%313 = load float*, float** %9
%314 = load i32, i32* %6
%315 = load i32, i32* @slasq1.i
%316 = add nsw i32 %314, %315
%317 = sub nsw i32 %316, 1
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %313, i64 %318
%320 = load float, float* %319
%321 = load float, float* @slasq1.tol2
%322 = load float, float* @slasq1.dm
%323 = load i32, i32* @slasq1.i
%324 = load i32, i32* @slasq1.m
%325 = sub nsw i32 %323, %324
%326 = sitofp i32 %325 to float
%327 = fdiv float %322, %326
%328 = fmul float %321, %327
%329 = fcmp ole float %320, %328
br i1 %329, label %330, label %493
330: ; preds = %312, %299
%331 = load i32, i32* @slasq1.i
%332 = load i32, i32* @slasq1.m
%333 = sub nsw i32 %331, %332
store i32 %333, i32* @slasq1.ny
%334 = load i32, i32* @slasq1.ny
%335 = icmp eq i32 %334, 1
br i1 %335, label %336, label %337
336: ; preds = %330
br label %477
337: ; preds = %330
%338 = load i32, i32* @slasq1.ny
%339 = icmp eq i32 %338, 2
br i1 %339, label %340, label %380
340: ; preds = %337
%341 = load float*, float** %7
%342 = load i32, i32* @slasq1.m
%343 = add nsw i32 %342, 1
%344 = sub nsw i32 %343, 1
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %341, i64 %345
%347 = load float, float* %346
%348 = fpext float %347 to double
%349 = load float*, float** %8
%350 = load i32, i32* @slasq1.m
%351 = add nsw i32 %350, 1
%352 = sub nsw i32 %351, 1
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %349, i64 %353
%355 = load float, float* %354
%356 = fpext float %355 to double
%357 = load float*, float** %7
%358 = load i32, i32* @slasq1.m
%359 = add nsw i32 %358, 2
%360 = sub nsw i32 %359, 1
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %357, i64 %361
%363 = load float, float* %362
%364 = fpext float %363 to double
%365 = call i32 (double, double, double, float*, float*, ...) bitcast (i32 (...)* @slas2 to i32 (double, double, double, float*, float*, ...)*)(double %348, double %356, double %364, float* @slasq1.sig1, float* @slasq1.sig2)
%366 = load float, float* @slasq1.sig1
%367 = load float*, float** %7
%368 = load i32, i32* @slasq1.m
%369 = add nsw i32 %368, 1
%370 = sub nsw i32 %369, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds float, float* %367, i64 %371
store float %366, float* %372
%373 = load float, float* @slasq1.sig2
%374 = load float*, float** %7
%375 = load i32, i32* @slasq1.m
%376 = add nsw i32 %375, 2
%377 = sub nsw i32 %376, 1
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds float, float* %374, i64 %378
store float %373, float* %379
br label %475
380: ; preds = %337
%381 = load i32, i32* @slasq1.ke
%382 = add nsw i32 %381, 1
%383 = load i32, i32* @slasq1.m
%384 = sub nsw i32 %382, %383
store i32 %384, i32* @slasq1.kend
%385 = load i32, i32* @slasq1.ny
%386 = load float*, float** %7
%387 = load i32, i32* @slasq1.m
%388 = add nsw i32 %387, 1
%389 = sub nsw i32 %388, 1
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds float, float* %386, i64 %390
%392 = load float*, float** %8
%393 = load i32, i32* @slasq1.m
%394 = add nsw i32 %393, 1
%395 = sub nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds float, float* %392, i64 %396
%398 = load float*, float** %9
%399 = load i32, i32* @slasq1.m
%400 = add nsw i32 %399, 1
%401 = sub nsw i32 %400, 1
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds float, float* %398, i64 %402
%404 = load float*, float** %9
%405 = load i32, i32* @slasq1.m
%406 = load i32, i32* %6
%407 = add nsw i32 %405, %406
%408 = add nsw i32 %407, 1
%409 = sub nsw i32 %408, 1
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %404, i64 %410
%412 = load float, float* @slasq1.eps
%413 = fpext float %412 to double
%414 = load float, float* @slasq1.tol2
%415 = fpext float %414 to double
%416 = load float, float* @slasq1.small2
%417 = fpext float %416 to double
%418 = load i32*, i32** %10
%419 = call i32 (i32, float*, float*, float*, float*, double, double, double, float*, i32*, i32*, ...) bitcast (i32 (...)* @slasq2 to i32 (i32, float*, float*, float*, float*, double, double, double, float*, i32*, i32*, ...)*)(i32 %385, float* %391, float* %397, float* %403, float* %411, double %413, double %415, double %417, float* @slasq1.dm, i32* @slasq1.kend, i32* %418)
%420 = load i32*, i32** %10
%421 = load i32, i32* %420
%422 = icmp ne i32 %421, 0
br i1 %422, label %423, label %428
423: ; preds = %380
%424 = load i32, i32* @slasq1.i
%425 = load i32*, i32** %10
%426 = load i32, i32* %425
%427 = add nsw i32 %426, %424
store i32 %427, i32* %425
br label %541
428: ; preds = %380
%429 = load i32, i32* @slasq1.m
%430 = load i32, i32* @slasq1.ny
%431 = add nsw i32 %429, %430
store i32 %431, i32* %12
%432 = load i32, i32* @slasq1.m
%433 = add nsw i32 %432, 1
store i32 %433, i32* @slasq1.j
br label %434
434: ; preds = %455, %428
%435 = load i32, i32* @slasq1.j
%436 = load i32, i32* @slasq1.m
%437 = load i32, i32* @slasq1.ny
%438 = add nsw i32 %436, %437
%439 = icmp sle i32 %435, %438
br i1 %439, label %440, label %458
440: ; preds = %434
%441 = load float*, float** %7
%442 = load i32, i32* @slasq1.j
%443 = sub nsw i32 %442, 1
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float, float* %441, i64 %444
%446 = load float, float* %445
%447 = fpext float %446 to double
%448 = call double @sqrt(double %447)
%449 = fptrunc double %448 to float
%450 = load float*, float** %7
%451 = load i32, i32* @slasq1.j
%452 = sub nsw i32 %451, 1
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds float, float* %450, i64 %453
store float %449, float* %454
br label %455
455: ; preds = %440
%456 = load i32, i32* @slasq1.j
%457 = add nsw i32 %456, 1
store i32 %457, i32* @slasq1.j
br label %434
458: ; preds = %434
%459 = load i32, i32* @slasq1.c__0
%460 = load i32, i32* @slasq1.c__0
%461 = load float, float* @slasq1.scl
%462 = fpext float %461 to double
%463 = load float, float* @slasq1.sigmx
%464 = fpext float %463 to double
%465 = load i32, i32* @slasq1.ny
%466 = load i32, i32* @slasq1.c__1
%467 = load float*, float** %7
%468 = load i32, i32* @slasq1.m
%469 = add nsw i32 %468, 1
%470 = sub nsw i32 %469, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float, float* %467, i64 %471
%473 = load i32, i32* @slasq1.ny
%474 = call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %459, i32 %460, double %462, double %464, i32 %465, i32 %466, float* %472, i32 %473, i32* @slasq1.ierr)
br label %475
475: ; preds = %458, %340
br label %476
476: ; preds = %475
br label %477
477: ; preds = %476, %336
%478 = load i32, i32* @slasq1.i
store i32 %478, i32* @slasq1.m
%479 = load i32, i32* @slasq1.i
%480 = load i32, i32* %6
%481 = icmp ne i32 %479, %480
br i1 %481, label %482, label %492
482: ; preds = %477
%483 = load float*, float** %9
%484 = load i32, i32* @slasq1.i
%485 = add nsw i32 %484, 1
%486 = sub nsw i32 %485, 1
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %483, i64 %487
%489 = load float, float* %488
store float %489, float* @slasq1.dx
%490 = load float, float* @slasq1.dx
store float %490, float* @slasq1.dm
%491 = load i32, i32* @slasq1.i
store i32 %491, i32* @slasq1.ke
store i32 1, i32* @slasq1.restrt
br label %492
492: ; preds = %482, %477
br label %493
493: ; preds = %492, %312
%494 = load i32, i32* @slasq1.i
%495 = load i32, i32* %6
%496 = icmp ne i32 %494, %495
br i1 %496, label %497, label %528
497: ; preds = %493
%498 = load i32, i32* @slasq1.restrt
%499 = icmp ne i32 %498, 0
br i1 %499, label %528, label %500
500: ; preds = %497
%501 = load float*, float** %9
%502 = load i32, i32* @slasq1.i
%503 = add nsw i32 %502, 1
%504 = sub nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds float, float* %501, i64 %505
%507 = load float, float* %506
%508 = load float, float* @slasq1.dx
%509 = load float, float* @slasq1.dx
%510 = load float*, float** %9
%511 = load i32, i32* %6
%512 = load i32, i32* @slasq1.i
%513 = add nsw i32 %511, %512
%514 = sub nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float, float* %510, i64 %515
%517 = load float, float* %516
%518 = fadd float %509, %517
%519 = fdiv float %508, %518
%520 = fmul float %507, %519
store float %520, float* @slasq1.dx
%521 = load float, float* @slasq1.dm
%522 = load float, float* @slasq1.dx
%523 = fcmp ogt float %521, %522
br i1 %523, label %524, label %527
524: ; preds = %500
%525 = load float, float* @slasq1.dx
store float %525, float* @slasq1.dm
%526 = load i32, i32* @slasq1.i
store i32 %526, i32* @slasq1.ke
br label %527
527: ; preds = %524, %500
br label %528
528: ; preds = %527, %497, %493
store i32 0, i32* @slasq1.restrt
br label %529
529: ; preds = %528
%530 = load i32, i32* @slasq1.i
%531 = add nsw i32 %530, 1
store i32 %531, i32* @slasq1.i
br label %295
532: ; preds = %295
%533 = load i32, i32* @slasq1.ke
%534 = add nsw i32 %533, 1
store i32 %534, i32* @slasq1.kend
br label %535
535: ; preds = %532, %103
%536 = load i32, i32* %6
%537 = load float*, float** %7
%538 = getelementptr inbounds float, float* %537, i64 0
%539 = load i32*, i32** %10
%540 = call i32 (i8*, i32, float*, i32*, ...) bitcast (i32 (...)* @slasrt to i32 (i8*, i32, float*, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32 %536, float* %538, i32* %539)
br label %541
541: ; preds = %535, %423, %45, %33, %29, %21
ret void
}

LLVM IR (-O2):
@slasq1.kend = internal global i32 0
@slasq1.ierr = internal global i32 0
@slasq1.i = internal unnamed_addr global i32 0
@slasq1.j = internal unnamed_addr global i32 0
@slasq1.m = internal unnamed_addr global i32 0
@slasq1.sfmin = internal unnamed_addr global float 0.000000e+00
@slasq1.sigmn = internal global float 0.000000e+00
@slasq1.sigmx = internal global float 0.000000e+00
@slasq1.small2 = internal unnamed_addr global float 0.000000e+00
@slasq1.ke = internal unnamed_addr global i32 0
@slasq1.dm = internal global float 0.000000e+00
@slasq1.dx = internal unnamed_addr global float 0.000000e+00
@slasq1.ny = internal unnamed_addr global i32 0
@slasq1.thresh = internal unnamed_addr global float 0.000000e+00
@slasq1.tolmul = internal unnamed_addr global float 0.000000e+00
@slasq1.scl = internal unnamed_addr global float 0.000000e+00
@slasq1.eps = internal unnamed_addr global float 0.000000e+00
@slasq1.tol = internal unnamed_addr global float 0.000000e+00
@slasq1.sig1 = internal global float 0.000000e+00
@slasq1.sig2 = internal global float 0.000000e+00
@slasq1.tol2 = internal unnamed_addr global float 0.000000e+00
@.str = [8 x i8] c"EPSILON\00"
@.str.1 = [13 x i8] c"SAFE MINIMUM\00"
@.str.2 = [2 x i8] c"G\00"
@.str.3 = [2 x i8] c"D\00"
define void @slasq1(i32 %0, float* %1, float* %2, float* %3, i32* %4) {
store i32 0, i32* %4
%6 = icmp slt i32 %0, 0
br i1 %6, label %7, label %8
7: ; preds = %5
store i32 -2, i32* %4
br label %362
8: ; preds = %5
switch i32 %0, label %23 [
i32 0, label %362
i32 1, label %9
i32 2, label %12
]
9: ; preds = %8
%10 = load float, float* %1
%11 = tail call float @llvm.fabs.f32(float %10)
store float %11, float* %1
br label %362
12: ; preds = %8
%13 = load float, float* %1
%14 = fpext float %13 to double
%15 = load float, float* %2
%16 = fpext float %15 to double
%17 = getelementptr inbounds float, float* %1, i64 1
%18 = load float, float* %17
%19 = fpext float %18 to double
%20 = tail call i32 (double, double, double, float*, float*, ...) bitcast (i32 (...)* @slas2 to i32 (double, double, double, float*, float*, ...)*)(double %14, double %16, double %19, float* @slasq1.sigmn, float* @slasq1.sigmx)
%21 = load float, float* @slasq1.sigmx
store float %21, float* %1
%22 = load float, float* @slasq1.sigmn
store float %22, float* %17
br label %362
23: ; preds = %8
store float 0.000000e+00, float* @slasq1.sigmx
%24 = zext i32 %0 to i64
%25 = add nsw i64 %24, -1
%26 = and i64 %25, 1
%27 = and i64 %25, -2
br label %28
28: ; preds = %28, %23
%29 = phi float [ 0.000000e+00, %23 ], [ %42, %28 ]
%30 = phi i64 [ 1, %23 ], [ %43, %28 ]
%31 = phi i64 [ 0, %23 ], [ %44, %28 ]
%32 = add nsw i64 %30, -1
%33 = getelementptr inbounds float, float* %2, i64 %32
%34 = load float, float* %33
%35 = tail call float @llvm.fabs.f32(float %34)
%36 = fcmp ogt float %29, %35
%37 = select i1 %36, float %29, float %35
store float %37, float* @slasq1.sigmx
%38 = getelementptr inbounds float, float* %2, i64 %30
%39 = load float, float* %38
%40 = tail call float @llvm.fabs.f32(float %39)
%41 = fcmp ogt float %37, %40
%42 = select i1 %41, float %37, float %40
store float %42, float* @slasq1.sigmx
%43 = add nuw nsw i64 %30, 2
%44 = add i64 %31, 2
%45 = icmp eq i64 %44, %27
br i1 %45, label %46, label %28
46: ; preds = %28
%47 = icmp eq i64 %26, 0
br i1 %47, label %55, label %48
48: ; preds = %46
%49 = add nsw i64 %43, -1
%50 = getelementptr inbounds float, float* %2, i64 %49
%51 = load float, float* %50
%52 = tail call float @llvm.fabs.f32(float %51)
%53 = fcmp ogt float %42, %52
%54 = select i1 %53, float %42, float %52
store float %54, float* @slasq1.sigmx
br label %55
55: ; preds = %46, %48
%56 = phi float [ %42, %46 ], [ %54, %48 ]
%57 = fcmp oeq float %56, 0.000000e+00
store i32 %0, i32* @slasq1.i
%58 = add i32 %0, -1
br i1 %57, label %360, label %59
59: ; preds = %55
%60 = icmp slt i32 %0, 1
br i1 %60, label %99, label %61
61: ; preds = %59
%62 = add nuw i32 %0, 1
%63 = zext i32 %0 to i64
%64 = and i64 %63, 1
%65 = icmp eq i32 %62, 2
br i1 %65, label %89, label %66
66: ; preds = %61
%67 = and i64 %63, 4294967294
br label %68
68: ; preds = %68, %66
%69 = phi i64 [ 1, %66 ], [ %84, %68 ]
%70 = phi i64 [ 0, %66 ], [ %85, %68 ]
%71 = add nsw i64 %69, -1
%72 = getelementptr inbounds float, float* %1, i64 %71
%73 = load float, float* %72
%74 = tail call float @llvm.fabs.f32(float %73)
store float %74, float* %72
%75 = load float, float* @slasq1.sigmx
%76 = fcmp ogt float %75, %74
%77 = select i1 %76, float %75, float %74
store float %77, float* @slasq1.sigmx
%78 = getelementptr inbounds float, float* %1, i64 %69
%79 = load float, float* %78
%80 = tail call float @llvm.fabs.f32(float %79)
store float %80, float* %78
%81 = load float, float* @slasq1.sigmx
%82 = fcmp ogt float %81, %80
%83 = select i1 %82, float %81, float %80
store float %83, float* @slasq1.sigmx
%84 = add nuw nsw i64 %69, 2
%85 = add i64 %70, 2
%86 = icmp eq i64 %85, %67
br i1 %86, label %87, label %68
87: ; preds = %68
%88 = add nuw i64 %69, 1
br label %89
89: ; preds = %87, %61
%90 = phi i64 [ 0, %61 ], [ %88, %87 ]
%91 = icmp eq i64 %64, 0
br i1 %91, label %99, label %92
92: ; preds = %89
%93 = getelementptr inbounds float, float* %1, i64 %90
%94 = load float, float* %93
%95 = tail call float @llvm.fabs.f32(float %94)
store float %95, float* %93
%96 = load float, float* @slasq1.sigmx
%97 = fcmp ogt float %96, %95
%98 = select i1 %97, float %96, float %95
store float %98, float* @slasq1.sigmx
br label %99
99: ; preds = %92, %89, %59
%100 = phi i32 [ 1, %59 ], [ %62, %89 ], [ %62, %92 ]
store i32 %100, i32* @slasq1.i
%101 = tail call i32 (i8*, ...) bitcast (i32 (...)* @slamch to i32 (i8*, ...)*)(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%102 = sitofp i32 %101 to float
store float %102, float* @slasq1.eps
%103 = tail call i32 (i8*, ...) bitcast (i32 (...)* @slamch to i32 (i8*, ...)*)(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%104 = sitofp i32 %103 to float
store float %104, float* @slasq1.sfmin
%105 = load float, float* @slasq1.eps
%106 = fpext float %105 to double
%107 = tail call double @pow(double %106, double 1.250000e-01)
%108 = fptrunc double %107 to float
%109 = fcmp ogt float %108, 1.000000e+02
%110 = select i1 %109, float 1.000000e+02, float %108
%111 = fcmp olt float %110, 1.000000e+01
%112 = select i1 %111, float 1.000000e+01, float %110
store float %112, float* @slasq1.tolmul
%113 = load float, float* @slasq1.eps
%114 = fmul float %113, %112
store float %114, float* @slasq1.tol
%115 = fmul float %114, %114
store float %115, float* @slasq1.tol2
%116 = load float, float* @slasq1.sigmx
%117 = fpext float %116 to double
%118 = load float, float* @slasq1.sfmin
%119 = fpext float %118 to double
%120 = tail call double @sqrt(double %119)
%121 = fmul double %120, %117
%122 = load float, float* @slasq1.tol
%123 = fpext float %122 to double
%124 = fmul double %121, %123
%125 = fptrunc double %124 to float
store float %125, float* @slasq1.thresh
%126 = load float, float* @slasq1.sfmin
%127 = fmul float %126, 2.560000e+02
%128 = fdiv float 1.000000e+00, %127
%129 = tail call float @sqrtf(float %128)
store float %129, float* @slasq1.scl
%130 = load float, float* @slasq1.tolmul
%131 = fmul float %130, %130
%132 = fmul float %131, 2.560000e+02
%133 = fdiv float 1.000000e+00, %132
store float %133, float* @slasq1.small2
%134 = tail call i32 (i32, float*, i32, float*, i32, ...) bitcast (i32 (...)* @scopy to i32 (i32, float*, i32, float*, i32, ...)*)(i32 %0, float* %1, i32 1, float* %3, i32 1)
%135 = sext i32 %0 to i64
%136 = getelementptr inbounds float, float* %3, i64 %135
%137 = tail call i32 (i32, float*, i32, float*, i32, ...) bitcast (i32 (...)* @scopy to i32 (i32, float*, i32, float*, i32, ...)*)(i32 %58, float* %2, i32 1, float* %136, i32 1)
%138 = load float, float* @slasq1.sigmx
%139 = fpext float %138 to double
%140 = load float, float* @slasq1.scl
%141 = fpext float %140 to double
%142 = tail call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 0, i32 0, double %139, double %141, i32 %0, i32 1, float* %3, i32 %0, i32* @slasq1.ierr)
%143 = load float, float* @slasq1.sigmx
%144 = fpext float %143 to double
%145 = load float, float* @slasq1.scl
%146 = fpext float %145 to double
%147 = tail call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 0, i32 0, double %144, double %146, i32 %58, i32 1, float* %136, i32 %58, i32* @slasq1.ierr)
%148 = shl i32 %0, 1
%149 = icmp sgt i32 %148, 1
br i1 %149, label %150, label %215
150: ; preds = %99
%151 = zext i32 %148 to i64
%152 = add nsw i64 %151, -1
%153 = icmp ult i64 %152, 8
br i1 %153, label %205, label %154
154: ; preds = %150
%155 = and i64 %152, -8
%156 = or i64 %155, 1
%157 = add nsw i64 %155, -8
%158 = lshr exact i64 %157, 3
%159 = add nuw nsw i64 %158, 1
%160 = and i64 %159, 1
%161 = icmp eq i64 %157, 0
br i1 %161, label %191, label %162
162: ; preds = %154
%163 = and i64 %159, 4611686018427387902
br label %164
164: ; preds = %164, %162
%165 = phi i64 [ 0, %162 ], [ %188, %164 ]
%166 = phi i64 [ 0, %162 ], [ %189, %164 ]
%167 = getelementptr inbounds float, float* %3, i64 %165
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = getelementptr inbounds float, float* %167, i64 4
%171 = bitcast float* %170 to <4 x float>*
%172 = load <4 x float>, <4 x float>* %171
%173 = fmul <4 x float> %169, %169
%174 = fmul <4 x float> %172, %172
%175 = bitcast float* %167 to <4 x float>*
store <4 x float> %173, <4 x float>* %175
%176 = bitcast float* %170 to <4 x float>*
store <4 x float> %174, <4 x float>* %176
%177 = or i64 %165, 8
%178 = getelementptr inbounds float, float* %3, i64 %177
%179 = bitcast float* %178 to <4 x float>*
%180 = load <4 x float>, <4 x float>* %179
%181 = getelementptr inbounds float, float* %178, i64 4
%182 = bitcast float* %181 to <4 x float>*
%183 = load <4 x float>, <4 x float>* %182
%184 = fmul <4 x float> %180, %180
%185 = fmul <4 x float> %183, %183
%186 = bitcast float* %178 to <4 x float>*
store <4 x float> %184, <4 x float>* %186
%187 = bitcast float* %181 to <4 x float>*
store <4 x float> %185, <4 x float>* %187
%188 = add nuw i64 %165, 16
%189 = add i64 %166, 2
%190 = icmp eq i64 %189, %163
br i1 %190, label %191, label %164
191: ; preds = %164, %154
%192 = phi i64 [ 0, %154 ], [ %188, %164 ]
%193 = icmp eq i64 %160, 0
br i1 %193, label %205, label %194
194: ; preds = %191
%195 = getelementptr inbounds float, float* %3, i64 %192
%196 = bitcast float* %195 to <4 x float>*
%197 = load <4 x float>, <4 x float>* %196
%198 = getelementptr inbounds float, float* %195, i64 4
%199 = bitcast float* %198 to <4 x float>*
%200 = load <4 x float>, <4 x float>* %199
%201 = fmul <4 x float> %197, %197
%202 = fmul <4 x float> %200, %200
%203 = bitcast float* %195 to <4 x float>*
store <4 x float> %201, <4 x float>* %203
%204 = bitcast float* %198 to <4 x float>*
store <4 x float> %202, <4 x float>* %204
br label %205
205: ; preds = %194, %191, %150
%206 = phi i64 [ 1, %150 ], [ %156, %191 ], [ %156, %194 ]
br label %207
207: ; preds = %205, %207
%208 = phi i64 [ %213, %207 ], [ %206, %205 ]
%209 = add nsw i64 %208, -1
%210 = getelementptr inbounds float, float* %3, i64 %209
%211 = load float, float* %210
%212 = fmul float %211, %211
store float %212, float* %210
%213 = add nuw nsw i64 %208, 1
%214 = icmp eq i64 %213, %151
br i1 %214, label %215, label %207
215: ; preds = %207, %99
%216 = phi i32 [ 1, %99 ], [ %148, %207 ]
store i32 %216, i32* @slasq1.j
store i32 0, i32* @slasq1.m
%217 = sext i32 %58 to i64
%218 = getelementptr inbounds float, float* %2, i64 %217
store float 0.000000e+00, float* %218
%219 = load float, float* %3
store float %219, float* @slasq1.dx
store float %219, float* @slasq1.dm
store i32 0, i32* @slasq1.ke
store i32 1, i32* @slasq1.i
br i1 %60, label %358, label %220
220: ; preds = %215, %350
%221 = phi i32 [ %351, %350 ], [ 0, %215 ]
%222 = phi i32 [ %353, %350 ], [ 1, %215 ]
%223 = add nsw i32 %222, -1
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %2, i64 %224
%226 = load float, float* %225
%227 = tail call float @llvm.fabs.f32(float %226)
%228 = load float, float* @slasq1.thresh
%229 = fcmp ugt float %227, %228
br i1 %229, label %232, label %230
230: ; preds = %220
%231 = sub nsw i32 %222, %221
br label %244
232: ; preds = %220
%233 = add i32 %58, %222
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %3, i64 %234
%236 = load float, float* %235
%237 = load float, float* @slasq1.tol2
%238 = load float, float* @slasq1.dm
%239 = sub nsw i32 %222, %221
%240 = sitofp i32 %239 to float
%241 = fdiv float %238, %240
%242 = fmul float %237, %241
%243 = fcmp ugt float %236, %242
br i1 %243, label %330, label %244
244: ; preds = %230, %232
%245 = phi i32 [ %231, %230 ], [ %239, %232 ]
store i32 %245, i32* @slasq1.ny
switch i32 %245, label %268 [
i32 1, label %321
i32 2, label %246
]
246: ; preds = %244
%247 = sext i32 %221 to i64
%248 = getelementptr inbounds float, float* %1, i64 %247
%249 = load float, float* %248
%250 = fpext float %249 to double
%251 = getelementptr inbounds float, float* %2, i64 %247
%252 = load float, float* %251
%253 = fpext float %252 to double
%254 = add nsw i32 %221, 1
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %1, i64 %255
%257 = load float, float* %256
%258 = fpext float %257 to double
%259 = tail call i32 (double, double, double, float*, float*, ...) bitcast (i32 (...)* @slas2 to i32 (double, double, double, float*, float*, ...)*)(double %250, double %253, double %258, float* @slasq1.sig1, float* @slasq1.sig2)
%260 = load float, float* @slasq1.sig1
%261 = load i32, i32* @slasq1.m
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds float, float* %1, i64 %262
store float %260, float* %263
%264 = load float, float* @slasq1.sig2
%265 = add nsw i32 %261, 1
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds float, float* %1, i64 %266
store float %264, float* %267
br label %321
268: ; preds = %244
%269 = load i32, i32* @slasq1.ke
%270 = sub i32 1, %221
%271 = add i32 %270, %269
store i32 %271, i32* @slasq1.kend
%272 = sext i32 %221 to i64
%273 = getelementptr inbounds float, float* %1, i64 %272
%274 = getelementptr inbounds float, float* %2, i64 %272
%275 = getelementptr inbounds float, float* %3, i64 %272
%276 = add nsw i32 %221, %0
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds float, float* %3, i64 %277
%279 = load float, float* @slasq1.eps
%280 = fpext float %279 to double
%281 = load float, float* @slasq1.tol2
%282 = fpext float %281 to double
%283 = load float, float* @slasq1.small2
%284 = fpext float %283 to double
%285 = tail call i32 (i32, float*, float*, float*, float*, double, double, double, float*, i32*, i32*, ...) bitcast (i32 (...)* @slasq2 to i32 (i32, float*, float*, float*, float*, double, double, double, float*, i32*, i32*, ...)*)(i32 %245, float* %273, float* %274, float* %275, float* %278, double %280, double %282, double %284, float* @slasq1.dm, i32* @slasq1.kend, i32* %4)
%286 = load i32, i32* %4
%287 = icmp eq i32 %286, 0
br i1 %287, label %288, label %293
288: ; preds = %268
%289 = load i32, i32* @slasq1.m
%290 = add nsw i32 %289, 1
store i32 %290, i32* @slasq1.j
%291 = load i32, i32* @slasq1.ny
%292 = icmp sgt i32 %291, 0
br i1 %292, label %296, label %311
293: ; preds = %268
%294 = load i32, i32* @slasq1.i
%295 = add nsw i32 %294, %286
store i32 %295, i32* %4
br label %362
296: ; preds = %288, %296
%297 = phi i32 [ %302, %296 ], [ %289, %288 ]
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %1, i64 %298
%300 = load float, float* %299
%301 = tail call float @sqrtf(float %300)
%302 = load i32, i32* @slasq1.j
%303 = add nsw i32 %302, -1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %1, i64 %304
store float %301, float* %305
%306 = add nsw i32 %302, 1
store i32 %306, i32* @slasq1.j
%307 = load i32, i32* @slasq1.m
%308 = load i32, i32* @slasq1.ny
%309 = add nsw i32 %308, %307
%310 = icmp slt i32 %302, %309
br i1 %310, label %296, label %311
311: ; preds = %296, %288
%312 = phi i32 [ %289, %288 ], [ %307, %296 ]
%313 = phi i32 [ %291, %288 ], [ %308, %296 ]
%314 = load float, float* @slasq1.scl
%315 = fpext float %314 to double
%316 = load float, float* @slasq1.sigmx
%317 = fpext float %316 to double
%318 = sext i32 %312 to i64
%319 = getelementptr inbounds float, float* %1, i64 %318
%320 = tail call i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...) bitcast (i32 (...)* @slascl to i32 (i8*, i32, i32, double, double, i32, i32, float*, i32, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 0, i32 0, double %315, double %317, i32 %313, i32 1, float* %319, i32 %313, i32* @slasq1.ierr)
br label %321
321: ; preds = %244, %311, %246
%322 = load i32, i32* @slasq1.i
store i32 %322, i32* @slasq1.m
%323 = icmp eq i32 %322, %0
br i1 %323, label %324, label %326
324: ; preds = %321
%325 = add nsw i32 %0, 1
store i32 %325, i32* @slasq1.i
br label %355
326: ; preds = %321
%327 = sext i32 %322 to i64
%328 = getelementptr inbounds float, float* %3, i64 %327
%329 = load float, float* %328
store float %329, float* @slasq1.dx
br label %346
330: ; preds = %232
%331 = icmp eq i32 %222, %0
br i1 %331, label %350, label %332
332: ; preds = %330
%333 = sext i32 %222 to i64
%334 = getelementptr inbounds float, float* %3, i64 %333
%335 = load float, float* %334
%336 = load float, float* @slasq1.dx
%337 = add i32 %58, %222
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds float, float* %3, i64 %338
%340 = load float, float* %339
%341 = fadd float %336, %340
%342 = fdiv float %336, %341
%343 = fmul float %335, %342
store float %343, float* @slasq1.dx
%344 = load float, float* @slasq1.dm
%345 = fcmp ogt float %344, %343
br i1 %345, label %346, label %350
346: ; preds = %332, %326
%347 = phi float [ %329, %326 ], [ %343, %332 ]
%348 = phi i32 [ %322, %326 ], [ %222, %332 ]
%349 = phi i32 [ %322, %326 ], [ %221, %332 ]
store float %347, float* @slasq1.dm
store i32 %348, i32* @slasq1.ke
br label %350
350: ; preds = %346, %332, %330
%351 = phi i32 [ %221, %332 ], [ %221, %330 ], [ %349, %346 ]
%352 = phi i32 [ %222, %332 ], [ %222, %330 ], [ %348, %346 ]
%353 = add nsw i32 %352, 1
store i32 %353, i32* @slasq1.i
%354 = icmp slt i32 %352, %0
br i1 %354, label %220, label %355
355: ; preds = %350, %324
%356 = load i32, i32* @slasq1.ke
%357 = add i32 %356, 1
br label %358
358: ; preds = %355, %215
%359 = phi i32 [ %357, %355 ], [ 1, %215 ]
store i32 %359, i32* @slasq1.kend
br label %360
360: ; preds = %55, %358
%361 = tail call i32 (i8*, i32, float*, i32*, ...) bitcast (i32 (...)* @slasrt to i32 (i8*, i32, float*, i32*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32 %0, float* %1, i32* %4)
br label %362
362: ; preds = %8, %360, %293, %12, %9, %7
ret void
}