void slascl(char *type, int kl_, int ku_, float cfrom, float cto, int m__,
            int n__, float *a, int lda, int *info) {
  int i__1, i__2, i__3, i__4, i__5;
  static int done;
  static float ctoc;
  static int i, j;
  static int itype, k1, k2, k3, k4;
  static float cfrom1;
  static float cfromc;
  static float bignum, smlnum, mul, cto1;
  *info = 0;
  if ((toupper(*type) == toupper(*"G"))) {
    itype = 0;
  } else if ((toupper(*type) == toupper(*"L"))) {
    itype = 1;
  } else if ((toupper(*type) == toupper(*"U"))) {
    itype = 2;
  } else if ((toupper(*type) == toupper(*"H"))) {
    itype = 3;
  } else if ((toupper(*type) == toupper(*"B"))) {
    itype = 4;
  } else if ((toupper(*type) == toupper(*"Q"))) {
    itype = 5;
  } else if ((toupper(*type) == toupper(*"Z"))) {
    itype = 6;
  } else {
    itype = -1;
  }
  if (itype == -1) {
    *info = -1;
  } else if (cfrom == 0.f) {
    *info = -4;
  } else if (m__ < 0) {
    *info = -6;
  } else if (n__ < 0 || (itype == 4 && n__ != m__) ||
             (itype == 5 && n__ != m__)) {
    *info = -7;
  } else if (itype <= 3 && lda < (((1) > (m__)) ? (1) : (m__))) {
    *info = -9;
  } else if (itype >= 4) {
    i__1 = m__ - 1;
    if (kl_ < 0 || kl_ > (((i__1) > (0)) ? (i__1) : (0))) {
      *info = -2;
    } else {
      i__1 = n__ - 1;
      if (ku_ < 0 || ku_ > (((i__1) > (0)) ? (i__1) : (0)) ||
          ((itype == 4 || itype == 5) && kl_ != ku_)) {
        *info = -3;
      } else if ((itype == 4 && lda < kl_ + 1) ||
                 (itype == 5 && lda < ku_ + 1) ||
                 (itype == 6 && lda < (kl_ << 1) + ku_ + 1)) {
        *info = -9;
      }
    }
  }
  if (*info != 0) {
    i__1 = -(*info);
    return;
  }
  if (n__ == 0 || m__ == 0) {
    return;
  }
  smlnum = slamch("S");
  bignum = 1.f / smlnum;
  cfromc = cfrom;
  ctoc = cto;
L10:
  cfrom1 = cfromc * smlnum;
  cto1 = ctoc / bignum;
  if (fabs(cfrom1) > fabs(ctoc) && ctoc != 0.f) {
    mul = smlnum;
    done = 0;
    cfromc = cfrom1;
  } else if (fabs(cto1) > fabs(cfromc)) {
    mul = bignum;
    done = 0;
    ctoc = cto1;
  } else {
    mul = ctoc / cfromc;
    done = 1;
  }
  if (itype == 0) {
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__2 = m__;
      for (i = 1; i <= m__; ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 1) {
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__2 = m__;
      for (i = j; i <= m__; ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 2) {
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__2 = (((j) < (m__)) ? (j) : (m__));
      for (i = 1; i <= (((j) < (m__)) ? (j) : (m__)); ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 3) {
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__3 = j + 1;
      i__2 = (((i__3) < (m__)) ? (i__3) : (m__));
      for (i = 1; i <= (((j + 1) < (m__)) ? (j + 1) : (m__)); ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 4) {
    k3 = kl_ + 1;
    k4 = n__ + 1;
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__3 = k3, i__4 = k4 - j;
      i__2 = (((i__3) < (i__4)) ? (i__3) : (i__4));
      for (i = 1; i <= (((k3) < (k4 - j)) ? (k3) : (k4 - j)); ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 5) {
    k1 = ku_ + 2;
    k3 = ku_ + 1;
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__2 = k1 - j;
      i__3 = k3;
      for (i = (((k1 - j) > (1)) ? (k1 - j) : (1)); i <= k3; ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  } else if (itype == 6) {
    k1 = kl_ + ku_ + 2;
    k2 = kl_ + 1;
    k3 = (kl_ << 1) + ku_ + 1;
    k4 = kl_ + ku_ + 1 + m__;
    i__1 = n__;
    for (j = 1; j <= n__; ++j) {
      i__3 = k1 - j;
      i__4 = k3, i__5 = k4 - j;
      i__2 = (((i__4) < (i__5)) ? (i__4) : (i__5));
      for (i = (((k1 - j) > (k2)) ? (k1 - j) : (k2));
           i <= (((k3) < (k4 - j)) ? (k3) : (k4 - j)); ++i) {
        a[(i)-1 + ((j)-1) * (lda)] *= mul;
      }
    }
  }
  if (!done) {
    goto L10;
  }
}


x86 assembly (clang, -O0):
<slascl>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x40(%rbp)
movsbl 0xeaf(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
cmp    %ecx,%eax
jne    1192 <slascl+0x72>
movl   $0x0,0x2eb7(%rip)
jmp    1304 <slascl+0x1e4>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x44(%rbp)
movsbl 0xe7a(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
cmp    %ecx,%eax
jne    11c9 <slascl+0xa9>
movl   $0x1,0x2e80(%rip)
jmp    12ff <slascl+0x1df>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x48(%rbp)
movsbl 0xe45(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%eax
cmp    %ecx,%eax
jne    1200 <slascl+0xe0>
movl   $0x2,0x2e49(%rip)
jmp    12fa <slascl+0x1da>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x4c(%rbp)
movsbl 0xe10(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
cmp    %ecx,%eax
jne    1237 <slascl+0x117>
movl   $0x3,0x2e12(%rip)
jmp    12f5 <slascl+0x1d5>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x50(%rbp)
movsbl 0xddb(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%eax
cmp    %ecx,%eax
jne    126e <slascl+0x14e>
movl   $0x4,0x2ddb(%rip)
jmp    12f0 <slascl+0x1d0>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x54(%rbp)
movsbl 0xda6(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
cmp    %ecx,%eax
jne    12a5 <slascl+0x185>
movl   $0x5,0x2da4(%rip)
jmp    12eb <slascl+0x1cb>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %eax,-0x58(%rbp)
movsbl 0xd71(%rip),%edi
call   1030 <toupper@plt>
mov    %eax,%ecx
mov    -0x58(%rbp),%eax
cmp    %ecx,%eax
jne    12dc <slascl+0x1bc>
movl   $0x6,0x2d6d(%rip)
jmp    12e6 <slascl+0x1c6>
movl   $0xffffffff,0x2d5e(%rip)
ff ff ff
jmp    12eb <slascl+0x1cb>
jmp    12f0 <slascl+0x1d0>
jmp    12f5 <slascl+0x1d5>
jmp    12fa <slascl+0x1da>
jmp    12ff <slascl+0x1df>
jmp    1304 <slascl+0x1e4>
cmpl   $0xffffffff,0x2d39(%rip)
jne    1320 <slascl+0x200>
mov    0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    156a <slascl+0x44a>
movss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1346 <slascl+0x226>
jp     1346 <slascl+0x226>
mov    0x18(%rbp),%rax
movl   $0xfffffffc,(%rax)
jmp    1565 <slascl+0x445>
cmpl   $0x0,-0x1c(%rbp)
jge    135f <slascl+0x23f>
mov    0x18(%rbp),%rax
movl   $0xfffffffa,(%rax)
jmp    1560 <slascl+0x440>
cmpl   $0x0,-0x20(%rbp)
jl     139b <slascl+0x27b>
cmpl   $0x4,0x2cd4(%rip)
jne    1382 <slascl+0x262>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    139b <slascl+0x27b>
cmpl   $0x5,0x2cbb(%rip)
jne    13aa <slascl+0x28a>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     13aa <slascl+0x28a>
mov    0x18(%rbp),%rax
movl   $0xfffffff9,(%rax)
jmp    155b <slascl+0x43b>
cmpl   $0x3,0x2c93(%rip)
jg     13fb <slascl+0x2db>
mov    0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jle    13d8 <slascl+0x2b8>
mov    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13de <slascl+0x2be>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%rbp),%ecx
cmp    %ecx,%eax
jge    13fb <slascl+0x2db>
mov    0x18(%rbp),%rax
movl   $0xfffffff7,(%rax)
jmp    1556 <slascl+0x436>
cmpl   $0x4,0x2c42(%rip)
jl     1551 <slascl+0x431>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     144e <slascl+0x32e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    1436 <slascl+0x316>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    1440 <slascl+0x320>
xor    %eax,%eax
mov    %eax,-0x68(%rbp)
jmp    1440 <slascl+0x320>
mov    -0x64(%rbp),%eax
mov    -0x68(%rbp),%ecx
cmp    %ecx,%eax
jle    145d <slascl+0x33d>
mov    0x18(%rbp),%rax
movl   $0xfffffffe,(%rax)
jmp    154c <slascl+0x42c>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     14c9 <slascl+0x3a9>
mov    -0x10(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    148b <slascl+0x36b>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    1495 <slascl+0x375>
xor    %eax,%eax
mov    %eax,-0x70(%rbp)
jmp    1495 <slascl+0x375>
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
cmp    %ecx,%eax
jg     14c9 <slascl+0x3a9>
cmpl   $0x4,0x2b9a(%rip)
je     14bd <slascl+0x39d>
cmpl   $0x5,0x2b8d(%rip)
jne    14d8 <slascl+0x3b8>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     14d8 <slascl+0x3b8>
mov    0x18(%rbp),%rax
movl   $0xfffffffd,(%rax)
jmp    1547 <slascl+0x427>
cmpl   $0x4,0x2b65(%rip)
jne    14f6 <slascl+0x3d6>
mov    0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1538 <slascl+0x418>
cmpl   $0x5,0x2b47(%rip)
jne    1514 <slascl+0x3f4>
mov    0x10(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     1538 <slascl+0x418>
cmpl   $0x6,0x2b29(%rip)
jne    1542 <slascl+0x422>
mov    0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
add    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1542 <slascl+0x422>
mov    0x18(%rbp),%rax
movl   $0xfffffff7,(%rax)
jmp    1547 <slascl+0x427>
jmp    154c <slascl+0x42c>
jmp    1551 <slascl+0x431>
jmp    1556 <slascl+0x436>
jmp    155b <slascl+0x43b>
jmp    1560 <slascl+0x440>
jmp    1565 <slascl+0x445>
jmp    156a <slascl+0x44a>
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1587 <slascl+0x467>
mov    0x18(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x2c(%rbp)
jmp    1f01 <slascl+0xde1>
cmpl   $0x0,-0x20(%rbp)
je     159b <slascl+0x47b>
cmpl   $0x0,-0x1c(%rbp)
jne    15a0 <slascl+0x480>
jmp    1f01 <slascl+0xde1>
lea    0xa87(%rip),%rdi
mov    $0x0,%al
call   1040 <slamch@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x2aaa(%rip)
movss  0xa3e(%rip),%xmm0
divss  0x2a9a(%rip),%xmm0
movss  %xmm0,0x2a8e(%rip)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,0x2a7d(%rip)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,0x2a4c(%rip)
movss  0x2a68(%rip),%xmm0
mulss  0x2a68(%rip),%xmm0
movss  %xmm0,0x2a54(%rip)
movss  0x2a2c(%rip),%xmm0
divss  0x2a4c(%rip),%xmm0
movss  %xmm0,0x2a50(%rip)
movss  0x2a34(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x9e1(%rip),%xmm1
pand   %xmm1,%xmm0
movss  0x29fd(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0x9ca(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    16a2 <slascl+0x582>
movss  0x29dc(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1673 <slascl+0x553>
jp     1673 <slascl+0x553>
jmp    16a2 <slascl+0x582>
movss  0x29e9(%rip),%xmm0
movss  %xmm0,0x29e5(%rip)
movl   $0x0,0x29a7(%rip)
movss  0x29c3(%rip),%xmm0
movss  %xmm0,0x29bf(%rip)
jmp    1730 <slascl+0x610>
movss  0x29c2(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x95b(%rip),%xmm1
pand   %xmm1,%xmm0
movss  0x299b(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0x944(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1709 <slascl+0x5e9>
movss  0x297e(%rip),%xmm0
movss  %xmm0,0x297e(%rip)
movl   $0x0,0x2940(%rip)
movss  0x2970(%rip),%xmm0
movss  %xmm0,0x2934(%rip)
jmp    172b <slascl+0x60b>
movss  0x2927(%rip),%xmm0
divss  0x2943(%rip),%xmm0
movss  %xmm0,0x2947(%rip)
movl   $0x1,0x2909(%rip)
jmp    1730 <slascl+0x610>
cmpl   $0x0,0x290d(%rip)
jne    17de <slascl+0x6be>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x28f3(%rip)
mov    0x28ed(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     17d9 <slascl+0x6b9>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,0x28d0(%rip)
mov    0x28ca(%rip),%eax
cmp    -0x1c(%rbp),%eax
jg     17c0 <slascl+0x6a0>
movss  0x28e5(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x28af(%rip),%ecx
sub    $0x1,%ecx
mov    0x28aa(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x288a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2881(%rip)
jmp    176c <slascl+0x64c>
jmp    17c5 <slascl+0x6a5>
mov    0x2875(%rip),%eax
add    $0x1,%eax
mov    %eax,0x286c(%rip)
jmp    174d <slascl+0x62d>
jmp    1eef <slascl+0xdcf>
cmpl   $0x1,0x285f(%rip)
jne    188e <slascl+0x76e>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2845(%rip)
mov    0x283f(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1889 <slascl+0x769>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    0x282a(%rip),%eax
mov    %eax,0x2820(%rip)
mov    0x281a(%rip),%eax
cmp    -0x1c(%rbp),%eax
jg     1870 <slascl+0x750>
movss  0x2835(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x27ff(%rip),%ecx
sub    $0x1,%ecx
mov    0x27fa(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x27da(%rip),%eax
add    $0x1,%eax
mov    %eax,0x27d1(%rip)
jmp    181c <slascl+0x6fc>
jmp    1875 <slascl+0x755>
mov    0x27c5(%rip),%eax
add    $0x1,%eax
mov    %eax,0x27bc(%rip)
jmp    17fb <slascl+0x6db>
jmp    1eea <slascl+0xdca>
cmpl   $0x2,0x27af(%rip)
jne    198a <slascl+0x86a>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2795(%rip)
mov    0x278f(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1985 <slascl+0x865>
mov    0x2780(%rip),%eax
cmp    -0x1c(%rbp),%eax
jge    18d7 <slascl+0x7b7>
mov    0x2771(%rip),%eax
mov    %eax,-0x74(%rbp)
jmp    18dd <slascl+0x7bd>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,0x274f(%rip)
mov    0x2749(%rip),%eax
mov    %eax,-0x78(%rbp)
mov    0x2744(%rip),%eax
cmp    -0x1c(%rbp),%eax
jge    1913 <slascl+0x7f3>
mov    0x2735(%rip),%eax
mov    %eax,-0x7c(%rbp)
jmp    1919 <slascl+0x7f9>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x7c(%rbp),%ecx
cmp    %ecx,%eax
jg     196c <slascl+0x84c>
movss  0x2739(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2703(%rip),%ecx
sub    $0x1,%ecx
mov    0x26fe(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x26de(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26d5(%rip)
jmp    18ed <slascl+0x7cd>
jmp    1971 <slascl+0x851>
mov    0x26c9(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26c0(%rip)
jmp    18ab <slascl+0x78b>
jmp    1ee5 <slascl+0xdc5>
cmpl   $0x3,0x26b3(%rip)
jne    1aa1 <slascl+0x981>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2699(%rip)
mov    0x2693(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1a9c <slascl+0x97c>
mov    0x2684(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    19d9 <slascl+0x8b9>
mov    -0x34(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    19df <slascl+0x8bf>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,0x264d(%rip)
mov    0x2647(%rip),%eax
mov    %eax,-0x84(%rbp)
mov    0x263f(%rip),%eax
add    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jge    1a21 <slascl+0x901>
mov    0x262d(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1a2a <slascl+0x90a>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x88(%rbp),%ecx
cmp    %ecx,%eax
jg     1a83 <slascl+0x963>
movss  0x2622(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x25ec(%rip),%ecx
sub    $0x1,%ecx
mov    0x25e7(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x25c7(%rip),%eax
add    $0x1,%eax
mov    %eax,0x25be(%rip)
jmp    19ef <slascl+0x8cf>
jmp    1a88 <slascl+0x968>
mov    0x25b2(%rip),%eax
add    $0x1,%eax
mov    %eax,0x25a9(%rip)
jmp    19a7 <slascl+0x887>
jmp    1ee0 <slascl+0xdc0>
cmpl   $0x4,0x259c(%rip)
jne    1bf3 <slascl+0xad3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x2596(%rip)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x258e(%rip)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x256a(%rip)
mov    0x2564(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1bee <slascl+0xace>
mov    0x2565(%rip),%eax
mov    %eax,-0x34(%rbp)
mov    0x2560(%rip),%eax
sub    0x2546(%rip),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b17 <slascl+0x9f7>
mov    -0x34(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1b20 <slascl+0xa00>
mov    -0x38(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,0x2509(%rip)
mov    0x2503(%rip),%eax
mov    %eax,-0x90(%rbp)
mov    0x250b(%rip),%eax
mov    0x2509(%rip),%ecx
sub    0x24ef(%rip),%ecx
cmp    %ecx,%eax
jge    1b6a <slascl+0xa4a>
mov    0x24f1(%rip),%eax
mov    %eax,-0x94(%rbp)
jmp    1b7c <slascl+0xa5c>
mov    0x24e4(%rip),%eax
sub    0x24ca(%rip),%eax
mov    %eax,-0x94(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x94(%rbp),%ecx
cmp    %ecx,%eax
jg     1bd5 <slascl+0xab5>
movss  0x24d0(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x249a(%rip),%ecx
sub    $0x1,%ecx
mov    0x2495(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x2475(%rip),%eax
add    $0x1,%eax
mov    %eax,0x246c(%rip)
jmp    1b33 <slascl+0xa13>
jmp    1bda <slascl+0xaba>
mov    0x2460(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2457(%rip)
jmp    1ad6 <slascl+0x9b6>
jmp    1edb <slascl+0xdbb>
cmpl   $0x5,0x244a(%rip)
jne    1d0c <slascl+0xbec>
mov    -0x10(%rbp),%eax
add    $0x2,%eax
mov    %eax,0x243c(%rip)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x2438(%rip)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x2418(%rip)
mov    0x2412(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1d07 <slascl+0xbe7>
mov    0x240b(%rip),%eax
sub    0x23fd(%rip),%eax
mov    %eax,-0x30(%rbp)
mov    0x2404(%rip),%eax
mov    %eax,-0x34(%rbp)
mov    0x23f3(%rip),%eax
sub    0x23e5(%rip),%eax
cmp    $0x1,%eax
jle    1c7b <slascl+0xb5b>
mov    0x23de(%rip),%eax
sub    0x23d0(%rip),%eax
mov    %eax,-0x98(%rbp)
jmp    1c8b <slascl+0xb6b>
mov    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1c8b <slascl+0xb6b>
mov    -0x98(%rbp),%eax
mov    %eax,0x23a5(%rip)
mov    0x239f(%rip),%eax
cmp    0x23ad(%rip),%eax
jg     1cee <slascl+0xbce>
movss  0x23b7(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x2381(%rip),%ecx
sub    $0x1,%ecx
mov    0x237c(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x235c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2353(%rip)
jmp    1c97 <slascl+0xb77>
jmp    1cf3 <slascl+0xbd3>
mov    0x2347(%rip),%eax
add    $0x1,%eax
mov    %eax,0x233e(%rip)
jmp    1c28 <slascl+0xb08>
jmp    1ed6 <slascl+0xdb6>
cmpl   $0x6,0x2331(%rip)
jne    1ed1 <slascl+0xdb1>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
add    $0x2,%eax
mov    %eax,0x2320(%rip)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x2318(%rip)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
add    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,0x230a(%rip)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
add    $0x1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,0x22fc(%rip)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,0x22d8(%rip)
mov    0x22d2(%rip),%eax
cmp    -0x20(%rbp),%eax
jg     1ecc <slascl+0xdac>
mov    0x22cb(%rip),%eax
sub    0x22bd(%rip),%eax
mov    %eax,-0x34(%rbp)
mov    0x22c4(%rip),%eax
mov    %eax,-0x38(%rbp)
mov    0x22bf(%rip),%eax
sub    0x22a5(%rip),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1db8 <slascl+0xc98>
mov    -0x38(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1dc1 <slascl+0xca1>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    0x2278(%rip),%eax
sub    0x226a(%rip),%eax
cmp    0x2270(%rip),%eax
jle    1df9 <slascl+0xcd9>
mov    0x2260(%rip),%eax
sub    0x2252(%rip),%eax
mov    %eax,-0xa0(%rbp)
jmp    1e05 <slascl+0xce5>
mov    0x224d(%rip),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,0x222b(%rip)
mov    0x2225(%rip),%eax
mov    %eax,-0xa4(%rbp)
mov    0x222d(%rip),%eax
mov    0x222b(%rip),%ecx
sub    0x2211(%rip),%ecx
cmp    %ecx,%eax
jge    1e48 <slascl+0xd28>
mov    0x2213(%rip),%eax
mov    %eax,-0xa8(%rbp)
jmp    1e5a <slascl+0xd3a>
mov    0x2206(%rip),%eax
sub    0x21ec(%rip),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%ecx
cmp    %ecx,%eax
jg     1eb3 <slascl+0xd93>
movss  0x21f2(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x21bc(%rip),%ecx
sub    $0x1,%ecx
mov    0x21b7(%rip),%edx
sub    $0x1,%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x2197(%rip),%eax
add    $0x1,%eax
mov    %eax,0x218e(%rip)
jmp    1e11 <slascl+0xcf1>
jmp    1eb8 <slascl+0xd98>
mov    0x2182(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2179(%rip)
jmp    1d68 <slascl+0xc48>
jmp    1ed1 <slascl+0xdb1>
jmp    1ed6 <slascl+0xdb6>
jmp    1edb <slascl+0xdbb>
jmp    1ee0 <slascl+0xdc0>
jmp    1ee5 <slascl+0xdc5>
jmp    1eea <slascl+0xdca>
jmp    1eef <slascl+0xdcf>
cmpl   $0x0,0x213e(%rip)
jne    1f01 <slascl+0xde1>
jmp    15ec <slascl+0x4cc>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slascl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,%rbx
mov    %r8,(%rsp)
mov    %rcx,0x8(%rsp)
movaps %xmm1,0xb0(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %edx,%r15d
mov    %esi,%r13d
mov    0x128(%rsp),%r12
movl   $0x0,(%r12)
movsbl (%rdi),%edi
call   1030 <toupper@plt>
mov    %eax,%ebp
mov    $0x47,%edi
call   1030 <toupper@plt>
mov    $0x1,%r14b
xor    %edx,%edx
cmp    %eax,%ebp
jne    1186 <slascl+0x66>
mov    $0x1,%al
mov    $0x1,%dil
xor    %ebp,%ebp
jmp    11ce <slascl+0xae>
mov    $0x4c,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    119b <slascl+0x7b>
mov    $0x1,%edx
jmp    11c7 <slascl+0xa7>
mov    $0x55,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    11b0 <slascl+0x90>
mov    $0x2,%edx
jmp    11c7 <slascl+0xa7>
mov    $0x48,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    21e2 <slascl+0x10c2>
mov    $0x3,%edx
xor    %ebp,%ebp
mov    $0x1,%al
mov    $0x1,%dil
mov    $0x1,%sil
movaps 0x20(%rsp),%xmm1
mov    %edx,0x3e58(%rip)
mov    $0xfffffffc,%edx
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    1201 <slascl+0xe1>
jp     1201 <slascl+0xe1>
mov    %edx,(%r12)
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpl   $0x0,0x8(%rsp)
js     21d8 <slascl+0x10b8>
mov    $0xfffffff9,%edx
mov    (%rsp),%rcx
test   %ecx,%ecx
js     11eb <slascl+0xcb>
cmp    0x8(%rsp),%ecx
je     1226 <slascl+0x106>
mov    %eax,%ecx
and    %r14b,%cl
je     11eb <slascl+0xcb>
mov    0x120(%rsp),%r8d
test   %dil,%dil
je     2200 <slascl+0x10e0>
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    $0x1,%eax
cmovne %ecx,%eax
mov    $0xfffffff7,%edx
cmp    %r8d,%eax
jg     11eb <slascl+0xcb>
mov    %r15,%rbp
cmpl   $0x0,0x8(%rsp)
mov    (%rsp),%r15
je     11ef <slascl+0xcf>
test   %r15d,%r15d
je     11ef <slascl+0xcf>
lea    0x1dd2(%rip),%rdi
xor    %eax,%eax
call   1040 <slamch@plt>
movaps 0x20(%rsp),%xmm2
movaps 0xb0(%rsp),%xmm5
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0x1d73(%rip),%xmm1
divss  %xmm0,%xmm1
mov    0x3d9d(%rip),%eax
mov    %eax,0x18(%rsp)
lea    0x0(%rbp,%r13,1),%eax
lea    0x2(%rbp,%r13,1),%ecx
mov    %ecx,0x74(%rsp)
lea    0x1(%r13),%ecx
mov    %ecx,0x1c(%rsp)
lea    0x1(%rbp),%ecx
mov    %ecx,0x48(%rsp)
lea    0x1(%rbp,%r13,2),%ecx
mov    %ecx,0x70(%rsp)
lea    0x1(%rbp,%r13,1),%ecx
mov    %ecx,0x44(%rsp)
mov    0x8(%rsp),%rcx
lea    0x1(%rcx,%rax,1),%eax
mov    %eax,0x6c(%rsp)
lea    0x2(%rbp),%eax
mov    %eax,0x68(%rsp)
movslq %ebp,%rdx
mov    %rdx,0x50(%rsp)
mov    %ecx,%eax
add    %ecx,%ebp
add    %r13d,%ebp
mov    %rbp,0x90(%rsp)
movaps %xmm0,%xmm10
shufps $0x0,%xmm0,%xmm10
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
lea    -0x8(%rax),%rcx
mov    %rcx,0x78(%rsp)
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rax,%rcx
not    %rcx
mov    %rcx,0xa0(%rsp)
mov    %eax,%edi
and    $0xfffffff8,%edi
mov    %rsi,%rcx
mov    %rsi,0xd8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xc0(%rsp)
movaps 0x1cc4(%rip),%xmm4
xorps  %xmm9,%xmm9
lea    0x1(%r15),%ecx
mov    %rcx,0xa8(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0x38(%rsp)
mov    %rax,0x98(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0x88(%rsp)
mov    0x120(%rsp),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x4c(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0xe0(%rsp)
mov    %rdi,0xd0(%rsp)
lea    0x1(%rdi),%rcx
mov    %rcx,0xc8(%rsp)
mov    %eax,%eax
mov    %rax,0x58(%rsp)
jmp    13bb <slascl+0x29b>
cmpb   $0x0,0x14(%rsp)
jne    11ef <slascl+0xcf>
movaps %xmm2,%xmm6
mulss  %xmm0,%xmm6
movaps %xmm6,%xmm7
andps  %xmm4,%xmm7
movaps %xmm5,%xmm3
andps  %xmm4,%xmm3
ucomiss %xmm3,%xmm7
jbe    13ed <slascl+0x2cd>
ucomiss %xmm9,%xmm5
jne    13db <slascl+0x2bb>
jnp    13ed <slascl+0x2cd>
movl   $0x0,0x14(%rsp)
movaps %xmm10,%xmm2
movss  %xmm6,%xmm2
jmp    142d <slascl+0x30d>
movaps %xmm5,%xmm6
divss  %xmm1,%xmm6
movaps %xmm6,%xmm3
andps  %xmm4,%xmm3
movaps %xmm2,%xmm7
andps  %xmm4,%xmm7
ucomiss %xmm7,%xmm3
jbe    141d <slascl+0x2fd>
movl   $0x0,0x14(%rsp)
movaps %xmm8,%xmm3
movss  %xmm2,%xmm3
movaps %xmm6,%xmm5
movaps %xmm3,%xmm2
jmp    142d <slascl+0x30d>
movaps %xmm5,%xmm3
divss  %xmm2,%xmm3
unpcklps %xmm3,%xmm2
mov    $0x1,%al
mov    %eax,0x14(%rsp)
cmpl   $0x6,0x18(%rsp)
ja     13b0 <slascl+0x290>
mov    0x18(%rsp),%eax
lea    0x1bdd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%r8d
mov    $0x8,%r9d
xor    %r10d,%r10d
mov    0x18(%rsp),%esi
jmp    148d <slascl+0x36d>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r8),%eax
add    $0x1,%esi
add    %r11d,%r9d
add    %r11d,%r10d
mov    (%rsp),%r15
cmp    %r15d,%r8d
mov    %eax,%r8d
je     13b0 <slascl+0x290>
lea    -0x1(%r8),%edi
mov    0x120(%rsp),%r11d
imul   %r11d,%edi
add    $0xffffffff,%edi
mov    $0x1,%ebp
cmpl   $0x8,0x98(%rsp)
08
jae    1530 <slascl+0x410>
mov    %rbp,%rcx
testb  $0x1,0x38(%rsp)
jne    14d4 <slascl+0x3b4>
add    %ebp,%edi
movslq %edi,%rax
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
lea    0x1(%rbp),%rcx
not    %rbp
cmp    0xa0(%rsp),%rbp
je     1470 <slascl+0x350>
lea    (%r10,%rcx,1),%eax
mov    0x38(%rsp),%rdx
sub    %rcx,%rdx
nopl   (%rax)
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rcx,4)
cltq
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
add    $0x2,%eax
add    $0xfffffffffffffffe,%rdx
jne    14f0 <slascl+0x3d0>
jmp    1470 <slascl+0x350>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%eax
imul   %r11d,%eax
mov    0x88(%rsp),%rdx
lea    (%rax,%rdx,1),%ecx
cmp    %eax,%ecx
jl     14b3 <slascl+0x393>
mov    %rdx,%rax
shr    $0x20,%rax
jne    14b3 <slascl+0x393>
cmpq   $0x8,0x78(%rsp)
jae    1562 <slascl+0x442>
xor    %ebp,%ebp
jmp    15b5 <slascl+0x495>
mov    0xc0(%rsp),%rdx
mov    %r9d,%eax
xor    %ebp,%ebp
nop
lea    -0x8(%rax),%ecx
movslq %ecx,%rcx
movups (%rbx,%rcx,4),%xmm3
movups 0x10(%rbx,%rcx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rcx,4)
movups %xmm7,0x10(%rbx,%rcx,4)
cltq
movups (%rbx,%rax,4),%xmm3
movups 0x10(%rbx,%rax,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
add    $0x10,%rbp
add    $0x10,%eax
add    $0xfffffffffffffffe,%rdx
jne    1570 <slascl+0x450>
testb  $0x1,0xd8(%rsp)
01
je     15df <slascl+0x4bf>
or     $0x1,%ebp
add    %edi,%ebp
movslq %ebp,%rax
movups (%rbx,%rax,4),%xmm3
movups 0x10(%rbx,%rax,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
mov    0xc8(%rsp),%rbp
mov    0xd0(%rsp),%rax
cmp    %rax,0x98(%rsp)
je     1470 <slascl+0x350>
jmp    14b3 <slascl+0x393>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%edx
mov    $0x8,%r14d
xor    %r11d,%r11d
mov    0x78(%rsp),%r13
xor    %ecx,%ecx
jmp    1646 <slascl+0x526>
add    $0x1,%rdx
add    $0x1,%rcx
add    0x4c(%rsp),%r14d
add    $0xffffffffffffffff,%r13
add    %r12d,%r11d
cmp    0xa8(%rsp),%rdx
mov    (%rsp),%r15
je     13b0 <slascl+0x290>
cmp    0x8(%rsp),%edx
mov    0x120(%rsp),%r12d
jg     1620 <slascl+0x500>
mov    %rcx,%rax
not    %rax
mov    0x38(%rsp),%rsi
lea    (%rax,%rsi,1),%r8
lea    -0x1(%rdx),%r9d
imul   %r12d,%r9d
add    $0xffffffff,%r9d
mov    %rdx,%rsi
cmp    $0x8,%r8
jb     1770 <slascl+0x650>
mov    0x88(%rsp),%rbp
sub    %rcx,%rbp
mov    0x4c(%rsp),%esi
mov    %esi,%edi
imul   %ecx,%edi
lea    (%rdi,%rbp,1),%r10d
mov    %rdx,%rsi
cmp    %edi,%r10d
jl     1770 <slascl+0x650>
shr    $0x20,%rbp
mov    %rdx,%rsi
jne    1770 <slascl+0x650>
mov    0x38(%rsp),%rsi
add    %rsi,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
cmp    $0x8,%rax
jae    16ce <slascl+0x5ae>
xor    %eax,%eax
jmp    1736 <slascl+0x616>
mov    %r13,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r14d,%ebp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x8(%rbp),%edi
movslq %edi,%rdi
movups (%rbx,%rdi,4),%xmm3
movups 0x10(%rbx,%rdi,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdi,4)
movups %xmm7,0x10(%rbx,%rdi,4)
movslq %ebp,%rbp
movups (%rbx,%rbp,4),%xmm3
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
add    $0x10,%rax
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rsi
jne    16f0 <slascl+0x5d0>
mov    %r8,%rsi
and    $0xfffffffffffffff8,%rsi
test   $0x1,%r10b
je     1762 <slascl+0x642>
add    %edx,%eax
add    %r9d,%eax
cltq
movups (%rbx,%rax,4),%xmm3
movups 0x10(%rbx,%rax,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
cmp    %rsi,%r8
je     1620 <slascl+0x500>
add    %rdx,%rsi
xchg   %ax,%ax
mov    0x38(%rsp),%rax
sub    %esi,%eax
mov    %rsi,%rbp
test   $0x1,%al
je     1796 <slascl+0x676>
add    %esi,%r9d
movslq %r9d,%rax
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
lea    0x1(%rsi),%rbp
not    %rsi
cmp    0xa0(%rsp),%rsi
je     1620 <slascl+0x500>
lea    (%r11,%rbp,1),%eax
mov    0x38(%rsp),%rsi
sub    %rbp,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rax),%edi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
cltq
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
add    $0x2,%eax
add    $0xfffffffffffffffe,%rsi
jne    17c0 <slascl+0x6a0>
jmp    1620 <slascl+0x500>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%esi
mov    $0x8,%r9d
xor    %r14d,%r14d
xor    %r11d,%r11d
jmp    1828 <slascl+0x708>
nopl   0x0(%rax)
lea    0x1(%rsi),%eax
add    $0x1,%r11d
add    %r12d,%r9d
add    %r12d,%r14d
cmp    %r15d,%esi
mov    %eax,%esi
je     13b0 <slascl+0x290>
mov    0x8(%rsp),%rax
cmp    %esi,%eax
mov    %esi,%edx
cmovl  %eax,%edx
cmovg  %esi,%eax
test   %eax,%eax
mov    0x120(%rsp),%r12d
jle    1810 <slascl+0x6f0>
add    $0x1,%edx
lea    -0x1(%rdx),%r8
lea    -0x1(%rsi),%r13d
imul   %r12d,%r13d
add    $0xffffffff,%r13d
mov    $0x1,%eax
cmp    $0x8,%r8
jb     1950 <slascl+0x830>
lea    -0x2(%rdx),%rcx
mov    %r11d,%ebp
imul   %r12d,%ebp
lea    (%rcx,%rbp,1),%edi
cmp    %ebp,%edi
jl     189e <slascl+0x77e>
shr    $0x20,%rcx
mov    (%rsp),%r15
jne    1950 <slascl+0x830>
lea    -0x9(%rdx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
cmp    $0x8,%rax
jae    18a7 <slascl+0x787>
xor    %ecx,%ecx
jmp    1906 <slascl+0x7e6>
mov    (%rsp),%r15
jmp    1950 <slascl+0x830>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    %r9d,%ebp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x8(%rbp),%edi
movslq %edi,%rdi
movups (%rbx,%rdi,4),%xmm3
movups 0x10(%rbx,%rdi,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdi,4)
movups %xmm7,0x10(%rbx,%rdi,4)
movslq %ebp,%rbp
movups (%rbx,%rbp,4),%xmm3
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
add    $0x10,%rcx
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rax
jne    18c0 <slascl+0x7a0>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
test   $0x1,%r10b
je     1934 <slascl+0x814>
or     $0x1,%ecx
add    %r13d,%ecx
movslq %ecx,%rcx
movups (%rbx,%rcx,4),%xmm3
movups 0x10(%rbx,%rcx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rcx,4)
movups %xmm7,0x10(%rbx,%rcx,4)
cmp    %rax,%r8
mov    (%rsp),%r15
je     1810 <slascl+0x6f0>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rcx
test   $0x1,%dl
jne    1970 <slascl+0x850>
add    %eax,%r13d
movslq %r13d,%rcx
movss  (%rbx,%rcx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rcx,4)
lea    0x1(%rax),%rcx
not    %rax
add    %rdx,%rax
je     1810 <slascl+0x6f0>
lea    (%r14,%rcx,1),%eax
sub    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rcx,4)
cltq
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
add    $0x2,%eax
add    $0xfffffffffffffffe,%rdx
jne    1990 <slascl+0x870>
jmp    1810 <slascl+0x6f0>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%r9d
xor    %r13d,%r13d
mov    $0x8,%r10d
mov    $0x2,%esi
mov    $0xffffffffffffffff,%rdi
jmp    1a13 <slascl+0x8f3>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13d
mov    0x120(%rsp),%eax
add    %eax,%r10d
add    $0x1,%esi
add    0x58(%rsp),%rdi
mov    (%rsp),%r15
cmp    %r15d,%r8d
je     13b0 <slascl+0x290>
mov    %r9d,%r8d
mov    0x8(%rsp),%rax
cmp    %esi,%eax
mov    %esi,%ecx
cmovl  %eax,%ecx
lea    0x2(%r13),%r14d
cmp    %r14d,%eax
cmovl  %eax,%r14d
lea    0x1(%r8),%r9d
cmp    %eax,%r9d
mov    %eax,%r15d
cmovl  %r9d,%r15d
test   %r15d,%r15d
jle    19f0 <slascl+0x8d0>
mov    $0x1,%ebp
cmp    $0x8,%r14d
jb     1b50 <slascl+0xa30>
lea    -0x1(%r14),%r11
mov    %r13d,%eax
mov    0x120(%rsp),%edx
imul   %edx,%eax
lea    (%r11,%rax,1),%edx
cmp    %eax,%edx
jl     1b50 <slascl+0xa30>
shr    $0x20,%r11
jne    1b50 <slascl+0xa30>
mov    %r14d,%eax
and    $0xfffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,%r12
shr    $0x3,%r12
add    $0x1,%r12
test   %rax,%rax
je     1af8 <slascl+0x9d8>
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %r10d,%ebp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    -0x8(%rbp),%edx
movslq %edx,%rdx
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdx,4)
movups %xmm7,0x10(%rbx,%rdx,4)
movslq %ebp,%rbp
movups (%rbx,%rbp,4),%xmm3
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
add    $0x10,%rax
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rcx
jne    1ab0 <slascl+0x990>
jmp    1afa <slascl+0x9da>
xor    %eax,%eax
mov    %r14d,%ebp
and    $0xfffffff8,%ebp
test   $0x1,%r12b
je     1b36 <slascl+0xa16>
lea    -0x1(%r8),%ecx
mov    0x120(%rsp),%edx
imul   %edx,%ecx
add    $0xffffffff,%ecx
or     $0x1,%eax
add    %ecx,%eax
cltq
movups (%rbx,%rax,4),%xmm3
movups 0x10(%rbx,%rax,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
cmp    %r14,%rbp
je     19f0 <slascl+0x8d0>
or     $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%rbp,1),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rcx,4)
lea    0x1(%rbp),%rcx
cmp    %rax,%rbp
mov    %rcx,%rbp
jb     1b60 <slascl+0xa40>
jmp    19f0 <slascl+0x8d0>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%r9d
xor    %r10d,%r10d
mov    $0x8,%r8d
mov    $0xffffffffffffffff,%rsi
mov    %r15d,%r12d
jmp    1bd0 <slascl+0xab0>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r9),%eax
add    $0x1,%r10d
add    %r13d,%r8d
add    $0xffffffff,%r12d
add    0x58(%rsp),%rsi
cmp    %r15d,%r9d
mov    %eax,%r9d
je     13b0 <slascl+0x290>
mov    0x1c(%rsp),%ecx
cmp    %ecx,%r12d
mov    %ecx,%edi
cmovl  %r12d,%edi
mov    %r15d,%eax
sub    %r10d,%eax
cmp    %ecx,%eax
cmovge %ecx,%eax
mov    0xa8(%rsp),%rdx
mov    %edx,%r14d
sub    %r9d,%r14d
cmp    %r14d,%ecx
cmovl  %ecx,%r14d
test   %r14d,%r14d
mov    0x120(%rsp),%r13d
jle    1bb0 <slascl+0xa90>
mov    $0x1,%ecx
cmp    $0x8,%eax
jb     1d10 <slascl+0xbf0>
lea    -0x1(%rax),%r11
mov    %r10d,%ebp
imul   %r13d,%ebp
lea    (%r11,%rbp,1),%edx
cmp    %ebp,%edx
jl     1cb8 <slascl+0xb98>
shr    $0x20,%r11
mov    (%rsp),%r15
jne    1d10 <slascl+0xbf0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rcx,%rcx
je     1cbe <slascl+0xb9e>
and    $0xfffffff8,%edi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    %r8d,%ecx
xor    %ebp,%ebp
xchg   %ax,%ax
lea    -0x8(%rcx),%edx
movslq %edx,%rdx
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdx,4)
movups %xmm7,0x10(%rbx,%rdx,4)
movslq %ecx,%rcx
movups (%rbx,%rcx,4),%xmm3
movups 0x10(%rbx,%rcx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rcx,4)
movups %xmm7,0x10(%rbx,%rcx,4)
add    $0x10,%rbp
add    $0x10,%ecx
add    $0xfffffffffffffffe,%rdi
jne    1c70 <slascl+0xb50>
jmp    1cc0 <slascl+0xba0>
mov    (%rsp),%r15
jmp    1d10 <slascl+0xbf0>
xor    %ebp,%ebp
mov    %eax,%ecx
and    $0xfffffff8,%ecx
test   $0x1,%r15b
je     1cf6 <slascl+0xbd6>
lea    -0x1(%r9),%edx
imul   %r13d,%edx
add    $0xffffffff,%edx
or     $0x1,%ebp
add    %edx,%ebp
movslq %ebp,%rdx
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdx,4)
movups %xmm7,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
mov    (%rsp),%r15
je     1bb0 <slascl+0xa90>
or     $0x1,%rcx
nopw   0x0(%rax,%rax,1)
mov    %r14d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rcx,1),%edx
movslq %edx,%rdx
movss  (%rbx,%rdx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rdx,4)
lea    0x1(%rcx),%rdx
cmp    %rax,%rcx
mov    %rdx,%rcx
jb     1d20 <slascl+0xc00>
jmp    1bb0 <slascl+0xa90>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%r8d
xor    %r14d,%r14d
mov    $0x7,%r9d
mov    $0xffffffffffffffff,%rcx
mov    0x48(%rsp),%r12d
jmp    1d97 <slascl+0xc77>
nopl   0x0(%rax)
lea    0x1(%r8),%eax
add    $0xffffffff,%r12d
add    $0x1,%r14d
mov    0x120(%rsp),%edx
add    %edx,%r9d
add    0x58(%rsp),%rcx
cmp    %r15d,%r8d
mov    %eax,%r8d
je     13b0 <slascl+0x290>
cmp    $0x2,%r12d
mov    $0x1,%r13d
cmovge %r12d,%r13d
mov    0xe0(%rsp),%rdx
cmp    %r13,%rdx
mov    %r13,%rsi
cmovg  %rdx,%rsi
mov    0x48(%rsp),%eax
mov    %eax,%edi
sub    %r14d,%edi
cmp    $0x2,%edi
mov    $0x1,%ebp
cmovl  %ebp,%edi
cmp    %rdi,%rdx
mov    %rdi,%r11
cmovg  %rdx,%r11
mov    %rdi,%r10
cmovg  %rdx,%r10
mov    0x68(%rsp),%edx
sub    %r8d,%edx
test   %edx,%edx
cmovle %ebp,%edx
cmp    %eax,%edx
jg     1d70 <slascl+0xc50>
sub    %rdi,%r11
lea    0x1(%r11),%rax
cmp    $0x2,%r12d
mov    $0x1,%edx
cmovge %r12d,%edx
cmp    $0x8,%rax
jae    1e10 <slascl+0xcf0>
mov    0x50(%rsp),%rdi
jmp    1f30 <slascl+0xe10>
mov    %rax,%r15
sub    %rdi,%r10
mov    %r14d,%ebp
mov    0x120(%rsp),%eax
imul   %eax,%ebp
add    %ebp,%edi
add    $0xffffffff,%edi
lea    (%r10,%rdi,1),%ebp
cmp    %edi,%ebp
jl     1e57 <slascl+0xd37>
shr    $0x20,%r10
jne    1e57 <slascl+0xd37>
add    $0xfffffffffffffff9,%r11
mov    %r11,%r10
shr    $0x3,%r10
add    $0x1,%r10
cmp    $0x8,%r11
jae    1e65 <slascl+0xd45>
xor    %eax,%eax
mov    0x120(%rsp),%r11d
jmp    1ed6 <slascl+0xdb6>
mov    (%rsp),%r15
mov    0x50(%rsp),%rdi
jmp    1f30 <slascl+0xe10>
mov    %r13d,%edi
add    %r9d,%edi
sub    %r13,%rsi
add    $0xfffffffffffffff9,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %eax,%eax
mov    0x120(%rsp),%r11d
nopl   0x0(%rax,%rax,1)
lea    -0x8(%rdi),%ebp
movslq %ebp,%rbp
movups (%rbx,%rbp,4),%xmm3
movups 0x10(%rbx,%rbp,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rbp,4)
movups %xmm7,0x10(%rbx,%rbp,4)
movslq %edi,%rdi
movups (%rbx,%rdi,4),%xmm3
movups 0x10(%rbx,%rdi,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdi,4)
movups %xmm7,0x10(%rbx,%rdi,4)
add    $0x10,%rax
add    $0x10,%edi
add    $0xfffffffffffffffe,%rsi
jne    1e90 <slascl+0xd70>
mov    %r15,%rbp
mov    %r15,%rsi
and    $0xfffffffffffffff8,%rsi
test   $0x1,%r10b
je     1f0f <slascl+0xdef>
lea    -0x1(%r8),%edi
imul   %r11d,%edi
add    $0xffffffff,%edi
add    %edx,%eax
add    %edi,%eax
cltq
movups (%rbx,%rax,4),%xmm3
movups 0x10(%rbx,%rax,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
cmp    %rsi,%rbp
mov    (%rsp),%r15
mov    0x50(%rsp),%rdi
je     1d70 <slascl+0xc50>
add    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rdx,1),%eax
cltq
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rax,4)
lea    0x1(%rdx),%rax
cmp    %rdi,%rdx
mov    %rax,%rdx
jle    1f30 <slascl+0xe10>
jmp    1d70 <slascl+0xc50>
movaps %xmm2,%xmm6
shufps $0x55,%xmm2,%xmm6
mov    $0x1,%r14d
xor    %r11d,%r11d
mov    $0x7,%r9d
mov    $0xffffffffffffffff,%r8
mov    0x90(%rsp),%rax
mov    %eax,%r12d
mov    0x44(%rsp),%r10d
jmp    1fbf <slascl+0xe9f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r14),%eax
add    $0xffffffff,%r10d
add    $0x1,%r11d
mov    0x120(%rsp),%ecx
add    %ecx,%r9d
add    $0xffffffff,%r12d
add    0x58(%rsp),%r8
mov    (%rsp),%r15
cmp    %r15d,%r14d
mov    %eax,%r14d
je     13b0 <slascl+0x290>
mov    0x1c(%rsp),%ecx
cmp    %ecx,%r10d
mov    %ecx,%edx
cmovg  %r10d,%edx
mov    0x70(%rsp),%edi
cmp    %edi,%r12d
mov    %edi,%r15d
cmovl  %r12d,%r15d
cmp    %r10d,%r15d
cmovle %r10d,%r15d
cmp    %ecx,%r15d
cmovle %ecx,%r15d
mov    0x90(%rsp),%rax
sub    %r11d,%eax
cmp    %edi,%eax
cmovge %edi,%eax
mov    0x44(%rsp),%esi
mov    %esi,%ebp
sub    %r11d,%ebp
cmp    %ebp,%eax
mov    %ebp,%r13d
cmovg  %eax,%r13d
cmp    %ecx,%r13d
cmovle %ecx,%r13d
cmp    %ecx,%ebp
cmovle %ecx,%ebp
cmp    %ebp,%eax
cmovle %ebp,%eax
mov    0x74(%rsp),%esi
sub    %r14d,%esi
cmp    %ecx,%esi
cmovle %ecx,%esi
mov    0x6c(%rsp),%ecx
sub    %r14d,%ecx
cmp    %ecx,%edi
cmovl  %edi,%ecx
cmp    %ecx,%esi
jg     1f90 <slascl+0xe70>
mov    %r14,0x20(%rsp)
movslq %ebp,%rsi
movslq %eax,%r14
mov    %rsi,0xb0(%rsp)
sub    %rsi,%r14
lea    0x1(%r14),%rsi
mov    0x1c(%rsp),%eax
cmp    %eax,%r10d
mov    %eax,%edi
cmovg  %r10d,%edi
movslq %edi,%rax
cmp    $0x8,%rsi
jb     20d0 <slascl+0xfb0>
mov    %edi,0x64(%rsp)
mov    %rsi,0x80(%rsp)
mov    %r9d,%edi
mov    %r11d,%esi
mov    0x120(%rsp),%r9d
imul   %r9d,%esi
add    %ebp,%esi
add    $0xffffffff,%esi
lea    (%r14,%rsi,1),%ebp
cmp    %esi,%ebp
jl     20cb <slascl+0xfab>
shr    $0x20,%r14
mov    %edi,%r9d
jne    20d0 <slascl+0xfb0>
movslq %r13d,%rsi
sub    0xb0(%rsp),%rsi
add    $0xfffffffffffffff9,%rsi
mov    %rsi,%r13
shr    $0x3,%r13
add    $0x1,%r13
cmp    $0x8,%rsi
jae    2106 <slascl+0xfe6>
xor    %edi,%edi
mov    0x20(%rsp),%r14
jmp    2176 <slascl+0x1056>
mov    %edi,%r9d
xchg   %ax,%ax
mov    0x20(%rsp),%r14
movslq %ecx,%rcx
nopl   0x0(%rax,%rax,1)
lea    (%r8,%rax,1),%edx
movslq %edx,%rdx
movss  (%rbx,%rdx,4),%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rbx,%rdx,4)
lea    0x1(%rax),%rdx
cmp    %rcx,%rax
mov    %rdx,%rax
jl     20e0 <slascl+0xfc0>
jmp    1f90 <slascl+0xe70>
movslq %r15d,%rbp
movslq %edx,%rsi
add    %r9d,%edx
sub    %rsi,%rbp
add    $0xfffffffffffffff9,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
mov    0x20(%rsp),%r14
nopl   0x0(%rax)
lea    -0x8(%rdx),%esi
movslq %esi,%rsi
movups (%rbx,%rsi,4),%xmm3
movups 0x10(%rbx,%rsi,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rsi,4)
movups %xmm7,0x10(%rbx,%rsi,4)
movslq %edx,%rdx
movups (%rbx,%rdx,4),%xmm3
movups 0x10(%rbx,%rdx,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rdx,4)
movups %xmm7,0x10(%rbx,%rdx,4)
add    $0x10,%rdi
add    $0x10,%edx
add    $0xfffffffffffffffe,%rbp
jne    2130 <slascl+0x1010>
mov    0x80(%rsp),%rsi
mov    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%r13b
je     21c7 <slascl+0x10a7>
lea    -0x1(%r14),%esi
mov    0x120(%rsp),%ebp
imul   %ebp,%esi
add    $0xffffffff,%esi
mov    0x64(%rsp),%ebp
add    %edi,%ebp
add    %esi,%ebp
movslq %ebp,%rsi
movups (%rbx,%rsi,4),%xmm3
movups 0x10(%rbx,%rsi,4),%xmm7
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm7
movups %xmm3,(%rbx,%rsi,4)
movups %xmm7,0x10(%rbx,%rsi,4)
mov    0x80(%rsp),%rsi
cmp    %rdx,%rsi
je     1f90 <slascl+0xe70>
add    %rdx,%rax
jmp    20d5 <slascl+0xfb5>
mov    $0xfffffffa,%edx
jmp    11eb <slascl+0xcb>
mov    $0x42,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    22ab <slascl+0x118b>
mov    $0x4,%edx
xor    %eax,%eax
jmp    22c3 <slascl+0x11a3>
mov    $0xfffffffe,%edx
test   %r13d,%r13d
js     11eb <slascl+0xcb>
mov    0x8(%rsp),%rdi
test   %edi,%edi
mov    $0x1,%ecx
cmovne %edi,%ecx
cmp    %r13d,%ecx
jbe    11eb <slascl+0xcb>
mov    $0xfffffffd,%edx
test   %r15d,%r15d
js     11eb <slascl+0xcb>
mov    (%rsp),%rdi
test   %edi,%edi
mov    $0x1,%ecx
cmovne %edi,%ecx
cmp    %r15d,%r13d
sete   %dil
cmp    %r15d,%ecx
jbe    11eb <slascl+0xcb>
or     %sil,%dil
je     11eb <slascl+0xcb>
mov    0x120(%rsp),%ecx
mov    %rcx,%rdx
cmp    %edx,%r13d
setge  %cl
xor    $0x1,%al
cmp    %edx,%r15d
setl   %sil
mov    $0xfffffff7,%edx
test   %al,%cl
jne    11eb <slascl+0xcb>
or     %r14b,%sil
je     11eb <slascl+0xcb>
test   %bpl,%bpl
je     1250 <slascl+0x130>
lea    (%r15,%r13,2),%eax
mov    0x120(%rsp),%ecx
cmp    %ecx,%eax
jge    11eb <slascl+0xcb>
jmp    1250 <slascl+0x130>
mov    $0x51,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    22ce <slascl+0x11ae>
mov    $0x5,%edx
xor    %r14d,%r14d
mov    $0x1,%al
xor    %edi,%edi
xor    %ebp,%ebp
xor    %esi,%esi
jmp    11d1 <slascl+0xb1>
mov    $0x5a,%edi
call   1030 <toupper@plt>
cmp    %eax,%ebp
jne    22f0 <slascl+0x11d0>
mov    $0x1,%al
mov    $0x6,%edx
xor    %edi,%edi
mov    $0x1,%r14b
mov    $0x1,%bpl
jmp    11ce <slascl+0xae>
movl   $0xffffffff,0x2d3a(%rip)
ff ff ff
mov    $0xffffffff,%edx
jmp    11eb <slascl+0xcb>

LLVM IR (-O0):
@slascl.done = internal global i32 0
@slascl.ctoc = internal global float 0.000000e+00
@slascl.i = internal global i32 0
@slascl.j = internal global i32 0
@slascl.itype = internal global i32 0
@slascl.k1 = internal global i32 0
@slascl.k2 = internal global i32 0
@slascl.k3 = internal global i32 0
@slascl.k4 = internal global i32 0
@slascl.cfrom1 = internal global float 0.000000e+00
@slascl.cfromc = internal global float 0.000000e+00
@slascl.bignum = internal global float 0.000000e+00
@slascl.smlnum = internal global float 0.000000e+00
@slascl.mul = internal global float 0.000000e+00
@slascl.cto1 = internal global float 0.000000e+00
@.str = [2 x i8] c"G\00"
@.str.1 = [2 x i8] c"L\00"
@.str.2 = [2 x i8] c"U\00"
@.str.3 = [2 x i8] c"H\00"
@.str.4 = [2 x i8] c"B\00"
@.str.5 = [2 x i8] c"Q\00"
@.str.6 = [2 x i8] c"Z\00"
@.str.7 = [2 x i8] c"S\00"
define void @slascl(i8* %0, i32 %1, i32 %2, float %3, float %4, i32 %5, i32 %6, float* %7, i32 %8, i32* %9) {
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca i32
%17 = alloca i32
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store i8* %0, i8** %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store float %3, float* %14
store float %4, float* %15
store i32 %5, i32* %16
store i32 %6, i32* %17
store float* %7, float** %18
store i32 %8, i32* %19
store i32* %9, i32** %20
%26 = load i32*, i32** %20
store i32 0, i32* %26
%27 = load i8*, i8** %11
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = call i32 @toupper(i32 %29)
%31 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0)
%32 = sext i8 %31 to i32
%33 = call i32 @toupper(i32 %32)
%34 = icmp eq i32 %30, %33
br i1 %34, label %35, label %36
35: ; preds = %10
store i32 0, i32* @slascl.itype
br label %103
36: ; preds = %10
%37 = load i8*, i8** %11
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = call i32 @toupper(i32 %39)
%41 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0)
%42 = sext i8 %41 to i32
%43 = call i32 @toupper(i32 %42)
%44 = icmp eq i32 %40, %43
br i1 %44, label %45, label %46
45: ; preds = %36
store i32 1, i32* @slascl.itype
br label %102
46: ; preds = %36
%47 = load i8*, i8** %11
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = call i32 @toupper(i32 %49)
%51 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%52 = sext i8 %51 to i32
%53 = call i32 @toupper(i32 %52)
%54 = icmp eq i32 %50, %53
br i1 %54, label %55, label %56
55: ; preds = %46
store i32 2, i32* @slascl.itype
br label %101
56: ; preds = %46
%57 = load i8*, i8** %11
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = call i32 @toupper(i32 %59)
%61 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0)
%62 = sext i8 %61 to i32
%63 = call i32 @toupper(i32 %62)
%64 = icmp eq i32 %60, %63
br i1 %64, label %65, label %66
65: ; preds = %56
store i32 3, i32* @slascl.itype
br label %100
66: ; preds = %56
%67 = load i8*, i8** %11
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = call i32 @toupper(i32 %69)
%71 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0)
%72 = sext i8 %71 to i32
%73 = call i32 @toupper(i32 %72)
%74 = icmp eq i32 %70, %73
br i1 %74, label %75, label %76
75: ; preds = %66
store i32 4, i32* @slascl.itype
br label %99
76: ; preds = %66
%77 = load i8*, i8** %11
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = call i32 @toupper(i32 %79)
%81 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0)
%82 = sext i8 %81 to i32
%83 = call i32 @toupper(i32 %82)
%84 = icmp eq i32 %80, %83
br i1 %84, label %85, label %86
85: ; preds = %76
store i32 5, i32* @slascl.itype
br label %98
86: ; preds = %76
%87 = load i8*, i8** %11
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = call i32 @toupper(i32 %89)
%91 = load i8, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0)
%92 = sext i8 %91 to i32
%93 = call i32 @toupper(i32 %92)
%94 = icmp eq i32 %90, %93
br i1 %94, label %95, label %96
95: ; preds = %86
store i32 6, i32* @slascl.itype
br label %97
96: ; preds = %86
store i32 -1, i32* @slascl.itype
br label %97
97: ; preds = %96, %95
br label %98
98: ; preds = %97, %85
br label %99
99: ; preds = %98, %75
br label %100
100: ; preds = %99, %65
br label %101
101: ; preds = %100, %55
br label %102
102: ; preds = %101, %45
br label %103
103: ; preds = %102, %35
%104 = load i32, i32* @slascl.itype
%105 = icmp eq i32 %104, -1
br i1 %105, label %106, label %108
106: ; preds = %103
%107 = load i32*, i32** %20
store i32 -1, i32* %107
br label %236
108: ; preds = %103
%109 = load float, float* %14
%110 = fcmp oeq float %109, 0.000000e+00
br i1 %110, label %111, label %113
111: ; preds = %108
%112 = load i32*, i32** %20
store i32 -4, i32* %112
br label %235
113: ; preds = %108
%114 = load i32, i32* %16
%115 = icmp slt i32 %114, 0
br i1 %115, label %116, label %118
116: ; preds = %113
%117 = load i32*, i32** %20
store i32 -6, i32* %117
br label %234
118: ; preds = %113
%119 = load i32, i32* %17
%120 = icmp slt i32 %119, 0
br i1 %120, label %135, label %121
121: ; preds = %118
%122 = load i32, i32* @slascl.itype
%123 = icmp eq i32 %122, 4
br i1 %123, label %124, label %128
124: ; preds = %121
%125 = load i32, i32* %17
%126 = load i32, i32* %16
%127 = icmp ne i32 %125, %126
br i1 %127, label %135, label %128
128: ; preds = %124, %121
%129 = load i32, i32* @slascl.itype
%130 = icmp eq i32 %129, 5
br i1 %130, label %131, label %137
131: ; preds = %128
%132 = load i32, i32* %17
%133 = load i32, i32* %16
%134 = icmp ne i32 %132, %133
br i1 %134, label %135, label %137
135: ; preds = %131, %124, %118
%136 = load i32*, i32** %20
store i32 -7, i32* %136
br label %233
137: ; preds = %131, %128
%138 = load i32, i32* @slascl.itype
%139 = icmp sle i32 %138, 3
br i1 %139, label %140, label %152
140: ; preds = %137
%141 = load i32, i32* %19
%142 = load i32, i32* %16
%143 = icmp sgt i32 1, %142
br i1 %143, label %144, label %145
144: ; preds = %140
br label %147
145: ; preds = %140
%146 = load i32, i32* %16
br label %147
147: ; preds = %145, %144
%148 = phi i32 [ 1, %144 ], [ %146, %145 ]
%149 = icmp slt i32 %141, %148
br i1 %149, label %150, label %152
150: ; preds = %147
%151 = load i32*, i32** %20
store i32 -9, i32* %151
br label %232
152: ; preds = %147, %137
%153 = load i32, i32* @slascl.itype
%154 = icmp sge i32 %153, 4
br i1 %154, label %155, label %231
155: ; preds = %152
%156 = load i32, i32* %16
%157 = sub nsw i32 %156, 1
store i32 %157, i32* %21
%158 = load i32, i32* %12
%159 = icmp slt i32 %158, 0
br i1 %159, label %170, label %160
160: ; preds = %155
%161 = load i32, i32* %12
%162 = load i32, i32* %21
%163 = icmp sgt i32 %162, 0
br i1 %163, label %164, label %166
164: ; preds = %160
%165 = load i32, i32* %21
br label %167
166: ; preds = %160
br label %167
167: ; preds = %166, %164
%168 = phi i32 [ %165, %164 ], [ 0, %166 ]
%169 = icmp sgt i32 %161, %168
br i1 %169, label %170, label %172
170: ; preds = %167, %155
%171 = load i32*, i32** %20
store i32 -2, i32* %171
br label %230
172: ; preds = %167
%173 = load i32, i32* %17
%174 = sub nsw i32 %173, 1
store i32 %174, i32* %21
%175 = load i32, i32* %13
%176 = icmp slt i32 %175, 0
br i1 %176, label %197, label %177
177: ; preds = %172
%178 = load i32, i32* %13
%179 = load i32, i32* %21
%180 = icmp sgt i32 %179, 0
br i1 %180, label %181, label %183
181: ; preds = %177
%182 = load i32, i32* %21
br label %184
183: ; preds = %177
br label %184
184: ; preds = %183, %181
%185 = phi i32 [ %182, %181 ], [ 0, %183 ]
%186 = icmp sgt i32 %178, %185
br i1 %186, label %197, label %187
187: ; preds = %184
%188 = load i32, i32* @slascl.itype
%189 = icmp eq i32 %188, 4
br i1 %189, label %193, label %190
190: ; preds = %187
%191 = load i32, i32* @slascl.itype
%192 = icmp eq i32 %191, 5
br i1 %192, label %193, label %199
193: ; preds = %190, %187
%194 = load i32, i32* %12
%195 = load i32, i32* %13
%196 = icmp ne i32 %194, %195
br i1 %196, label %197, label %199
197: ; preds = %193, %184, %172
%198 = load i32*, i32** %20
store i32 -3, i32* %198
br label %229
199: ; preds = %193, %190
%200 = load i32, i32* @slascl.itype
%201 = icmp eq i32 %200, 4
br i1 %201, label %202, label %207
202: ; preds = %199
%203 = load i32, i32* %19
%204 = load i32, i32* %12
%205 = add nsw i32 %204, 1
%206 = icmp slt i32 %203, %205
br i1 %206, label %226, label %207
207: ; preds = %202, %199
%208 = load i32, i32* @slascl.itype
%209 = icmp eq i32 %208, 5
br i1 %209, label %210, label %215
210: ; preds = %207
%211 = load i32, i32* %19
%212 = load i32, i32* %13
%213 = add nsw i32 %212, 1
%214 = icmp slt i32 %211, %213
br i1 %214, label %226, label %215
215: ; preds = %210, %207
%216 = load i32, i32* @slascl.itype
%217 = icmp eq i32 %216, 6
br i1 %217, label %218, label %228
218: ; preds = %215
%219 = load i32, i32* %19
%220 = load i32, i32* %12
%221 = shl i32 %220, 1
%222 = load i32, i32* %13
%223 = add nsw i32 %221, %222
%224 = add nsw i32 %223, 1
%225 = icmp slt i32 %219, %224
br i1 %225, label %226, label %228
226: ; preds = %218, %210, %202
%227 = load i32*, i32** %20
store i32 -9, i32* %227
br label %228
228: ; preds = %226, %218, %215
br label %229
229: ; preds = %228, %197
br label %230
230: ; preds = %229, %170
br label %231
231: ; preds = %230, %152
br label %232
232: ; preds = %231, %150
br label %233
233: ; preds = %232, %135
br label %234
234: ; preds = %233, %116
br label %235
235: ; preds = %234, %111
br label %236
236: ; preds = %235, %106
%237 = load i32*, i32** %20
%238 = load i32, i32* %237
%239 = icmp ne i32 %238, 0
br i1 %239, label %240, label %244
240: ; preds = %236
%241 = load i32*, i32** %20
%242 = load i32, i32* %241
%243 = sub nsw i32 0, %242
store i32 %243, i32* %21
br label %703
244: ; preds = %236
%245 = load i32, i32* %17
%246 = icmp eq i32 %245, 0
br i1 %246, label %250, label %247
247: ; preds = %244
%248 = load i32, i32* %16
%249 = icmp eq i32 %248, 0
br i1 %249, label %250, label %251
250: ; preds = %247, %244
br label %703
251: ; preds = %247
%252 = call i32 (i8*, ...) bitcast (i32 (...)* @slamch to i32 (i8*, ...)*)(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%253 = sitofp i32 %252 to float
store float %253, float* @slascl.smlnum
%254 = load float, float* @slascl.smlnum
%255 = fdiv float 1.000000e+00, %254
store float %255, float* @slascl.bignum
%256 = load float, float* %14
store float %256, float* @slascl.cfromc
%257 = load float, float* %15
store float %257, float* @slascl.ctoc
br label %258
258: ; preds = %702, %251
%259 = load float, float* @slascl.cfromc
%260 = load float, float* @slascl.smlnum
%261 = fmul float %259, %260
store float %261, float* @slascl.cfrom1
%262 = load float, float* @slascl.ctoc
%263 = load float, float* @slascl.bignum
%264 = fdiv float %262, %263
store float %264, float* @slascl.cto1
%265 = load float, float* @slascl.cfrom1
%266 = fpext float %265 to double
%267 = call double @llvm.fabs.f64(double %266)
%268 = load float, float* @slascl.ctoc
%269 = fpext float %268 to double
%270 = call double @llvm.fabs.f64(double %269)
%271 = fcmp ogt double %267, %270
br i1 %271, label %272, label %278
272: ; preds = %258
%273 = load float, float* @slascl.ctoc
%274 = fcmp une float %273, 0.000000e+00
br i1 %274, label %275, label %278
275: ; preds = %272
%276 = load float, float* @slascl.smlnum
store float %276, float* @slascl.mul
store i32 0, i32* @slascl.done
%277 = load float, float* @slascl.cfrom1
store float %277, float* @slascl.cfromc
br label %294
278: ; preds = %272, %258
%279 = load float, float* @slascl.cto1
%280 = fpext float %279 to double
%281 = call double @llvm.fabs.f64(double %280)
%282 = load float, float* @slascl.cfromc
%283 = fpext float %282 to double
%284 = call double @llvm.fabs.f64(double %283)
%285 = fcmp ogt double %281, %284
br i1 %285, label %286, label %289
286: ; preds = %278
%287 = load float, float* @slascl.bignum
store float %287, float* @slascl.mul
store i32 0, i32* @slascl.done
%288 = load float, float* @slascl.cto1
store float %288, float* @slascl.ctoc
br label %293
289: ; preds = %278
%290 = load float, float* @slascl.ctoc
%291 = load float, float* @slascl.cfromc
%292 = fdiv float %290, %291
store float %292, float* @slascl.mul
store i32 1, i32* @slascl.done
br label %293
293: ; preds = %289, %286
br label %294
294: ; preds = %293, %275
%295 = load i32, i32* @slascl.itype
%296 = icmp eq i32 %295, 0
br i1 %296, label %297, label %331
297: ; preds = %294
%298 = load i32, i32* %17
store i32 %298, i32* %21
store i32 1, i32* @slascl.j
br label %299
299: ; preds = %327, %297
%300 = load i32, i32* @slascl.j
%301 = load i32, i32* %17
%302 = icmp sle i32 %300, %301
br i1 %302, label %303, label %330
303: ; preds = %299
%304 = load i32, i32* %16
store i32 %304, i32* %22
store i32 1, i32* @slascl.i
br label %305
305: ; preds = %323, %303
%306 = load i32, i32* @slascl.i
%307 = load i32, i32* %16
%308 = icmp sle i32 %306, %307
br i1 %308, label %309, label %326
309: ; preds = %305
%310 = load float, float* @slascl.mul
%311 = load float*, float** %18
%312 = load i32, i32* @slascl.i
%313 = sub nsw i32 %312, 1
%314 = load i32, i32* @slascl.j
%315 = sub nsw i32 %314, 1
%316 = load i32, i32* %19
%317 = mul nsw i32 %315, %316
%318 = add nsw i32 %313, %317
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds float, float* %311, i64 %319
%321 = load float, float* %320
%322 = fmul float %321, %310
store float %322, float* %320
br label %323
323: ; preds = %309
%324 = load i32, i32* @slascl.i
%325 = add nsw i32 %324, 1
store i32 %325, i32* @slascl.i
br label %305
326: ; preds = %305
br label %327
327: ; preds = %326
%328 = load i32, i32* @slascl.j
%329 = add nsw i32 %328, 1
store i32 %329, i32* @slascl.j
br label %299
330: ; preds = %299
br label %699
331: ; preds = %294
%332 = load i32, i32* @slascl.itype
%333 = icmp eq i32 %332, 1
br i1 %333, label %334, label %369
334: ; preds = %331
%335 = load i32, i32* %17
store i32 %335, i32* %21
store i32 1, i32* @slascl.j
br label %336
336: ; preds = %365, %334
%337 = load i32, i32* @slascl.j
%338 = load i32, i32* %17
%339 = icmp sle i32 %337, %338
br i1 %339, label %340, label %368
340: ; preds = %336
%341 = load i32, i32* %16
store i32 %341, i32* %22
%342 = load i32, i32* @slascl.j
store i32 %342, i32* @slascl.i
br label %343
343: ; preds = %361, %340
%344 = load i32, i32* @slascl.i
%345 = load i32, i32* %16
%346 = icmp sle i32 %344, %345
br i1 %346, label %347, label %364
347: ; preds = %343
%348 = load float, float* @slascl.mul
%349 = load float*, float** %18
%350 = load i32, i32* @slascl.i
%351 = sub nsw i32 %350, 1
%352 = load i32, i32* @slascl.j
%353 = sub nsw i32 %352, 1
%354 = load i32, i32* %19
%355 = mul nsw i32 %353, %354
%356 = add nsw i32 %351, %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %349, i64 %357
%359 = load float, float* %358
%360 = fmul float %359, %348
store float %360, float* %358
br label %361
361: ; preds = %347
%362 = load i32, i32* @slascl.i
%363 = add nsw i32 %362, 1
store i32 %363, i32* @slascl.i
br label %343
364: ; preds = %343
br label %365
365: ; preds = %364
%366 = load i32, i32* @slascl.j
%367 = add nsw i32 %366, 1
store i32 %367, i32* @slascl.j
br label %336
368: ; preds = %336
br label %698
369: ; preds = %331
%370 = load i32, i32* @slascl.itype
%371 = icmp eq i32 %370, 2
br i1 %371, label %372, label %422
372: ; preds = %369
%373 = load i32, i32* %17
store i32 %373, i32* %21
store i32 1, i32* @slascl.j
br label %374
374: ; preds = %418, %372
%375 = load i32, i32* @slascl.j
%376 = load i32, i32* %17
%377 = icmp sle i32 %375, %376
br i1 %377, label %378, label %421
378: ; preds = %374
%379 = load i32, i32* @slascl.j
%380 = load i32, i32* %16
%381 = icmp slt i32 %379, %380
br i1 %381, label %382, label %384
382: ; preds = %378
%383 = load i32, i32* @slascl.j
br label %386
384: ; preds = %378
%385 = load i32, i32* %16
br label %386
386: ; preds = %384, %382
%387 = phi i32 [ %383, %382 ], [ %385, %384 ]
store i32 %387, i32* %22
store i32 1, i32* @slascl.i
br label %388
388: ; preds = %414, %386
%389 = load i32, i32* @slascl.i
%390 = load i32, i32* @slascl.j
%391 = load i32, i32* %16
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %395
393: ; preds = %388
%394 = load i32, i32* @slascl.j
br label %397
395: ; preds = %388
%396 = load i32, i32* %16
br label %397
397: ; preds = %395, %393
%398 = phi i32 [ %394, %393 ], [ %396, %395 ]
%399 = icmp sle i32 %389, %398
br i1 %399, label %400, label %417
400: ; preds = %397
%401 = load float, float* @slascl.mul
%402 = load float*, float** %18
%403 = load i32, i32* @slascl.i
%404 = sub nsw i32 %403, 1
%405 = load i32, i32* @slascl.j
%406 = sub nsw i32 %405, 1
%407 = load i32, i32* %19
%408 = mul nsw i32 %406, %407
%409 = add nsw i32 %404, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %402, i64 %410
%412 = load float, float* %411
%413 = fmul float %412, %401
store float %413, float* %411
br label %414
414: ; preds = %400
%415 = load i32, i32* @slascl.i
%416 = add nsw i32 %415, 1
store i32 %416, i32* @slascl.i
br label %388
417: ; preds = %397
br label %418
418: ; preds = %417
%419 = load i32, i32* @slascl.j
%420 = add nsw i32 %419, 1
store i32 %420, i32* @slascl.j
br label %374
421: ; preds = %374
br label %697
422: ; preds = %369
%423 = load i32, i32* @slascl.itype
%424 = icmp eq i32 %423, 3
br i1 %424, label %425, label %479
425: ; preds = %422
%426 = load i32, i32* %17
store i32 %426, i32* %21
store i32 1, i32* @slascl.j
br label %427
427: ; preds = %475, %425
%428 = load i32, i32* @slascl.j
%429 = load i32, i32* %17
%430 = icmp sle i32 %428, %429
br i1 %430, label %431, label %478
431: ; preds = %427
%432 = load i32, i32* @slascl.j
%433 = add nsw i32 %432, 1
store i32 %433, i32* %23
%434 = load i32, i32* %23
%435 = load i32, i32* %16
%436 = icmp slt i32 %434, %435
br i1 %436, label %437, label %439
437: ; preds = %431
%438 = load i32, i32* %23
br label %441
439: ; preds = %431
%440 = load i32, i32* %16
br label %441
441: ; preds = %439, %437
%442 = phi i32 [ %438, %437 ], [ %440, %439 ]
store i32 %442, i32* %22
store i32 1, i32* @slascl.i
br label %443
443: ; preds = %471, %441
%444 = load i32, i32* @slascl.i
%445 = load i32, i32* @slascl.j
%446 = add nsw i32 %445, 1
%447 = load i32, i32* %16
%448 = icmp slt i32 %446, %447
br i1 %448, label %449, label %452
449: ; preds = %443
%450 = load i32, i32* @slascl.j
%451 = add nsw i32 %450, 1
br label %454
452: ; preds = %443
%453 = load i32, i32* %16
br label %454
454: ; preds = %452, %449
%455 = phi i32 [ %451, %449 ], [ %453, %452 ]
%456 = icmp sle i32 %444, %455
br i1 %456, label %457, label %474
457: ; preds = %454
%458 = load float, float* @slascl.mul
%459 = load float*, float** %18
%460 = load i32, i32* @slascl.i
%461 = sub nsw i32 %460, 1
%462 = load i32, i32* @slascl.j
%463 = sub nsw i32 %462, 1
%464 = load i32, i32* %19
%465 = mul nsw i32 %463, %464
%466 = add nsw i32 %461, %465
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds float, float* %459, i64 %467
%469 = load float, float* %468
%470 = fmul float %469, %458
store float %470, float* %468
br label %471
471: ; preds = %457
%472 = load i32, i32* @slascl.i
%473 = add nsw i32 %472, 1
store i32 %473, i32* @slascl.i
br label %443
474: ; preds = %454
br label %475
475: ; preds = %474
%476 = load i32, i32* @slascl.j
%477 = add nsw i32 %476, 1
store i32 %477, i32* @slascl.j
br label %427
478: ; preds = %427
br label %696
479: ; preds = %422
%480 = load i32, i32* @slascl.itype
%481 = icmp eq i32 %480, 4
br i1 %481, label %482, label %544
482: ; preds = %479
%483 = load i32, i32* %12
%484 = add nsw i32 %483, 1
store i32 %484, i32* @slascl.k3
%485 = load i32, i32* %17
%486 = add nsw i32 %485, 1
store i32 %486, i32* @slascl.k4
%487 = load i32, i32* %17
store i32 %487, i32* %21
store i32 1, i32* @slascl.j
br label %488
488: ; preds = %540, %482
%489 = load i32, i32* @slascl.j
%490 = load i32, i32* %17
%491 = icmp sle i32 %489, %490
br i1 %491, label %492, label %543
492: ; preds = %488
%493 = load i32, i32* @slascl.k3
store i32 %493, i32* %23
%494 = load i32, i32* @slascl.k4
%495 = load i32, i32* @slascl.j
%496 = sub nsw i32 %494, %495
store i32 %496, i32* %24
%497 = load i32, i32* %23
%498 = load i32, i32* %24
%499 = icmp slt i32 %497, %498
br i1 %499, label %500, label %502
500: ; preds = %492
%501 = load i32, i32* %23
br label %504
502: ; preds = %492
%503 = load i32, i32* %24
br label %504
504: ; preds = %502, %500
%505 = phi i32 [ %501, %500 ], [ %503, %502 ]
store i32 %505, i32* %22
store i32 1, i32* @slascl.i
br label %506
506: ; preds = %536, %504
%507 = load i32, i32* @slascl.i
%508 = load i32, i32* @slascl.k3
%509 = load i32, i32* @slascl.k4
%510 = load i32, i32* @slascl.j
%511 = sub nsw i32 %509, %510
%512 = icmp slt i32 %508, %511
br i1 %512, label %513, label %515
513: ; preds = %506
%514 = load i32, i32* @slascl.k3
br label %519
515: ; preds = %506
%516 = load i32, i32* @slascl.k4
%517 = load i32, i32* @slascl.j
%518 = sub nsw i32 %516, %517
br label %519
519: ; preds = %515, %513
%520 = phi i32 [ %514, %513 ], [ %518, %515 ]
%521 = icmp sle i32 %507, %520
br i1 %521, label %522, label %539
522: ; preds = %519
%523 = load float, float* @slascl.mul
%524 = load float*, float** %18
%525 = load i32, i32* @slascl.i
%526 = sub nsw i32 %525, 1
%527 = load i32, i32* @slascl.j
%528 = sub nsw i32 %527, 1
%529 = load i32, i32* %19
%530 = mul nsw i32 %528, %529
%531 = add nsw i32 %526, %530
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds float, float* %524, i64 %532
%534 = load float, float* %533
%535 = fmul float %534, %523
store float %535, float* %533
br label %536
536: ; preds = %522
%537 = load i32, i32* @slascl.i
%538 = add nsw i32 %537, 1
store i32 %538, i32* @slascl.i
br label %506
539: ; preds = %519
br label %540
540: ; preds = %539
%541 = load i32, i32* @slascl.j
%542 = add nsw i32 %541, 1
store i32 %542, i32* @slascl.j
br label %488
543: ; preds = %488
br label %695
544: ; preds = %479
%545 = load i32, i32* @slascl.itype
%546 = icmp eq i32 %545, 5
br i1 %546, label %547, label %599
547: ; preds = %544
%548 = load i32, i32* %13
%549 = add nsw i32 %548, 2
store i32 %549, i32* @slascl.k1
%550 = load i32, i32* %13
%551 = add nsw i32 %550, 1
store i32 %551, i32* @slascl.k3
%552 = load i32, i32* %17
store i32 %552, i32* %21
store i32 1, i32* @slascl.j
br label %553
553: ; preds = %595, %547
%554 = load i32, i32* @slascl.j
%555 = load i32, i32* %17
%556 = icmp sle i32 %554, %555
br i1 %556, label %557, label %598
557: ; preds = %553
%558 = load i32, i32* @slascl.k1
%559 = load i32, i32* @slascl.j
%560 = sub nsw i32 %558, %559
store i32 %560, i32* %22
%561 = load i32, i32* @slascl.k3
store i32 %561, i32* %23
%562 = load i32, i32* @slascl.k1
%563 = load i32, i32* @slascl.j
%564 = sub nsw i32 %562, %563
%565 = icmp sgt i32 %564, 1
br i1 %565, label %566, label %570
566: ; preds = %557
%567 = load i32, i32* @slascl.k1
%568 = load i32, i32* @slascl.j
%569 = sub nsw i32 %567, %568
br label %571
570: ; preds = %557
br label %571
571: ; preds = %570, %566
%572 = phi i32 [ %569, %566 ], [ 1, %570 ]
store i32 %572, i32* @slascl.i
br label %573
573: ; preds = %591, %571
%574 = load i32, i32* @slascl.i
%575 = load i32, i32* @slascl.k3
%576 = icmp sle i32 %574, %575
br i1 %576, label %577, label %594
577: ; preds = %573
%578 = load float, float* @slascl.mul
%579 = load float*, float** %18
%580 = load i32, i32* @slascl.i
%581 = sub nsw i32 %580, 1
%582 = load i32, i32* @slascl.j
%583 = sub nsw i32 %582, 1
%584 = load i32, i32* %19
%585 = mul nsw i32 %583, %584
%586 = add nsw i32 %581, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %579, i64 %587
%589 = load float, float* %588
%590 = fmul float %589, %578
store float %590, float* %588
br label %591
591: ; preds = %577
%592 = load i32, i32* @slascl.i
%593 = add nsw i32 %592, 1
store i32 %593, i32* @slascl.i
br label %573
594: ; preds = %573
br label %595
595: ; preds = %594
%596 = load i32, i32* @slascl.j
%597 = add nsw i32 %596, 1
store i32 %597, i32* @slascl.j
br label %553
598: ; preds = %553
br label %694
599: ; preds = %544
%600 = load i32, i32* @slascl.itype
%601 = icmp eq i32 %600, 6
br i1 %601, label %602, label %693
602: ; preds = %599
%603 = load i32, i32* %12
%604 = load i32, i32* %13
%605 = add nsw i32 %603, %604
%606 = add nsw i32 %605, 2
store i32 %606, i32* @slascl.k1
%607 = load i32, i32* %12
%608 = add nsw i32 %607, 1
store i32 %608, i32* @slascl.k2
%609 = load i32, i32* %12
%610 = shl i32 %609, 1
%611 = load i32, i32* %13
%612 = add nsw i32 %610, %611
%613 = add nsw i32 %612, 1
store i32 %613, i32* @slascl.k3
%614 = load i32, i32* %12
%615 = load i32, i32* %13
%616 = add nsw i32 %614, %615
%617 = add nsw i32 %616, 1
%618 = load i32, i32* %16
%619 = add nsw i32 %617, %618
store i32 %619, i32* @slascl.k4
%620 = load i32, i32* %17
store i32 %620, i32* %21
store i32 1, i32* @slascl.j
br label %621
621: ; preds = %689, %602
%622 = load i32, i32* @slascl.j
%623 = load i32, i32* %17
%624 = icmp sle i32 %622, %623
br i1 %624, label %625, label %692
625: ; preds = %621
%626 = load i32, i32* @slascl.k1
%627 = load i32, i32* @slascl.j
%628 = sub nsw i32 %626, %627
store i32 %628, i32* %23
%629 = load i32, i32* @slascl.k3
store i32 %629, i32* %24
%630 = load i32, i32* @slascl.k4
%631 = load i32, i32* @slascl.j
%632 = sub nsw i32 %630, %631
store i32 %632, i32* %25
%633 = load i32, i32* %24
%634 = load i32, i32* %25
%635 = icmp slt i32 %633, %634
br i1 %635, label %636, label %638
636: ; preds = %625
%637 = load i32, i32* %24
br label %640
638: ; preds = %625
%639 = load i32, i32* %25
br label %640
640: ; preds = %638, %636
%641 = phi i32 [ %637, %636 ], [ %639, %638 ]
store i32 %641, i32* %22
%642 = load i32, i32* @slascl.k1
%643 = load i32, i32* @slascl.j
%644 = sub nsw i32 %642, %643
%645 = load i32, i32* @slascl.k2
%646 = icmp sgt i32 %644, %645
br i1 %646, label %647, label %651
647: ; preds = %640
%648 = load i32, i32* @slascl.k1
%649 = load i32, i32* @slascl.j
%650 = sub nsw i32 %648, %649
br label %653
651: ; preds = %640
%652 = load i32, i32* @slascl.k2
br label %653
653: ; preds = %651, %647
%654 = phi i32 [ %650, %647 ], [ %652, %651 ]
store i32 %654, i32* @slascl.i
br label %655
655: ; preds = %685, %653
%656 = load i32, i32* @slascl.i
%657 = load i32, i32* @slascl.k3
%658 = load i32, i32* @slascl.k4
%659 = load i32, i32* @slascl.j
%660 = sub nsw i32 %658, %659
%661 = icmp slt i32 %657, %660
br i1 %661, label %662, label %664
662: ; preds = %655
%663 = load i32, i32* @slascl.k3
br label %668
664: ; preds = %655
%665 = load i32, i32* @slascl.k4
%666 = load i32, i32* @slascl.j
%667 = sub nsw i32 %665, %666
br label %668
668: ; preds = %664, %662
%669 = phi i32 [ %663, %662 ], [ %667, %664 ]
%670 = icmp sle i32 %656, %669
br i1 %670, label %671, label %688
671: ; preds = %668
%672 = load float, float* @slascl.mul
%673 = load float*, float** %18
%674 = load i32, i32* @slascl.i
%675 = sub nsw i32 %674, 1
%676 = load i32, i32* @slascl.j
%677 = sub nsw i32 %676, 1
%678 = load i32, i32* %19
%679 = mul nsw i32 %677, %678
%680 = add nsw i32 %675, %679
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds float, float* %673, i64 %681
%683 = load float, float* %682
%684 = fmul float %683, %672
store float %684, float* %682
br label %685
685: ; preds = %671
%686 = load i32, i32* @slascl.i
%687 = add nsw i32 %686, 1
store i32 %687, i32* @slascl.i
br label %655
688: ; preds = %668
br label %689
689: ; preds = %688
%690 = load i32, i32* @slascl.j
%691 = add nsw i32 %690, 1
store i32 %691, i32* @slascl.j
br label %621
692: ; preds = %621
br label %693
693: ; preds = %692, %599
br label %694
694: ; preds = %693, %598
br label %695
695: ; preds = %694, %543
br label %696
696: ; preds = %695, %478
br label %697
697: ; preds = %696, %421
br label %698
698: ; preds = %697, %368
br label %699
699: ; preds = %698, %330
%700 = load i32, i32* @slascl.done
%701 = icmp ne i32 %700, 0
br i1 %701, label %703, label %702
702: ; preds = %699
br label %258
703: ; preds = %240, %250, %699
ret void
}

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