#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 */

/* Variables and functions */
float fabs(float);
int floor(double);
int slacon_(int *n, float *v, float *x, int *isgn, float *est, int *kase) {
  int c__1 = 1;
  float zero = 0.0;
  float one = 1.0;
  static int jump;
  int jlast;
  int iter;
  float altsgn, estold;
  int i, j;
  float temp;
  extern int isamax_(int *, float *, int *);
  extern float sasum_(int *, float *, int *);
  extern int scopy_(int *, float *, int *, float *, int *);
  if (*kase == 0) {
    for (i = 0; i < *n; ++i) {
      x[i] = 1. / (float)(*n);
    }
    *kase = 1;
    jump = 1;
    return 0;
  }
  switch (jump) {
  case 1:
    goto L20;
  case 2:
    goto L40;
  case 3:
    goto L70;
  case 4:
    goto L110;
  case 5:
    goto L140;
  }
L20:
  if (*n == 1) {
    v[0] = x[0];
    *est = fabs(v[0]);
    goto L150;
  }
  *est = sasum_(n, x, &c__1);
  for (i = 0; i < *n; ++i) {
    x[i] = (x[i] >= 0 ? fabs(one) : -fabs(one));
    isgn[i] = (x[i] >= 0 ? floor(x[i] + .5) : -floor(.5 - x[i]));
  }
  *kase = 2;
  jump = 2;
  return 0;
L40:
  j = isamax_(n, &x[0], &c__1);
  --j;
  iter = 2;
L50:
  for (i = 0; i < *n; ++i)
    x[i] = zero;
  x[j] = one;
  *kase = 1;
  jump = 3;
  return 0;
L70:
  scopy_(n, x, &c__1, v, &c__1);
  estold = *est;
  *est = sasum_(n, v, &c__1);
  for (i = 0; i < *n; ++i)
    if (((x[i] >= 0 ? fabs(one) : -fabs(one)) >= 0
             ? floor((x[i] >= 0 ? fabs(one) : -fabs(one)) + .5)
             : -floor(.5 - (x[i] >= 0 ? fabs(one) : -fabs(one)))) != isgn[i])
      goto L90;
  goto L120;
L90:
  if (*est <= estold)
    goto L120;
  for (i = 0; i < *n; ++i) {
    x[i] = (x[i] >= 0 ? fabs(one) : -fabs(one));
    isgn[i] = (x[i] >= 0 ? floor(x[i] + .5) : -floor(.5 - x[i]));
  }
  *kase = 2;
  jump = 4;
  return 0;
L110:
  jlast = j;
  j = isamax_(n, &x[0], &c__1);
  --j;
  if (x[jlast] != fabs(x[j]) && iter < 5) {
    ++iter;
    goto L50;
  }
L120:
  altsgn = 1.;
  for (i = 1; i <= *n; ++i) {
    x[i - 1] = altsgn * ((float)(i - 1) / (float)(*n - 1) + 1.);
    altsgn = -altsgn;
  }
  *kase = 1;
  jump = 5;
  return 0;
L140:
  temp = sasum_(n, x, &c__1) / (float)(*n * 3) * 2.;
  if (temp > *est) {
    scopy_(n, &x[0], &c__1, &v[0], &c__1);
    *est = temp;
  }
L150:
  *kase = 0;
  return 0;
}


x86 assembly (clang, -O0):
<slacon_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xe76(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1209 <slacon_+0xb9>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    11e9 <slacon_+0x99>
mov    -0x10(%rbp),%rax
cvtsi2ssl (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe52(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11a3 <slacon_+0x53>
mov    -0x38(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,0x2e4f(%rip)
movl   $0x0,-0x4(%rbp)
jmp    190a <slacon_+0x7ba>
mov    0x2e3d(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x68(%rbp)
sub    $0x4,%eax
ja     124e <slacon_+0xfe>
mov    -0x68(%rbp),%rax
lea    0xdf4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1253 <slacon_+0x103>
jmp    13be <slacon_+0x26e>
jmp    144a <slacon_+0x2fa>
jmp    1748 <slacon_+0x5f8>
jmp    1884 <slacon_+0x734>
jmp    1253 <slacon_+0x103>
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jne    128a <slacon_+0x13a>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
call   1040 <fabs@plt>
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
jmp    18f9 <slacon_+0x7a9>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
call   1030 <sasum_@plt>
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    139e <slacon_+0x24e>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12e6 <slacon_+0x196>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x6c(%rbp)
jmp    1302 <slacon_+0x1b2>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1357 <slacon_+0x207>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcca(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,-0x70(%rbp)
jmp    1382 <slacon_+0x232>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xca0(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12aa <slacon_+0x15a>
mov    -0x38(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x2,0x2c9a(%rip)
movl   $0x0,-0x4(%rbp)
jmp    190a <slacon_+0x7ba>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
call   1060 <isamax_@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x4c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1418 <slacon_+0x2c8>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13e9 <slacon_+0x299>
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x3,0x2c0e(%rip)
movl   $0x0,-0x4(%rbp)
jmp    190a <slacon_+0x7ba>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rcx
lea    -0x3c(%rbp),%r8
mov    %r8,%rdx
call   1050 <scopy_@plt>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
call   1030 <sasum_@plt>
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    15fb <slacon_+0x4ab>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     14cb <slacon_+0x37b>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x74(%rbp)
jmp    14e7 <slacon_+0x397>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1563 <slacon_+0x413>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1525 <slacon_+0x3d5>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x78(%rbp)
jmp    1541 <slacon_+0x3f1>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xabe(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,-0x7c(%rbp)
jmp    15cf <slacon_+0x47f>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1590 <slacon_+0x440>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x80(%rbp)
jmp    15ac <slacon_+0x45c>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa53(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     15e8 <slacon_+0x498>
jmp    1600 <slacon_+0x4b0>
jmp    15ed <slacon_+0x49d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    148f <slacon_+0x33f>
jmp    17ce <slacon_+0x67e>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     161b <slacon_+0x4cb>
jmp    17ce <slacon_+0x67e>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1728 <slacon_+0x5d8>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1661 <slacon_+0x511>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x84(%rbp)
ff
jmp    1680 <slacon_+0x530>
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     16db <slacon_+0x58b>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x949(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,-0x88(%rbp)
jmp    1709 <slacon_+0x5b9>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x91c(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1070 <floor@plt>
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1622 <slacon_+0x4d2>
mov    -0x38(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x4,0x2910(%rip)
movl   $0x0,-0x4(%rbp)
jmp    190a <slacon_+0x7ba>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
call   1060 <isamax_@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jne    17b1 <slacon_+0x661>
jp     17b1 <slacon_+0x661>
jmp    17c9 <slacon_+0x679>
cmpl   $0x5,-0x4c(%rbp)
jge    17c9 <slacon_+0x679>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13e2 <slacon_+0x292>
jmp    17ce <slacon_+0x67e>
movss  0x82a(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1864 <slacon_+0x714>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x7f7(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    17e2 <slacon_+0x692>
mov    -0x38(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x5,0x27d4(%rip)
movl   $0x0,-0x4(%rbp)
jmp    190a <slacon_+0x7ba>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x3c(%rbp),%rdx
call   1030 <sasum_@plt>
mov    -0x10(%rbp),%rax
imul   $0x3,(%rax),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x758(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
ucomiss (%rax),%xmm0
jbe    18f4 <slacon_+0x7a4>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rcx
lea    -0x3c(%rbp),%r8
mov    %r8,%rdx
call   1050 <scopy_@plt>
movss  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
jmp    18f9 <slacon_+0x7a9>
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<slacon_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r14
mov    %rdx,%rbx
mov    %rdi,%r15
movl   $0x1,0xc(%rsp)
cmpl   $0x0,(%r9)
je     11ea <slacon_+0x9a>
mov    %r8,%r13
mov    %rcx,%r12
mov    %rsi,%rbp
mov    0x2ec8(%rip),%eax
add    $0xfffffffe,%eax
cmp    $0x3,%eax
ja     1215 <slacon_+0xc5>
lea    0xeb9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <isamax_@plt>
mov    %eax,%ebp
add    $0xffffffff,%ebp
mov    (%r15),%edx
test   %edx,%edx
jle    11ca <slacon_+0x7a>
shl    $0x2,%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movslq %ebp,%rax
movl   $0x3f800000,(%rbx,%rax,4)
movl   $0x1,(%r14)
movl   $0x3,0x2e67(%rip)
jmp    156f <slacon_+0x41f>
mov    (%r15),%eax
test   %eax,%eax
jle    155e <slacon_+0x40e>
cvtsi2ss %eax,%xmm1
movss  0xe1f(%rip),%xmm0
divss  %xmm1,%xmm0
cmp    $0x8,%eax
jae    13b4 <slacon_+0x264>
xor    %ecx,%ecx
jmp    1550 <slacon_+0x400>
cmpl   $0x1,(%r15)
jne    13e5 <slacon_+0x295>
movss  (%rbx),%xmm0
movss  %xmm0,0x0(%rbp)
andps  0xe11(%rip),%xmm0
jmp    13a2 <slacon_+0x252>
mov    %r14,0x10(%rsp)
lea    0xc(%rsp),%r14
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %rbp,%rcx
mov    %r14,%r8
call   1050 <scopy_@plt>
movss  0x0(%r13),%xmm0
movss  %xmm0,0x1c(%rsp)
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    0x10(%rsp),%r14
call   1040 <sasum_@plt>
movss  %xmm0,0x0(%r13)
cmpl   $0x0,(%r15)
jle    1343 <slacon_+0x1f3>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,0x20(%rsp)
movsd  0xd5d(%rip),%xmm0
call   1070 <floor@plt>
mov    %eax,%ecx
neg    %ecx
movss  0x20(%rsp),%xmm0
ucomiss 0xd6b(%rip),%xmm0
cmovae %eax,%ecx
cmp    (%r12,%rbp,4),%ecx
jne    1580 <slacon_+0x430>
add    $0x1,%rbp
movslq (%r15),%rax
cmp    %rax,%rbp
jl     1290 <slacon_+0x140>
jmp    12e7 <slacon_+0x197>
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <isamax_@plt>
mov    (%r15),%eax
test   %eax,%eax
jle    1343 <slacon_+0x1f3>
lea    -0x1(%rax),%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    %eax,%eax
movss  0xd21(%rip),%xmm1
xor    %ecx,%ecx
movsd  0xd0f(%rip),%xmm2
movaps 0xd20(%rip),%xmm3
xorps  %xmm4,%xmm4
cvtsi2ss %ecx,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm1,%xmm5
divss  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm2,%xmm4
mulsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rbx,%rcx,4)
xorps  %xmm3,%xmm1
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1310 <slacon_+0x1c0>
movl   $0x1,(%r14)
movl   $0x5,0x2cf8(%rip)
jmp    156f <slacon_+0x41f>
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1040 <sasum_@plt>
mov    (%r15),%eax
lea    (%rax,%rax,2),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
addss  %xmm0,%xmm0
ucomiss 0x0(%r13),%xmm0
jbe    13a8 <slacon_+0x258>
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %rbp,%rcx
mov    %rdx,%r8
movaps %xmm0,0x20(%rsp)
call   1050 <scopy_@plt>
movaps 0x20(%rsp),%xmm0
movss  %xmm0,0x0(%r13)
movl   $0x0,(%r14)
jmp    156f <slacon_+0x41f>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    1492 <slacon_+0x342>
xor    %edi,%edi
jmp    1511 <slacon_+0x3c1>
mov    %r14,0x10(%rsp)
lea    0xc(%rsp),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1040 <sasum_@plt>
movss  %xmm0,0x0(%r13)
cmpl   $0x0,(%r15)
jle    1478 <slacon_+0x328>
xor    %ebp,%ebp
lea    0xbf9(%rip),%r14
jmp    1447 <slacon_+0x2f7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0xbe8(%rip),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1070 <floor@plt>
neg    %eax
mov    %eax,(%r12,%rbp,4)
add    $0x1,%rbp
movslq (%r15),%rax
cmp    %rax,%rbp
jge    1478 <slacon_+0x328>
movss  (%rbx,%rbp,4),%xmm0
xor    %eax,%eax
ucomiss 0xbcf(%rip),%xmm0
setb   %al
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
cvtss2sd %xmm0,%xmm0
jb     1420 <slacon_+0x2d0>
addsd  0xb9f(%rip),%xmm0
call   1070 <floor@plt>
jmp    1437 <slacon_+0x2e7>
mov    0x10(%rsp),%rax
movl   $0x2,(%rax)
movl   $0x2,0x2bbf(%rip)
jmp    156f <slacon_+0x41f>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups %xmm1,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups %xmm1,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups %xmm1,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups %xmm1,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
movups %xmm1,0x80(%rbx,%rdi,4)
movups %xmm1,0x90(%rbx,%rdi,4)
movups %xmm1,0xa0(%rbx,%rdi,4)
movups %xmm1,0xb0(%rbx,%rdi,4)
movups %xmm1,0xc0(%rbx,%rdi,4)
movups %xmm1,0xd0(%rbx,%rdi,4)
movups %xmm1,0xe0(%rbx,%rdi,4)
movups %xmm1,0xf0(%rbx,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    14a0 <slacon_+0x350>
test   %rdx,%rdx
je     1542 <slacon_+0x3f2>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm1,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1530 <slacon_+0x3e0>
cmp    %rax,%rcx
je     155e <slacon_+0x40e>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1550 <slacon_+0x400>
movl   $0x1,(%r14)
movl   $0x1,0x2add(%rip)
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movss  0x1c(%rsp),%xmm0
ucomiss 0x0(%r13),%xmm0
jae    12e4 <slacon_+0x194>
cmpl   $0x0,(%r15)
jle    15fa <slacon_+0x4aa>
xor    %ebp,%ebp
lea    0xa68(%rip),%r14
jmp    15c9 <slacon_+0x479>
movsd  0xa66(%rip),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1070 <floor@plt>
neg    %eax
mov    %eax,(%r12,%rbp,4)
add    $0x1,%rbp
movslq (%r15),%rax
cmp    %rax,%rbp
jge    15fa <slacon_+0x4aa>
movss  (%rbx,%rbp,4),%xmm0
xor    %eax,%eax
ucomiss 0xa4d(%rip),%xmm0
setb   %al
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
cvtss2sd %xmm0,%xmm0
jb     15a2 <slacon_+0x452>
addsd  0xa1d(%rip),%xmm0
call   1070 <floor@plt>
jmp    15b9 <slacon_+0x469>
mov    0x10(%rsp),%rax
movl   $0x2,(%rax)
movl   $0x4,0x2a3d(%rip)
jmp    156f <slacon_+0x41f>

LLVM IR (-O0):
@slacon_.jump = internal global i32 0
define i32 @slacon_(i32* %0, float* %1, float* %2, i32* %3, float* %4, i32* %5) {
%7 = alloca i32
%8 = alloca i32*
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32*
%12 = alloca float*
%13 = alloca i32*
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca i32
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca i32
%22 = alloca i32
%23 = alloca float
store i32* %0, i32** %8
store float* %1, float** %9
store float* %2, float** %10
store i32* %3, i32** %11
store float* %4, float** %12
store i32* %5, i32** %13
store i32 1, i32* %14
store float 0.000000e+00, float* %15
store float 1.000000e+00, float* %16
%24 = load i32*, i32** %13
%25 = load i32, i32* %24
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %49
27: ; preds = %6
store i32 0, i32* %21
br label %28
28: ; preds = %44, %27
%29 = load i32, i32* %21
%30 = load i32*, i32** %8
%31 = load i32, i32* %30
%32 = icmp slt i32 %29, %31
br i1 %32, label %33, label %47
33: ; preds = %28
%34 = load i32*, i32** %8
%35 = load i32, i32* %34
%36 = sitofp i32 %35 to float
%37 = fpext float %36 to double
%38 = fdiv double 1.000000e+00, %37
%39 = fptrunc double %38 to float
%40 = load float*, float** %10
%41 = load i32, i32* %21
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float %39, float* %43
br label %44
44: ; preds = %33
%45 = load i32, i32* %21
%46 = add nsw i32 %45, 1
store i32 %46, i32* %21
br label %28
47: ; preds = %28
%48 = load i32*, i32** %13
store i32 1, i32* %48
store i32 1, i32* @slacon_.jump
store i32 0, i32* %7
br label %409
49: ; preds = %6
%50 = load i32, i32* @slacon_.jump
switch i32 %50, label %56 [
i32 1, label %51
i32 2, label %52
i32 3, label %53
i32 4, label %54
i32 5, label %55
]
51: ; preds = %49
br label %57
52: ; preds = %49
br label %138
53: ; preds = %49
br label %167
54: ; preds = %49
br label %321
55: ; preds = %49
br label %381
56: ; preds = %49
br label %57
57: ; preds = %56, %51
%58 = load i32*, i32** %8
%59 = load i32, i32* %58
%60 = icmp eq i32 %59, 1
br i1 %60, label %61, label %72
61: ; preds = %57
%62 = load float*, float** %10
%63 = getelementptr inbounds float, float* %62, i64 0
%64 = load float, float* %63
%65 = load float*, float** %9
%66 = getelementptr inbounds float, float* %65, i64 0
store float %64, float* %66
%67 = load float*, float** %9
%68 = getelementptr inbounds float, float* %67, i64 0
%69 = load float, float* %68
%70 = call float @fabs(float %69)
%71 = load float*, float** %12
store float %70, float* %71
br label %407
72: ; preds = %57
%73 = load i32*, i32** %8
%74 = load float*, float** %10
%75 = call float @sasum_(i32* %73, float* %74, i32* %14)
%76 = load float*, float** %12
store float %75, float* %76
store i32 0, i32* %21
br label %77
77: ; preds = %133, %72
%78 = load i32, i32* %21
%79 = load i32*, i32** %8
%80 = load i32, i32* %79
%81 = icmp slt i32 %78, %80
br i1 %81, label %82, label %136
82: ; preds = %77
%83 = load float*, float** %10
%84 = load i32, i32* %21
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
%87 = load float, float* %86
%88 = fcmp oge float %87, 0.000000e+00
br i1 %88, label %89, label %92
89: ; preds = %82
%90 = load float, float* %16
%91 = call float @fabs(float %90)
br label %96
92: ; preds = %82
%93 = load float, float* %16
%94 = call float @fabs(float %93)
%95 = fneg float %94
br label %96
96: ; preds = %92, %89
%97 = phi float [ %91, %89 ], [ %95, %92 ]
%98 = load float*, float** %10
%99 = load i32, i32* %21
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
store float %97, float* %101
%102 = load float*, float** %10
%103 = load i32, i32* %21
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
%106 = load float, float* %105
%107 = fcmp oge float %106, 0.000000e+00
br i1 %107, label %108, label %117
108: ; preds = %96
%109 = load float*, float** %10
%110 = load i32, i32* %21
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = fpext float %113 to double
%115 = fadd double %114, 5.000000e-01
%116 = call i32 @floor(double %115)
br label %127
117: ; preds = %96
%118 = load float*, float** %10
%119 = load i32, i32* %21
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = fpext float %122 to double
%124 = fsub double 5.000000e-01, %123
%125 = call i32 @floor(double %124)
%126 = sub nsw i32 0, %125
br label %127
127: ; preds = %117, %108
%128 = phi i32 [ %116, %108 ], [ %126, %117 ]
%129 = load i32*, i32** %11
%130 = load i32, i32* %21
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %129, i64 %131
store i32 %128, i32* %132
br label %133
133: ; preds = %127
%134 = load i32, i32* %21
%135 = add nsw i32 %134, 1
store i32 %135, i32* %21
br label %77
136: ; preds = %77
%137 = load i32*, i32** %13
store i32 2, i32* %137
store i32 2, i32* @slacon_.jump
store i32 0, i32* %7
br label %409
138: ; preds = %52
%139 = load i32*, i32** %8
%140 = load float*, float** %10
%141 = getelementptr inbounds float, float* %140, i64 0
%142 = call i32 @isamax_(i32* %139, float* %141, i32* %14)
store i32 %142, i32* %22
%143 = load i32, i32* %22
%144 = add nsw i32 %143, -1
store i32 %144, i32* %22
store i32 2, i32* %18
br label %145
145: ; preds = %344, %138
store i32 0, i32* %21
br label %146
146: ; preds = %157, %145
%147 = load i32, i32* %21
%148 = load i32*, i32** %8
%149 = load i32, i32* %148
%150 = icmp slt i32 %147, %149
br i1 %150, label %151, label %160
151: ; preds = %146
%152 = load float, float* %15
%153 = load float*, float** %10
%154 = load i32, i32* %21
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
store float %152, float* %156
br label %157
157: ; preds = %151
%158 = load i32, i32* %21
%159 = add nsw i32 %158, 1
store i32 %159, i32* %21
br label %146
160: ; preds = %146
%161 = load float, float* %16
%162 = load float*, float** %10
%163 = load i32, i32* %22
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
store float %161, float* %165
%166 = load i32*, i32** %13
store i32 1, i32* %166
store i32 3, i32* @slacon_.jump
store i32 0, i32* %7
br label %409
167: ; preds = %53
%168 = load i32*, i32** %8
%169 = load float*, float** %10
%170 = load float*, float** %9
%171 = call i32 @scopy_(i32* %168, float* %169, i32* %14, float* %170, i32* %14)
%172 = load float*, float** %12
%173 = load float, float* %172
store float %173, float* %20
%174 = load i32*, i32** %8
%175 = load float*, float** %9
%176 = call float @sasum_(i32* %174, float* %175, i32* %14)
%177 = load float*, float** %12
store float %176, float* %177
store i32 0, i32* %21
br label %178
178: ; preds = %249, %167
%179 = load i32, i32* %21
%180 = load i32*, i32** %8
%181 = load i32, i32* %180
%182 = icmp slt i32 %179, %181
br i1 %182, label %183, label %252
183: ; preds = %178
%184 = load float*, float** %10
%185 = load i32, i32* %21
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float, float* %184, i64 %186
%188 = load float, float* %187
%189 = fcmp oge float %188, 0.000000e+00
br i1 %189, label %190, label %193
190: ; preds = %183
%191 = load float, float* %16
%192 = call float @fabs(float %191)
br label %197
193: ; preds = %183
%194 = load float, float* %16
%195 = call float @fabs(float %194)
%196 = fneg float %195
br label %197
197: ; preds = %193, %190
%198 = phi float [ %192, %190 ], [ %196, %193 ]
%199 = fcmp oge float %198, 0.000000e+00
br i1 %199, label %200, label %219
200: ; preds = %197
%201 = load float*, float** %10
%202 = load i32, i32* %21
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %201, i64 %203
%205 = load float, float* %204
%206 = fcmp oge float %205, 0.000000e+00
br i1 %206, label %207, label %210
207: ; preds = %200
%208 = load float, float* %16
%209 = call float @fabs(float %208)
br label %214
210: ; preds = %200
%211 = load float, float* %16
%212 = call float @fabs(float %211)
%213 = fneg float %212
br label %214
214: ; preds = %210, %207
%215 = phi float [ %209, %207 ], [ %213, %210 ]
%216 = fpext float %215 to double
%217 = fadd double %216, 5.000000e-01
%218 = call i32 @floor(double %217)
br label %239
219: ; preds = %197
%220 = load float*, float** %10
%221 = load i32, i32* %21
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* %220, i64 %222
%224 = load float, float* %223
%225 = fcmp oge float %224, 0.000000e+00
br i1 %225, label %226, label %229
226: ; preds = %219
%227 = load float, float* %16
%228 = call float @fabs(float %227)
br label %233
229: ; preds = %219
%230 = load float, float* %16
%231 = call float @fabs(float %230)
%232 = fneg float %231
br label %233
233: ; preds = %229, %226
%234 = phi float [ %228, %226 ], [ %232, %229 ]
%235 = fpext float %234 to double
%236 = fsub double 5.000000e-01, %235
%237 = call i32 @floor(double %236)
%238 = sub nsw i32 0, %237
br label %239
239: ; preds = %233, %214
%240 = phi i32 [ %218, %214 ], [ %238, %233 ]
%241 = load i32*, i32** %11
%242 = load i32, i32* %21
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
%246 = icmp ne i32 %240, %245
br i1 %246, label %247, label %248
247: ; preds = %239
br label %253
248: ; preds = %239
br label %249
249: ; preds = %248
%250 = load i32, i32* %21
%251 = add nsw i32 %250, 1
store i32 %251, i32* %21
br label %178
252: ; preds = %178
br label %348
253: ; preds = %247
%254 = load float*, float** %12
%255 = load float, float* %254
%256 = load float, float* %20
%257 = fcmp ole float %255, %256
br i1 %257, label %258, label %259
258: ; preds = %253
br label %348
259: ; preds = %253
store i32 0, i32* %21
br label %260
260: ; preds = %316, %259
%261 = load i32, i32* %21
%262 = load i32*, i32** %8
%263 = load i32, i32* %262
%264 = icmp slt i32 %261, %263
br i1 %264, label %265, label %319
265: ; preds = %260
%266 = load float*, float** %10
%267 = load i32, i32* %21
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %266, i64 %268
%270 = load float, float* %269
%271 = fcmp oge float %270, 0.000000e+00
br i1 %271, label %272, label %275
272: ; preds = %265
%273 = load float, float* %16
%274 = call float @fabs(float %273)
br label %279
275: ; preds = %265
%276 = load float, float* %16
%277 = call float @fabs(float %276)
%278 = fneg float %277
br label %279
279: ; preds = %275, %272
%280 = phi float [ %274, %272 ], [ %278, %275 ]
%281 = load float*, float** %10
%282 = load i32, i32* %21
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds float, float* %281, i64 %283
store float %280, float* %284
%285 = load float*, float** %10
%286 = load i32, i32* %21
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
%289 = load float, float* %288
%290 = fcmp oge float %289, 0.000000e+00
br i1 %290, label %291, label %300
291: ; preds = %279
%292 = load float*, float** %10
%293 = load i32, i32* %21
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %292, i64 %294
%296 = load float, float* %295
%297 = fpext float %296 to double
%298 = fadd double %297, 5.000000e-01
%299 = call i32 @floor(double %298)
br label %310
300: ; preds = %279
%301 = load float*, float** %10
%302 = load i32, i32* %21
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds float, float* %301, i64 %303
%305 = load float, float* %304
%306 = fpext float %305 to double
%307 = fsub double 5.000000e-01, %306
%308 = call i32 @floor(double %307)
%309 = sub nsw i32 0, %308
br label %310
310: ; preds = %300, %291
%311 = phi i32 [ %299, %291 ], [ %309, %300 ]
%312 = load i32*, i32** %11
%313 = load i32, i32* %21
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %312, i64 %314
store i32 %311, i32* %315
br label %316
316: ; preds = %310
%317 = load i32, i32* %21
%318 = add nsw i32 %317, 1
store i32 %318, i32* %21
br label %260
319: ; preds = %260
%320 = load i32*, i32** %13
store i32 2, i32* %320
store i32 4, i32* @slacon_.jump
store i32 0, i32* %7
br label %409
321: ; preds = %54
%322 = load i32, i32* %22
store i32 %322, i32* %17
%323 = load i32*, i32** %8
%324 = load float*, float** %10
%325 = getelementptr inbounds float, float* %324, i64 0
%326 = call i32 @isamax_(i32* %323, float* %325, i32* %14)
store i32 %326, i32* %22
%327 = load i32, i32* %22
%328 = add nsw i32 %327, -1
store i32 %328, i32* %22
%329 = load float*, float** %10
%330 = load i32, i32* %17
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
%333 = load float, float* %332
%334 = load float*, float** %10
%335 = load i32, i32* %22
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %334, i64 %336
%338 = load float, float* %337
%339 = call float @fabs(float %338)
%340 = fcmp une float %333, %339
br i1 %340, label %341, label %347
341: ; preds = %321
%342 = load i32, i32* %18
%343 = icmp slt i32 %342, 5
br i1 %343, label %344, label %347
344: ; preds = %341
%345 = load i32, i32* %18
%346 = add nsw i32 %345, 1
store i32 %346, i32* %18
br label %145
347: ; preds = %341, %321
br label %348
348: ; preds = %347, %258, %252
store float 1.000000e+00, float* %19
store i32 1, i32* %21
br label %349
349: ; preds = %376, %348
%350 = load i32, i32* %21
%351 = load i32*, i32** %8
%352 = load i32, i32* %351
%353 = icmp sle i32 %350, %352
br i1 %353, label %354, label %379
354: ; preds = %349
%355 = load float, float* %19
%356 = fpext float %355 to double
%357 = load i32, i32* %21
%358 = sub nsw i32 %357, 1
%359 = sitofp i32 %358 to float
%360 = load i32*, i32** %8
%361 = load i32, i32* %360
%362 = sub nsw i32 %361, 1
%363 = sitofp i32 %362 to float
%364 = fdiv float %359, %363
%365 = fpext float %364 to double
%366 = fadd double %365, 1.000000e+00
%367 = fmul double %356, %366
%368 = fptrunc double %367 to float
%369 = load float*, float** %10
%370 = load i32, i32* %21
%371 = sub nsw i32 %370, 1
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %369, i64 %372
store float %368, float* %373
%374 = load float, float* %19
%375 = fneg float %374
store float %375, float* %19
br label %376
376: ; preds = %354
%377 = load i32, i32* %21
%378 = add nsw i32 %377, 1
store i32 %378, i32* %21
br label %349
379: ; preds = %349
%380 = load i32*, i32** %13
store i32 1, i32* %380
store i32 5, i32* @slacon_.jump
store i32 0, i32* %7
br label %409
381: ; preds = %55
%382 = load i32*, i32** %8
%383 = load float*, float** %10
%384 = call float @sasum_(i32* %382, float* %383, i32* %14)
%385 = load i32*, i32** %8
%386 = load i32, i32* %385
%387 = mul nsw i32 %386, 3
%388 = sitofp i32 %387 to float
%389 = fdiv float %384, %388
%390 = fpext float %389 to double
%391 = fmul double %390, 2.000000e+00
%392 = fptrunc double %391 to float
store float %392, float* %23
%393 = load float, float* %23
%394 = load float*, float** %12
%395 = load float, float* %394
%396 = fcmp ogt float %393, %395
br i1 %396, label %397, label %406
397: ; preds = %381
%398 = load i32*, i32** %8
%399 = load float*, float** %10
%400 = getelementptr inbounds float, float* %399, i64 0
%401 = load float*, float** %9
%402 = getelementptr inbounds float, float* %401, i64 0
%403 = call i32 @scopy_(i32* %398, float* %400, i32* %14, float* %402, i32* %14)
%404 = load float, float* %23
%405 = load float*, float** %12
store float %404, float* %405
br label %406
406: ; preds = %397, %381
br label %407
407: ; preds = %406, %61
%408 = load i32*, i32** %13
store i32 0, i32* %408
store i32 0, i32* %7
br label %409
409: ; preds = %407, %379, %319, %160, %136, %47
%410 = load i32, i32* %7
ret i32 %410
}

LLVM IR (-O2):
@slacon_.jump = internal unnamed_addr global i32 0
define i32 @slacon_(i32* %0, float* %1, float* %2, i32* nocapture %3, float* nocapture %4, i32* nocapture %5) {
%7 = bitcast float* %2 to i8*
%8 = alloca i32
%9 = bitcast i32* %8 to i8*
store i32 1, i32* %8
%10 = load i32, i32* %5
%11 = icmp eq i32 %10, 0
br i1 %11, label %12, label %101
12: ; preds = %6
%13 = load i32, i32* %0
%14 = icmp sgt i32 %13, 0
br i1 %14, label %15, label %100
15: ; preds = %12
%16 = sitofp i32 %13 to float
%17 = fdiv float 1.000000e+00, %16
%18 = zext i32 %13 to i64
%19 = icmp ult i32 %13, 8
br i1 %19, label %93, label %20
20: ; preds = %15
%21 = and i64 %18, 4294967288
%22 = insertelement <4 x float> poison, float %17, i64 0
%23 = shufflevector <4 x float> %22, <4 x float> poison, <4 x i32> zeroinitializer
%24 = insertelement <4 x float> poison, float %17, i64 0
%25 = shufflevector <4 x float> %24, <4 x float> poison, <4 x i32> zeroinitializer
%26 = add nsw i64 %21, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 7
%30 = icmp ult i64 %26, 56
br i1 %30, label %78, label %31
31: ; preds = %20
%32 = and i64 %28, 4611686018427387896
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %75, %33 ]
%35 = phi i64 [ 0, %31 ], [ %76, %33 ]
%36 = getelementptr inbounds float, float* %2, i64 %34
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> %23, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %25, <4 x float>* %39
%40 = or i64 %34, 8
%41 = getelementptr inbounds float, float* %2, i64 %40
%42 = bitcast float* %41 to <4 x float>*
store <4 x float> %23, <4 x float>* %42
%43 = getelementptr inbounds float, float* %41, i64 4
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> %25, <4 x float>* %44
%45 = or i64 %34, 16
%46 = getelementptr inbounds float, float* %2, i64 %45
%47 = bitcast float* %46 to <4 x float>*
store <4 x float> %23, <4 x float>* %47
%48 = getelementptr inbounds float, float* %46, i64 4
%49 = bitcast float* %48 to <4 x float>*
store <4 x float> %25, <4 x float>* %49
%50 = or i64 %34, 24
%51 = getelementptr inbounds float, float* %2, i64 %50
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %23, <4 x float>* %52
%53 = getelementptr inbounds float, float* %51, i64 4
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %25, <4 x float>* %54
%55 = or i64 %34, 32
%56 = getelementptr inbounds float, float* %2, i64 %55
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %23, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %25, <4 x float>* %59
%60 = or i64 %34, 40
%61 = getelementptr inbounds float, float* %2, i64 %60
%62 = bitcast float* %61 to <4 x float>*
store <4 x float> %23, <4 x float>* %62
%63 = getelementptr inbounds float, float* %61, i64 4
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %25, <4 x float>* %64
%65 = or i64 %34, 48
%66 = getelementptr inbounds float, float* %2, i64 %65
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> %23, <4 x float>* %67
%68 = getelementptr inbounds float, float* %66, i64 4
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %25, <4 x float>* %69
%70 = or i64 %34, 56
%71 = getelementptr inbounds float, float* %2, i64 %70
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %23, <4 x float>* %72
%73 = getelementptr inbounds float, float* %71, i64 4
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %25, <4 x float>* %74
%75 = add nuw i64 %34, 64
%76 = add nuw i64 %35, 8
%77 = icmp eq i64 %76, %32
br i1 %77, label %78, label %33
78: ; preds = %33, %20
%79 = phi i64 [ 0, %20 ], [ %75, %33 ]
%80 = icmp eq i64 %29, 0
br i1 %80, label %91, label %81
81: ; preds = %78, %81
%82 = phi i64 [ %88, %81 ], [ %79, %78 ]
%83 = phi i64 [ %89, %81 ], [ 0, %78 ]
%84 = getelementptr inbounds float, float* %2, i64 %82
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> %23, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> %25, <4 x float>* %87
%88 = add nuw i64 %82, 8
%89 = add i64 %83, 1
%90 = icmp eq i64 %89, %29
br i1 %90, label %91, label %81
91: ; preds = %81, %78
%92 = icmp eq i64 %21, %18
br i1 %92, label %100, label %93
93: ; preds = %15, %91
%94 = phi i64 [ 0, %15 ], [ %21, %91 ]
br label %95
95: ; preds = %93, %95
%96 = phi i64 [ %98, %95 ], [ %94, %93 ]
%97 = getelementptr inbounds float, float* %2, i64 %96
store float %17, float* %97
%98 = add nuw nsw i64 %96, 1
%99 = icmp eq i64 %98, %18
br i1 %99, label %100, label %95
100: ; preds = %95, %91, %12
store i32 1, i32* %5
store i32 1, i32* @slacon_.jump
br label %239
101: ; preds = %6
%102 = load i32, i32* @slacon_.jump
switch i32 %102, label %103 [
i32 5, label %225
i32 2, label %135
i32 3, label %146
i32 4, label %196
]
103: ; preds = %101
%104 = load i32, i32* %0
%105 = icmp eq i32 %104, 1
br i1 %105, label %106, label %109
106: ; preds = %103
%107 = load float, float* %2
store float %107, float* %1
%108 = tail call float @llvm.fabs.f32(float %107)
br label %236
109: ; preds = %103
%110 = call float @sasum_(i32* %0, float* %2, i32* %8)
store float %110, float* %4
%111 = load i32, i32* %0
%112 = icmp sgt i32 %111, 0
br i1 %112, label %113, label %134
113: ; preds = %109, %127
%114 = phi i64 [ %130, %127 ], [ 0, %109 ]
%115 = getelementptr inbounds float, float* %2, i64 %114
%116 = load float, float* %115
%117 = fcmp ult float %116, 0.000000e+00
%118 = select i1 %117, float -1.000000e+00, float 1.000000e+00
store float %118, float* %115
%119 = fpext float %118 to double
br i1 %117, label %123, label %120
120: ; preds = %113
%121 = fadd double %119, 5.000000e-01
%122 = call i32 @floor(double %121)
br label %127
123: ; preds = %113
%124 = fsub double 5.000000e-01, %119
%125 = call i32 @floor(double %124)
%126 = sub nsw i32 0, %125
br label %127
127: ; preds = %123, %120
%128 = phi i32 [ %122, %120 ], [ %126, %123 ]
%129 = getelementptr inbounds i32, i32* %3, i64 %114
store i32 %128, i32* %129
%130 = add nuw nsw i64 %114, 1
%131 = load i32, i32* %0
%132 = sext i32 %131 to i64
%133 = icmp slt i64 %130, %132
br i1 %133, label %113, label %134
134: ; preds = %127, %109
store i32 2, i32* %5
store i32 2, i32* @slacon_.jump
br label %239
135: ; preds = %101
%136 = call i32 @isamax_(i32* %0, float* %2, i32* %8)
%137 = add nsw i32 %136, -1
%138 = load i32, i32* %0
%139 = icmp sgt i32 %138, 0
br i1 %139, label %140, label %143
140: ; preds = %135
%141 = zext i32 %138 to i64
%142 = shl nuw nsw i64 %141, 2
br label %143
143: ; preds = %140, %135
%144 = sext i32 %137 to i64
%145 = getelementptr inbounds float, float* %2, i64 %144
store float 1.000000e+00, float* %145
store i32 1, i32* %5
store i32 3, i32* @slacon_.jump
br label %239
146: ; preds = %101
%147 = call i32 @scopy_(i32* %0, float* %2, i32* %8, float* %1, i32* %8)
%148 = load float, float* %4
%149 = call float @sasum_(i32* %0, float* %1, i32* %8)
store float %149, float* %4
%150 = load i32, i32* %0
%151 = icmp sgt i32 %150, 0
br i1 %151, label %156, label %224
152: ; preds = %156
%153 = load i32, i32* %0
%154 = sext i32 %153 to i64
%155 = icmp slt i64 %167, %154
br i1 %155, label %156, label %200
156: ; preds = %146, %152
%157 = phi i64 [ %167, %152 ], [ 0, %146 ]
%158 = getelementptr inbounds float, float* %2, i64 %157
%159 = load float, float* %158
%160 = fcmp ult float %159, 0.000000e+00
%161 = call i32 @floor(double 1.500000e+00)
%162 = sub nsw i32 0, %161
%163 = select i1 %160, i32 %162, i32 %161
%164 = getelementptr inbounds i32, i32* %3, i64 %157
%165 = load i32, i32* %164
%166 = icmp eq i32 %163, %165
%167 = add nuw nsw i64 %157, 1
br i1 %166, label %152, label %168
168: ; preds = %156
%169 = load float, float* %4
%170 = fcmp ugt float %169, %148
br i1 %170, label %171, label %198
171: ; preds = %168
%172 = load i32, i32* %0
%173 = icmp sgt i32 %172, 0
br i1 %173, label %174, label %195
174: ; preds = %171, %188
%175 = phi i64 [ %191, %188 ], [ 0, %171 ]
%176 = getelementptr inbounds float, float* %2, i64 %175
%177 = load float, float* %176
%178 = fcmp ult float %177, 0.000000e+00
%179 = select i1 %178, float -1.000000e+00, float 1.000000e+00
store float %179, float* %176
%180 = fpext float %179 to double
br i1 %178, label %184, label %181
181: ; preds = %174
%182 = fadd double %180, 5.000000e-01
%183 = call i32 @floor(double %182)
br label %188
184: ; preds = %174
%185 = fsub double 5.000000e-01, %180
%186 = call i32 @floor(double %185)
%187 = sub nsw i32 0, %186
br label %188
188: ; preds = %184, %181
%189 = phi i32 [ %183, %181 ], [ %187, %184 ]
%190 = getelementptr inbounds i32, i32* %3, i64 %175
store i32 %189, i32* %190
%191 = add nuw nsw i64 %175, 1
%192 = load i32, i32* %0
%193 = sext i32 %192 to i64
%194 = icmp slt i64 %191, %193
br i1 %194, label %174, label %195
195: ; preds = %188, %171
store i32 2, i32* %5
store i32 4, i32* @slacon_.jump
br label %239
196: ; preds = %101
%197 = call i32 @isamax_(i32* %0, float* %2, i32* %8)
br label %198
198: ; preds = %168, %196
%199 = load i32, i32* %0
br label %200
200: ; preds = %152, %198
%201 = phi i32 [ %199, %198 ], [ %153, %152 ]
%202 = icmp slt i32 %201, 1
br i1 %202, label %224, label %203
203: ; preds = %200
%204 = add nsw i32 %201, -1
%205 = sitofp i32 %204 to float
%206 = add nuw i32 %201, 1
%207 = zext i32 %206 to i64
br label %208
208: ; preds = %203, %208
%209 = phi i64 [ 1, %203 ], [ %222, %208 ]
%210 = phi float [ 1.000000e+00, %203 ], [ %221, %208 ]
%211 = fpext float %210 to double
%212 = add nsw i64 %209, -1
%213 = trunc i64 %212 to i32
%214 = sitofp i32 %213 to float
%215 = fdiv float %214, %205
%216 = fpext float %215 to double
%217 = fadd double %216, 1.000000e+00
%218 = fmul double %217, %211
%219 = fptrunc double %218 to float
%220 = getelementptr inbounds float, float* %2, i64 %212
store float %219, float* %220
%221 = fneg float %210
%222 = add nuw nsw i64 %209, 1
%223 = icmp eq i64 %222, %207
br i1 %223, label %224, label %208
224: ; preds = %208, %146, %200
store i32 1, i32* %5
store i32 5, i32* @slacon_.jump
br label %239
225: ; preds = %101
%226 = call float @sasum_(i32* %0, float* %2, i32* %8)
%227 = load i32, i32* %0
%228 = mul nsw i32 %227, 3
%229 = sitofp i32 %228 to float
%230 = fdiv float %226, %229
%231 = fmul float %230, 2.000000e+00
%232 = load float, float* %4
%233 = fcmp ogt float %231, %232
br i1 %233, label %234, label %238
234: ; preds = %225
%235 = call i32 @scopy_(i32* %0, float* %2, i32* %8, float* %1, i32* %8)
br label %236
236: ; preds = %106, %234
%237 = phi float [ %231, %234 ], [ %108, %106 ]
store float %237, float* %4
br label %238
238: ; preds = %236, %225
store i32 0, i32* %5
br label %239
239: ; preds = %238, %224, %195, %143, %134, %100
ret i32 0
}