#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef size_t start;
typedef size_t j;
typedef size_t i;
typedef size_t endd;

/* Variables and functions */
scalar_t__ toupper(char);
void slasrt(char *id, int n__, float *d, int *info) {
  int i__1, i__2;
  static int endd, i, j;
  static int stack[64];
  static float dmnmx, d1, d2, d3;
  static int start;
  static int stkpnt, dir;
  static float tmp;
  *info = 0;
  dir = -1;
  if ((toupper(*id) == toupper(*"D"))) {
    dir = 0;
  } else if ((toupper(*id) == toupper(*"I"))) {
    dir = 1;
  }
  if (dir == -1) {
    *info = -1;
  } else if (n__ < 0) {
    *info = -2;
  }
  if (*info != 0) {
    i__1 = -(*info);
    return;
  }
  if (n__ <= 1) {
    return;
  }
  stkpnt = 1;
  stack[(0)] = 1;
  stack[(1)] = n__;
L10:
  start = stack[((stkpnt << 1) - 2)];
  endd = stack[((stkpnt << 1) - 1)];
  --stkpnt;
  if (endd - start <= 20 && endd - start > 0) {
    if (dir == 0) {
      i__1 = endd;
      for (i = start + 1; i <= endd; ++i) {
        i__2 = start + 1;
        for (j = i; j >= start + 1; --j) {
          if (d[(j)-1] > d[(j - 1) - 1]) {
            dmnmx = d[(j)-1];
            d[(j)-1] = d[(j - 1) - 1];
            d[(j - 1) - 1] = dmnmx;
          } else {
            goto L30;
          }
        }
      L30:;
      }
    } else {
      i__1 = endd;
      for (i = start + 1; i <= endd; ++i) {
        i__2 = start + 1;
        for (j = i; j >= start + 1; --j) {
          if (d[(j)-1] < d[(j - 1) - 1]) {
            dmnmx = d[(j)-1];
            d[(j)-1] = d[(j - 1) - 1];
            d[(j - 1) - 1] = dmnmx;
          } else {
            goto L50;
          }
        }
      L50:;
      }
    }
  } else if (endd - start > 20) {
    d1 = d[(start)-1];
    d2 = d[(endd)-1];
    i = (start + endd) / 2;
    d3 = d[(i)-1];
    if (d1 < d2) {
      if (d3 < d1) {
        dmnmx = d1;
      } else if (d3 < d2) {
        dmnmx = d3;
      } else {
        dmnmx = d2;
      }
    } else {
      if (d3 < d2) {
        dmnmx = d2;
      } else if (d3 < d1) {
        dmnmx = d3;
      } else {
        dmnmx = d1;
      }
    }
    if (dir == 0) {
      i = start - 1;
      j = endd + 1;
    L60:
    L70:
      --j;
      if (d[(j)-1] < dmnmx) {
        goto L70;
      }
    L80:
      ++i;
      if (d[(i)-1] > dmnmx) {
        goto L80;
      }
      if (i < j) {
        tmp = d[(i)-1];
        d[(i)-1] = d[(j)-1];
        d[(j)-1] = tmp;
        goto L60;
      }
      if (j - start > endd - j - 1) {
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = start;
        stack[((stkpnt << 1) - 1)] = j;
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = j + 1;
        stack[((stkpnt << 1) - 1)] = endd;
      } else {
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = j + 1;
        stack[((stkpnt << 1) - 1)] = endd;
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = start;
        stack[((stkpnt << 1) - 1)] = j;
      }
    } else {
      i = start - 1;
      j = endd + 1;
    L90:
    L100:
      --j;
      if (d[(j)-1] > dmnmx) {
        goto L100;
      }
    L110:
      ++i;
      if (d[(i)-1] < dmnmx) {
        goto L110;
      }
      if (i < j) {
        tmp = d[(i)-1];
        d[(i)-1] = d[(j)-1];
        d[(j)-1] = tmp;
        goto L90;
      }
      if (j - start > endd - j - 1) {
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = start;
        stack[((stkpnt << 1) - 1)] = j;
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = j + 1;
        stack[((stkpnt << 1) - 1)] = endd;
      } else {
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = j + 1;
        stack[((stkpnt << 1) - 1)] = endd;
        ++stkpnt;
        stack[((stkpnt << 1) - 2)] = start;
        stack[((stkpnt << 1) - 1)] = j;
      }
    }
  }
  if (stkpnt > 0) {
    goto L10;
  }
}


x86 assembly (clang, -O0):
<slasrt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0xffffffff,0x302d(%rip)
ff ff ff
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %rax,-0x30(%rbp)
movsbl 0xeae(%rip),%edi
call   1030 <toupper@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
cmp    %rcx,%rax
jne    1176 <slasrt+0x66>
movl   $0x0,0x2ff7(%rip)
jmp    11b1 <slasrt+0xa1>
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1030 <toupper@plt>
mov    %rax,-0x38(%rbp)
movsbl 0xe75(%rip),%edi
call   1030 <toupper@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
cmp    %rcx,%rax
jne    11ac <slasrt+0x9c>
movl   $0x1,0x2fbc(%rip)
jmp    11b1 <slasrt+0xa1>
cmpl   $0xffffffff,0x2fb0(%rip)
jne    11cd <slasrt+0xbd>
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    11e6 <slasrt+0xd6>
cmpl   $0x0,-0xc(%rbp)
jge    11e1 <slasrt+0xd1>
mov    -0x20(%rbp),%rax
movl   $0xfffffffe,(%rax)
jmp    11e6 <slasrt+0xd6>
mov    -0x20(%rbp),%rax
cmpl   $0x0,(%rax)
je     1203 <slasrt+0xf3>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
mov    %eax,-0x24(%rbp)
jmp    1bda <slasrt+0xaca>
cmpl   $0x1,-0xc(%rbp)
jg     1212 <slasrt+0x102>
jmp    1bda <slasrt+0xaca>
movl   $0x1,0x2f48(%rip)
movl   $0x1,0x2e2a(%rip)
mov    -0xc(%rbp),%eax
mov    %eax,0x2e25(%rip)
mov    0x2f2f(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x2e0b(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2f12(%rip)
mov    0x2f10(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2dec(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2dd3(%rip)
mov    0x2ef1(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2ee8(%rip)
mov    0x2dbe(%rip),%eax
sub    0x2ed8(%rip),%eax
cmp    $0x14,%eax
jg     1532 <slasrt+0x422>
mov    0x2da9(%rip),%eax
sub    0x2ec3(%rip),%eax
cmp    $0x0,%eax
jle    1532 <slasrt+0x422>
cmpl   $0x0,0x2ebb(%rip)
jne    13ee <slasrt+0x2de>
mov    0x2d87(%rip),%eax
mov    %eax,-0x24(%rbp)
mov    0x2e9e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d79(%rip)
mov    0x2d73(%rip),%eax
cmp    0x2d69(%rip),%eax
jg     13e9 <slasrt+0x2d9>
mov    0x2e7d(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    0x2d55(%rip),%eax
mov    %eax,0x2d53(%rip)
mov    0x2d4d(%rip),%eax
mov    0x2e5f(%rip),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     13cb <slasrt+0x2bb>
mov    -0x18(%rbp),%rax
mov    0x2d32(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2d1d(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    13ad <slasrt+0x29d>
mov    -0x18(%rbp),%rax
mov    0x2d00(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2df5(%rip)
mov    -0x18(%rbp),%rax
mov    0x2ce3(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2ccb(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x2dc0(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2cae(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13b2 <slasrt+0x2a2>
jmp    13d0 <slasrt+0x2c0>
jmp    13b7 <slasrt+0x2a7>
mov    0x2c8b(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2c82(%rip)
jmp    12f5 <slasrt+0x1e5>
jmp    13d0 <slasrt+0x2c0>
jmp    13d5 <slasrt+0x2c5>
mov    0x2c69(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c60(%rip)
jmp    12cb <slasrt+0x1bb>
jmp    152d <slasrt+0x41d>
mov    0x2c4c(%rip),%eax
mov    %eax,-0x24(%rbp)
mov    0x2d63(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c3e(%rip)
mov    0x2c38(%rip),%eax
cmp    0x2c2e(%rip),%eax
jg     1528 <slasrt+0x418>
mov    0x2d42(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    0x2c1a(%rip),%eax
mov    %eax,0x2c18(%rip)
mov    0x2c12(%rip),%eax
mov    0x2d24(%rip),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     150a <slasrt+0x3fa>
mov    -0x18(%rbp),%rax
mov    0x2bf7(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    0x2be2(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    14ec <slasrt+0x3dc>
mov    -0x18(%rbp),%rax
mov    0x2bc1(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2cb6(%rip)
mov    -0x18(%rbp),%rax
mov    0x2ba4(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2b8c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x2c81(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2b6f(%rip),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    14f1 <slasrt+0x3e1>
jmp    150f <slasrt+0x3ff>
jmp    14f6 <slasrt+0x3e6>
mov    0x2b4c(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2b43(%rip)
jmp    1430 <slasrt+0x320>
jmp    150f <slasrt+0x3ff>
jmp    1514 <slasrt+0x404>
mov    0x2b2a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b21(%rip)
jmp    1406 <slasrt+0x2f6>
jmp    152d <slasrt+0x41d>
jmp    1bc8 <slasrt+0xab8>
mov    0x2b08(%rip),%eax
sub    0x2c22(%rip),%eax
cmp    $0x14,%eax
jle    1bc3 <slasrt+0xab3>
mov    -0x18(%rbp),%rax
mov    0x2c0f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2bf0(%rip)
mov    -0x18(%rbp),%rax
mov    0x2ad2(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2bd7(%rip)
mov    0x2bd9(%rip),%eax
add    0x2ab3(%rip),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,0x2aa9(%rip)
mov    -0x18(%rbp),%rax
mov    0x2a9f(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2ba4(%rip)
movss  0x2b94(%rip),%xmm1
movss  0x2b90(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1647 <slasrt+0x537>
movss  0x2b83(%rip),%xmm1
movss  0x2b73(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    15ff <slasrt+0x4ef>
movss  0x2b62(%rip),%xmm0
movss  %xmm0,0x2b56(%rip)
jmp    1642 <slasrt+0x532>
movss  0x2b55(%rip),%xmm1
movss  0x2b49(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    162d <slasrt+0x51d>
movss  0x2b3c(%rip),%xmm0
movss  %xmm0,0x2b28(%rip)
jmp    163d <slasrt+0x52d>
movss  0x2b23(%rip),%xmm0
movss  %xmm0,0x2b13(%rip)
jmp    1642 <slasrt+0x532>
jmp    16bd <slasrt+0x5ad>
movss  0x2b0d(%rip),%xmm1
movss  0x2b01(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1675 <slasrt+0x565>
movss  0x2af0(%rip),%xmm0
movss  %xmm0,0x2ae0(%rip)
jmp    16b8 <slasrt+0x5a8>
movss  0x2adf(%rip),%xmm1
movss  0x2acf(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    16a3 <slasrt+0x593>
movss  0x2ac6(%rip),%xmm0
movss  %xmm0,0x2ab2(%rip)
jmp    16b3 <slasrt+0x5a3>
movss  0x2aa9(%rip),%xmm0
movss  %xmm0,0x2a9d(%rip)
jmp    16b8 <slasrt+0x5a8>
jmp    16bd <slasrt+0x5ad>
cmpl   $0x0,0x2aa4(%rip)
jne    1944 <slasrt+0x834>
mov    0x2a90(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x296b(%rip)
mov    0x2961(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2960(%rip)
jmp    16ed <slasrt+0x5dd>
mov    0x2955(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x294c(%rip)
mov    -0x18(%rbp),%rax
mov    0x2942(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x2a37(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1727 <slasrt+0x617>
jmp    16ed <slasrt+0x5dd>
jmp    172c <slasrt+0x61c>
mov    0x2912(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2909(%rip)
mov    -0x18(%rbp),%rax
mov    0x28ff(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss 0x29f9(%rip),%xmm0
jbe    1762 <slasrt+0x652>
jmp    172c <slasrt+0x61c>
mov    0x28dc(%rip),%eax
cmp    0x28da(%rip),%eax
jge    17dd <slasrt+0x6cd>
mov    -0x18(%rbp),%rax
mov    0x28c6(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x29db(%rip)
mov    -0x18(%rbp),%rax
mov    0x28ad(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2894(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x29a9(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    0x287b(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16e8 <slasrt+0x5d8>
mov    0x2865(%rip),%eax
sub    0x2977(%rip),%eax
mov    0x2851(%rip),%ecx
sub    0x2853(%rip),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    18a2 <slasrt+0x792>
mov    0x295e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2955(%rip)
mov    0x294b(%rip),%edx
mov    0x2949(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x2825(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2814(%rip),%edx
mov    0x292a(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2806(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2911(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2908(%rip)
mov    0x27e6(%rip),%edx
add    $0x1,%edx
mov    0x28f9(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x27d5(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x27bc(%rip),%edx
mov    0x28da(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x27b6(%rip),%rax
mov    %edx,(%rax,%rcx,4)
jmp    193f <slasrt+0x82f>
mov    0x28bc(%rip),%eax
add    $0x1,%eax
mov    %eax,0x28b3(%rip)
mov    0x2791(%rip),%edx
add    $0x1,%edx
mov    0x28a4(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x2780(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2767(%rip),%edx
mov    0x2885(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2761(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x286c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2863(%rip)
mov    0x2859(%rip),%edx
mov    0x2857(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x2733(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2722(%rip),%edx
mov    0x2838(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2714(%rip),%rax
mov    %edx,(%rax,%rcx,4)
jmp    1bbe <slasrt+0xaae>
mov    0x2816(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x26f1(%rip)
mov    0x26e7(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26e6(%rip)
jmp    1967 <slasrt+0x857>
mov    0x26db(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x26d2(%rip)
mov    -0x18(%rbp),%rax
mov    0x26c8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss 0x27be(%rip),%xmm0
jbe    199d <slasrt+0x88d>
jmp    1967 <slasrt+0x857>
jmp    19a2 <slasrt+0x892>
mov    0x269c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2693(%rip)
mov    -0x18(%rbp),%rax
mov    0x2689(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x2782(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    19dc <slasrt+0x8cc>
jmp    19a2 <slasrt+0x892>
mov    0x2662(%rip),%eax
cmp    0x2660(%rip),%eax
jge    1a57 <slasrt+0x947>
mov    -0x18(%rbp),%rax
mov    0x264c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x2761(%rip)
mov    -0x18(%rbp),%rax
mov    0x2633(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    0x261a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x272f(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    0x2601(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1962 <slasrt+0x852>
mov    0x25eb(%rip),%eax
sub    0x26fd(%rip),%eax
mov    0x25d7(%rip),%ecx
sub    0x25d9(%rip),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1b1c <slasrt+0xa0c>
mov    0x26e4(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26db(%rip)
mov    0x26d1(%rip),%edx
mov    0x26cf(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x25ab(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x259a(%rip),%edx
mov    0x26b0(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x258c(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2697(%rip),%eax
add    $0x1,%eax
mov    %eax,0x268e(%rip)
mov    0x256c(%rip),%edx
add    $0x1,%edx
mov    0x267f(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x255b(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x2542(%rip),%edx
mov    0x2660(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x253c(%rip),%rax
mov    %edx,(%rax,%rcx,4)
jmp    1bb9 <slasrt+0xaa9>
mov    0x2642(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2639(%rip)
mov    0x2517(%rip),%edx
add    $0x1,%edx
mov    0x262a(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x2506(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x24ed(%rip),%edx
mov    0x260b(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x24e7(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x25f2(%rip),%eax
add    $0x1,%eax
mov    %eax,0x25e9(%rip)
mov    0x25df(%rip),%edx
mov    0x25dd(%rip),%eax
shl    $0x1,%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x24b9(%rip),%rax
mov    %edx,(%rax,%rcx,4)
mov    0x24a8(%rip),%edx
mov    0x25be(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x249a(%rip),%rax
mov    %edx,(%rax,%rcx,4)
jmp    1bbe <slasrt+0xaae>
jmp    1bc3 <slasrt+0xab3>
jmp    1bc8 <slasrt+0xab8>
cmpl   $0x0,0x2595(%rip)
jle    1bda <slasrt+0xaca>
jmp    122f <slasrt+0x11f>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slasrt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %esi,%r15d
mov    %rdi,%r12
movl   $0x0,(%rcx)
movl   $0xffffffff,0x3006(%rip)
ff ff ff
movsbl (%rdi),%edi
call   1030 <toupper@plt>
mov    %rax,%rbp
mov    $0x44,%edi
call   1030 <toupper@plt>
xor    %ecx,%ecx
cmp    %rax,%rbp
je     117b <slasrt+0x6b>
movsbl (%r12),%edi
call   1030 <toupper@plt>
mov    %rax,%rbp
mov    $0x49,%edi
call   1030 <toupper@plt>
mov    $0x1,%ecx
cmp    %rax,%rbp
jne    14e3 <slasrt+0x3d3>
mov    %ecx,0x2fbf(%rip)
mov    %ecx,%ebp
test   %r15d,%r15d
js     14dc <slasrt+0x3cc>
cmp    $0x2,%r15d
jb     14fa <slasrt+0x3ea>
cmpl   $0x0,(%r14)
jne    14fa <slasrt+0x3ea>
movabs $0xffffffff00000000,%r11
ff ff ff
movabs $0x100000000,%r9
movl   $0x1,0x2e82(%rip)
mov    %r15d,0x2e7f(%rip)
lea    -0x8(%rbx),%r15
mov    $0x1,%r10d
lea    0x2e6a(%rip),%r14
mov    %ebp,0x4(%rsp)
jmp    1210 <slasrt+0x100>
mov    0x8(%rsp),%rax
mov    %ecx,(%r14,%rax,4)
mov    %edx,%r13d
mov    0x4(%rsp),%ebp
mov    %r10d,%esi
add    $0x1,%esi
lea    (%r10,%r10,1),%eax
add    $0x2,%eax
cltq
mov    %r12d,-0x8(%r14,%rax,4)
mov    %r13d,-0x4(%r14,%rax,4)
mov    %esi,%r10d
test   %esi,%esi
jle    14fa <slasrt+0x3ea>
lea    (%r10,%r10,1),%eax
movslq %eax,%rdx
mov    -0x8(%r14,%rdx,4),%r12d
mov    -0x4(%r14,%rdx,4),%r13d
movslq %r12d,%rdi
lea    -0x1(%r10),%esi
mov    %r13d,%eax
sub    %edi,%eax
lea    -0x1(%rax),%ecx
cmp    $0x13,%ecx
ja     12a0 <slasrt+0x190>
test   %ebp,%ebp
je     12e8 <slasrt+0x1d8>
mov    %rdi,%rcx
cmp    %r12d,%r13d
jg     1255 <slasrt+0x145>
jmp    1205 <slasrt+0xf5>
nopw   0x0(%rax,%rax,1)
cmp    %ecx,%r13d
jle    1205 <slasrt+0xf5>
add    $0x1,%rcx
cmp    %ecx,%r12d
jge    1250 <slasrt+0x140>
mov    %rcx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rbx,%rax,4),%xmm1
movss  -0x4(%rbx,%rax,4),%xmm0
ucomiss %xmm0,%xmm1
jbe    1250 <slasrt+0x140>
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  %xmm0,-0x8(%rbx,%rax,4)
lea    -0x1(%rax),%rdx
mov    %rdx,%rax
cmp    %rdi,%rdx
jg     1270 <slasrt+0x160>
jmp    1250 <slasrt+0x140>
nopl   0x0(%rax,%rax,1)
cmp    $0x15,%eax
jl     1205 <slasrt+0xf5>
mov    %rdi,%rax
movslq %r13d,%rcx
add    $0xffffffffffffffff,%rdi
movss  -0x4(%rbx,%rax,4),%xmm1
movss  -0x4(%rbx,%rcx,4),%xmm2
lea    (%r12,%r13,1),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
movss  -0x4(%rbx,%rax,4),%xmm3
ucomiss %xmm1,%xmm2
jbe    134b <slasrt+0x23b>
ucomiss %xmm3,%xmm1
movaps %xmm1,%xmm0
ja     135a <slasrt+0x24a>
minss  %xmm2,%xmm3
jmp    1357 <slasrt+0x247>
cmp    %r12d,%r13d
jle    1205 <slasrt+0xf5>
mov    %rdi,%rcx
jmp    1309 <slasrt+0x1f9>
cs nopw 0x0(%rax,%rax,1)
cmp    %ecx,%r13d
jle    1205 <slasrt+0xf5>
add    $0x1,%rcx
cmp    %ecx,%r12d
jge    1300 <slasrt+0x1f0>
mov    %rcx,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x8(%rbx,%rax,4),%xmm1
movss  -0x4(%rbx,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1300 <slasrt+0x1f0>
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  %xmm0,-0x8(%rbx,%rax,4)
lea    -0x1(%rax),%rdx
mov    %rdx,%rax
cmp    %rdi,%rdx
jg     1320 <slasrt+0x210>
jmp    1300 <slasrt+0x1f0>
ucomiss %xmm3,%xmm2
movaps %xmm2,%xmm0
ja     135a <slasrt+0x24a>
minss  %xmm1,%xmm3
movaps %xmm3,%xmm0
lea    -0x2(%rdx),%rax
add    $0xffffffffffffffff,%rdx
lea    0x1(%r13),%r8d
test   %ebp,%ebp
mov    %rdx,0x10(%rsp)
mov    %rax,0x8(%rsp)
je     140b <slasrt+0x2fb>
nopl   0x0(%rax,%rax,1)
movslq %r8d,%rcx
lea    (%r15,%rcx,4),%rdx
shl    $0x20,%rcx
add    %r11,%rcx
xor    %ebp,%ebp
movss  (%rdx,%rbp,4),%xmm1
add    $0xffffffffffffffff,%rbp
add    %r11,%rcx
ucomiss %xmm0,%xmm1
ja     1390 <slasrt+0x280>
movslq %edi,%rsi
lea    (%rbx,%rsi,4),%rdx
shl    $0x20,%rsi
add    %r11,%rsi
nop
movss  (%rdx),%xmm1
add    %r9,%rsi
add    $0x4,%rdx
add    $0x1,%edi
ucomiss %xmm1,%xmm0
ja     13b0 <slasrt+0x2a0>
mov    %r8d,%edx
lea    (%rdx,%rbp,1),%rax
cmp    %eax,%edi
jge    1496 <slasrt+0x386>
sar    $0x1e,%rsi
sar    $0x1e,%rcx
movss  (%rbx,%rcx,1),%xmm2
movss  %xmm2,(%rbx,%rsi,1)
movss  %xmm1,(%rbx,%rcx,1)
mov    %eax,%r8d
jmp    1380 <slasrt+0x270>
xchg   %ax,%ax
sar    $0x1e,%r14
sar    $0x1e,%rcx
movss  (%rbx,%rcx,1),%xmm2
movss  %xmm2,(%rbx,%r14,1)
movss  %xmm1,(%rbx,%rcx,1)
mov    %edx,%r8d
movslq %r8d,%rcx
lea    (%r15,%rcx,4),%rdx
shl    $0x20,%rcx
add    %r11,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
add    %r11,%rcx
ucomiss (%rdx,%rbp,4),%xmm0
lea    -0x1(%rbp),%rbp
ja     1420 <slasrt+0x310>
movslq %edi,%r14
lea    (%rbx,%r14,4),%rdx
shl    $0x20,%r14
add    %r11,%r14
nopl   0x0(%rax,%rax,1)
movss  (%rdx),%xmm1
add    %r9,%r14
add    $0x4,%rdx
add    $0x1,%edi
ucomiss %xmm0,%xmm1
ja     1440 <slasrt+0x330>
mov    %r8d,%esi
lea    (%rsi,%rbp,1),%rdx
cmp    %edx,%edi
jl     13f0 <slasrt+0x2e0>
lea    (%rsi,%rbp,1),%rcx
add    $0x1,%rcx
add    %rbp,%rsi
mov    %r13d,%eax
sub    %r8d,%eax
sub    %r12d,%r8d
add    %ebp,%r8d
not    %ebp
add    %eax,%ebp
lea    0x2bc0(%rip),%r14
cmp    %ebp,%r8d
jle    14cb <slasrt+0x3bb>
mov    0x10(%rsp),%rax
mov    %esi,(%r14,%rax,4)
mov    %ecx,%r12d
jmp    11e8 <slasrt+0xd8>
lea    (%rdx,%rbp,1),%rcx
add    $0x1,%rcx
add    %rbp,%rdx
mov    %r13d,%eax
sub    %r8d,%eax
sub    %r12d,%r8d
add    %ebp,%r8d
not    %ebp
add    %eax,%ebp
cmp    %ebp,%r8d
jle    11dc <slasrt+0xcc>
mov    0x10(%rsp),%rax
mov    %edx,(%r14,%rax,4)
mov    %ecx,%r12d
jmp    11e8 <slasrt+0xd8>
mov    0x8(%rsp),%rax
mov    %ecx,(%r14,%rax,4)
mov    %esi,%r13d
jmp    11e8 <slasrt+0xd8>
mov    $0xfffffffe,%eax
jmp    14f7 <slasrt+0x3e7>
mov    0x2c57(%rip),%ebp
cmp    $0xffffffff,%ebp
jne    1183 <slasrt+0x73>
mov    $0xffffffff,%eax
mov    %eax,(%r14)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@slasrt.stack = internal unnamed_addr global [64 x i32] zeroinitializer
@slasrt.dir = internal unnamed_addr global i32 0
define void @slasrt(i8* nocapture %0, i32 %1, float* %2, i32* nocapture %3) {
store i32 0, i32* %3
store i32 -1, i32* @slasrt.dir
%5 = load i8, i8* %0
%6 = tail call i64 @toupper(i8 signext %5)
%7 = tail call i64 @toupper(i8 signext 68)
%8 = icmp eq i64 %6, %7
br i1 %8, label %17, label %9
9: ; preds = %4
%10 = load i8, i8* %0
%11 = tail call i64 @toupper(i8 signext %10)
%12 = tail call i64 @toupper(i8 signext 73)
%13 = icmp eq i64 %11, %12
br i1 %13, label %17, label %14
14: ; preds = %9
%15 = load i32, i32* @slasrt.dir
%16 = icmp eq i32 %15, -1
br i1 %16, label %213, label %19
17: ; preds = %9, %4
%18 = phi i32 [ 0, %4 ], [ 1, %9 ]
store i32 %18, i32* @slasrt.dir
br label %19
19: ; preds = %17, %14
%20 = phi i32 [ %15, %14 ], [ %18, %17 ]
%21 = icmp slt i32 %1, 0
br i1 %21, label %213, label %22
22: ; preds = %19
%23 = load i32, i32* %3
%24 = icmp ne i32 %23, 0
%25 = icmp ult i32 %1, 2
%26 = or i1 %25, %24
br i1 %26, label %215, label %27
27: ; preds = %22
store i32 1, i32* getelementptr inbounds ([64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 0)
store i32 %1, i32* getelementptr inbounds ([64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 1)
%28 = icmp eq i32 %20, 0
br label %29
29: ; preds = %210, %27
%30 = phi i32 [ %211, %210 ], [ 1, %27 ]
%31 = shl nuw i32 %30, 1
%32 = add nsw i32 %31, -2
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = add nsw i32 %31, -1
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = add nsw i32 %30, -1
%41 = sub nsw i32 %39, %35
%42 = add i32 %41, -1
%43 = icmp ult i32 %42, 20
br i1 %43, label %44, label %88
44: ; preds = %29
%45 = icmp sgt i32 %39, %35
br i1 %28, label %49, label %46
46: ; preds = %44
br i1 %45, label %47, label %210
47: ; preds = %46
%48 = sext i32 %35 to i64
br label %70
49: ; preds = %44
br i1 %45, label %50, label %210
50: ; preds = %49
%51 = sext i32 %35 to i64
br label %52
52: ; preds = %50, %68
%53 = phi i64 [ %51, %50 ], [ %54, %68 ]
%54 = add nsw i64 %53, 1
%55 = trunc i64 %54 to i32
%56 = icmp slt i32 %35, %55
br i1 %56, label %57, label %68
57: ; preds = %52, %66
%58 = phi i64 [ %59, %66 ], [ %54, %52 ]
%59 = add nsw i64 %58, -1
%60 = getelementptr inbounds float, float* %2, i64 %59
%61 = load float, float* %60
%62 = add nsw i64 %58, -2
%63 = getelementptr inbounds float, float* %2, i64 %62
%64 = load float, float* %63
%65 = fcmp ogt float %61, %64
br i1 %65, label %66, label %68
66: ; preds = %57
store float %64, float* %60
store float %61, float* %63
%67 = icmp sgt i64 %59, %51
br i1 %67, label %57, label %68
68: ; preds = %66, %57, %52
%69 = icmp sgt i32 %39, %55
br i1 %69, label %52, label %210
70: ; preds = %47, %86
%71 = phi i64 [ %48, %47 ], [ %72, %86 ]
%72 = add nsw i64 %71, 1
%73 = trunc i64 %72 to i32
%74 = icmp slt i32 %35, %73
br i1 %74, label %75, label %86
75: ; preds = %70, %84
%76 = phi i64 [ %77, %84 ], [ %72, %70 ]
%77 = add nsw i64 %76, -1
%78 = getelementptr inbounds float, float* %2, i64 %77
%79 = load float, float* %78
%80 = add nsw i64 %76, -2
%81 = getelementptr inbounds float, float* %2, i64 %80
%82 = load float, float* %81
%83 = fcmp olt float %79, %82
br i1 %83, label %84, label %86
84: ; preds = %75
store float %82, float* %78
store float %79, float* %81
%85 = icmp sgt i64 %77, %48
br i1 %85, label %75, label %86
86: ; preds = %84, %75, %70
%87 = icmp sgt i32 %39, %73
br i1 %87, label %70, label %210
88: ; preds = %29
%89 = icmp sgt i32 %41, 20
br i1 %89, label %90, label %210
90: ; preds = %88
%91 = add nsw i32 %35, -1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %2, i64 %92
%94 = load float, float* %93
%95 = add nsw i32 %39, -1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %2, i64 %96
%98 = load float, float* %97
%99 = add nsw i32 %39, %35
%100 = sdiv i32 %99, 2
%101 = add nsw i32 %100, -1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %2, i64 %102
%104 = load float, float* %103
%105 = fcmp olt float %94, %98
br i1 %105, label %106, label %111
106: ; preds = %90
%107 = fcmp olt float %104, %94
br i1 %107, label %116, label %108
108: ; preds = %106
%109 = fcmp olt float %104, %98
%110 = select i1 %109, float %104, float %98
br label %116
111: ; preds = %90
%112 = fcmp olt float %104, %98
br i1 %112, label %116, label %113
113: ; preds = %111
%114 = fcmp olt float %104, %94
%115 = select i1 %114, float %104, float %94
br label %116
116: ; preds = %113, %111, %108, %106
%117 = phi float [ %94, %106 ], [ %110, %108 ], [ %98, %111 ], [ %115, %113 ]
%118 = add nsw i32 %39, 1
br i1 %28, label %119, label %159
119: ; preds = %116, %142
%120 = phi i32 [ %140, %142 ], [ %91, %116 ]
%121 = phi i32 [ %139, %142 ], [ %118, %116 ]
%122 = sext i32 %121 to i64
br label %123
123: ; preds = %123, %119
%124 = phi i64 [ %125, %123 ], [ %122, %119 ]
%125 = add i64 %124, -1
%126 = add nsw i64 %124, -2
%127 = getelementptr inbounds float, float* %2, i64 %126
%128 = load float, float* %127
%129 = fcmp olt float %128, %117
br i1 %129, label %123, label %130
130: ; preds = %123
%131 = sext i32 %120 to i64
br label %132
132: ; preds = %130, %132
%133 = phi i64 [ %131, %130 ], [ %134, %132 ]
%134 = add i64 %133, 1
%135 = getelementptr inbounds float, float* %2, i64 %133
%136 = load float, float* %135
%137 = fcmp ogt float %136, %117
br i1 %137, label %132, label %138
138: ; preds = %132
%139 = trunc i64 %125 to i32
%140 = trunc i64 %134 to i32
%141 = icmp slt i32 %140, %139
br i1 %141, label %142, label %151
142: ; preds = %138
%143 = shl i64 %133, 32
%144 = ashr exact i64 %143, 32
%145 = getelementptr inbounds float, float* %2, i64 %144
%146 = shl i64 %124, 32
%147 = add i64 %146, -8589934592
%148 = ashr exact i64 %147, 32
%149 = getelementptr inbounds float, float* %2, i64 %148
%150 = load float, float* %149
store float %150, float* %145
store float %136, float* %149
br label %119
151: ; preds = %138
%152 = trunc i64 %124 to i32
%153 = trunc i64 %125 to i32
%154 = sub nsw i32 %153, %35
%155 = sub i32 %39, %152
%156 = icmp sgt i32 %154, %155
br i1 %156, label %157, label %158
157: ; preds = %151
store i32 %153, i32* %38
br label %199
158: ; preds = %151
store i32 %152, i32* %34
br label %199
159: ; preds = %116, %182
%160 = phi i32 [ %180, %182 ], [ %91, %116 ]
%161 = phi i32 [ %179, %182 ], [ %118, %116 ]
%162 = sext i32 %161 to i64
br label %163
163: ; preds = %163, %159
%164 = phi i64 [ %165, %163 ], [ %162, %159 ]
%165 = add i64 %164, -1
%166 = add nsw i64 %164, -2
%167 = getelementptr inbounds float, float* %2, i64 %166
%168 = load float, float* %167
%169 = fcmp ogt float %168, %117
br i1 %169, label %163, label %170
170: ; preds = %163
%171 = sext i32 %160 to i64
br label %172
172: ; preds = %170, %172
%173 = phi i64 [ %171, %170 ], [ %174, %172 ]
%174 = add i64 %173, 1
%175 = getelementptr inbounds float, float* %2, i64 %173
%176 = load float, float* %175
%177 = fcmp olt float %176, %117
br i1 %177, label %172, label %178
178: ; preds = %172
%179 = trunc i64 %165 to i32
%180 = trunc i64 %174 to i32
%181 = icmp slt i32 %180, %179
br i1 %181, label %182, label %191
182: ; preds = %178
%183 = shl i64 %173, 32
%184 = ashr exact i64 %183, 32
%185 = getelementptr inbounds float, float* %2, i64 %184
%186 = shl i64 %164, 32
%187 = add i64 %186, -8589934592
%188 = ashr exact i64 %187, 32
%189 = getelementptr inbounds float, float* %2, i64 %188
%190 = load float, float* %189
store float %190, float* %185
store float %176, float* %189
br label %159
191: ; preds = %178
%192 = trunc i64 %164 to i32
%193 = trunc i64 %165 to i32
%194 = sub nsw i32 %193, %35
%195 = sub i32 %39, %192
%196 = icmp sgt i32 %194, %195
br i1 %196, label %197, label %198
197: ; preds = %191
store i32 %193, i32* %38
br label %199
198: ; preds = %191
store i32 %192, i32* %34
br label %199
199: ; preds = %158, %157, %198, %197
%200 = phi i32 [ %192, %197 ], [ %35, %198 ], [ %152, %157 ], [ %35, %158 ]
%201 = phi i32 [ %39, %197 ], [ %193, %198 ], [ %39, %157 ], [ %153, %158 ]
%202 = add nsw i32 %30, 1
%203 = shl i32 %202, 1
%204 = add nsw i32 %203, -2
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 %205
store i32 %200, i32* %206
%207 = add nsw i32 %203, -1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [64 x i32], [64 x i32]* @slasrt.stack, i64 0, i64 %208
store i32 %201, i32* %209
br label %210
210: ; preds = %86, %68, %199, %46, %49, %88
%211 = phi i32 [ %40, %88 ], [ %40, %49 ], [ %40, %46 ], [ %202, %199 ], [ %40, %68 ], [ %40, %86 ]
%212 = icmp sgt i32 %211, 0
br i1 %212, label %29, label %215
213: ; preds = %19, %14
%214 = phi i32 [ -1, %14 ], [ -2, %19 ]
store i32 %214, i32* %3
br label %215
215: ; preds = %210, %213, %22
ret void
}