int freplex(float *const pr, float *const shift, int na, float (*const func)(),
            int itmax, int maxits, float ftol, float atol, float *const fret) {
  static float tiny = (float)1e-15;
  float pgrp[5], p[(5 + 1) * 5], y[5 + 1];
  int lista[5];
  float *pshft, *gap, *ptr;
  int *indg, *inds, *ngap, *nxtgap, *lengrp;
  int jpos, igap, kgap, iter, good_gap;
  int i, j, k;
  int mingl, mingr;
  int nzero, ndim;
  int nl, nr, maxgap, mainit;
  int numgap;
  int ihi, ilo;
  float logsft, olgsft;
  float fp;
  if (!(pshft = (float *)malloc(na * sizeof(float))) ||
      !(gap = (float *)malloc((na - 1) * sizeof(float))) ||
      !(inds = (int *)malloc(na * sizeof(int))) ||
      !(indg = (int *)malloc((na - 1) * sizeof(int))) ||
      !(ngap = (int *)malloc((na + 1) * sizeof(int))) ||
      !(nxtgap = (int *)malloc((na / 2 + 1) * sizeof(int))) ||
      !(lengrp = (int *)malloc((na / 2 + 1) * sizeof(int)))) {
    free(pshft);
    free(gap);
    free(inds);
    free(indg);
    free(nxtgap);
    free(ngap);
    free(lengrp);
    printf("REPLEX: Error - not enough memory\n");
    return (0);
  }
  y[0] = (*func)(pr);
  fp = y[0];
  nzero = 0;
  for (j = 0; j < na; j++) {
    if (shift[j] == (float)0.0) {
      ++nzero;
    }
    ptr = pshft;
    *(pshft + j) = fabs(shift[j]);
  }
  if (nzero == na) {
    free(pshft);
    free(gap);
    free(inds);
    free(indg);
    free(nxtgap);
    free(ngap);
    free(lengrp);
    printf("REPLEX: Warning - no non-zero shifts\n");
    return (0);
  }
  mainit = 0;
  while (1) {
    dsort(pshft, na, inds);
    olgsft = log(*(pshft + *(inds + nzero)));
    for (j = nzero + 1; j < na; j++) {
      logsft = log(*(pshft + *(inds + j)));
      *(gap + j - nzero - 1) = logsft - olgsft;
      olgsft = logsft;
    }
    igap = 2;
    *ngap = nzero - 1;
    *(ngap + 1) = na - 1;
    if (na - nzero >= 2 * 2) {
      dsort(gap, (na - nzero - 1), indg);
      for (j = na - nzero - 2; j >= 0; j--) {
        jpos = *(indg + j) + nzero;
        good_gap = 1;
        for (k = 0; k < igap; k++) {
          kgap = jpos - *(ngap + k);
          if (abs(kgap) < 2) {
            good_gap = 0;
            break;
          }
        }
        if (good_gap) {
          *(ngap + igap) = jpos;
          igap++;
        }
      }
    }
    *nxtgap = 1;
    *(nxtgap + 1) = 0;
    *lengrp = na - nzero;
    *(lengrp + 1) = 0;
    for (j = 2; j < igap; j++) {
      jpos = *(ngap + j);
      mingr = na - nzero;
      mingl = na - nzero;
      for (k = 0; k < j; k++) {
        kgap = *(ngap + k) - jpos;
        if (kgap > 0) {
          if (kgap < mingr) {
            mingr = kgap;
            nr = k;
          }
        } else if (kgap < 0) {
          if (-kgap < mingl) {
            mingl = -kgap;
            nl = k;
          }
        }
      }
      *(lengrp + j) = mingr;
      *(lengrp + nl) = mingl;
      *(nxtgap + j) = nr;
      *(nxtgap + nl) = j;
      maxgap = 0;
      for (k = 0; k <= j; k++) {
        if (*(lengrp + k) > maxgap) {
          maxgap = *(lengrp + k);
        }
      }
      if (maxgap <= 5) {
        break;
      }
    }
    j = 0;
    do {
      jpos = *(ngap + j);
      ndim = *(lengrp + j);
      for (k = 0; k < ndim; k++) {
        lista[k] = *(inds + jpos + k + 1);
        p[k] = pr[lista[k]];
        pgrp[k] = p[k];
        for (i = 0; i < ndim; i++) {
          p[(k + 1) * ndim + i] = pr[*(inds + jpos + i + 1)];
        }
        p[(k + 1) * ndim + k] += pshft[lista[k]];
      }
      for (k = 0; k < ndim; k++) {
        for (i = 0; i < ndim; i++) {
          pr[lista[i]] = p[(k + 1) * ndim + i];
        }
        y[k + 1] = (*func)(pr);
      }
      if (!(fsimplex(p, y, ndim, pr, na, ftol, atol, lista, func, itmax, &iter,
                     &ilo, &ihi))) {
        return (0);
      }
      for (k = 0; k < ndim; k++) {
        *(pshft + lista[k]) = fabs(p[ilo * ndim + k] - pgrp[k]);
        if (*(pshft + lista[k]) < tiny * fabs(shift[lista[k]])) {
          *(pshft + lista[k]) = tiny * fabs(shift[lista[k]]);
        }
        pr[lista[k]] = p[ilo * ndim + k];
      }
      if (y[ihi] > fp) {
        fp = y[ihi];
      }
      y[0] = y[ilo];
    } while ((j = *(nxtgap + j)) > 1);
    *fret = y[ilo];
    ++mainit;
    if (fabs(*fret - fp) * (float)2. <= ftol * (fabs(*fret) + fabs(fp))) {
      free(pshft);
      free(gap);
      free(inds);
      free(indg);
      free(nxtgap);
      free(ngap);
      free(lengrp);
      return (1);
    }
    if (*fret < atol) {
      free(pshft);
      free(gap);
      free(inds);
      free(indg);
      free(nxtgap);
      free(ngap);
      free(lengrp);
      return (2);
    }
    if (mainit == maxits) {
      free(pshft);
      free(gap);
      free(inds);
      free(indg);
      free(nxtgap);
      free(ngap);
      free(lengrp);
      return (3);
    }
    fp = *fret;
  }
}


x86 assembly (clang, -O0):
<freplex>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x1d0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %edx,-0x2c(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8d,-0x3c(%rbp)
mov    %r9d,-0x40(%rbp)
movss  %xmm0,-0x44(%rbp)
movss  %xmm1,-0x48(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x128(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x130(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x148(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x140(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x150(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x158(%rbp)
cmp    $0x0,%rax
je     129e <freplex+0x12e>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x160(%rbp)
cmp    $0x0,%rax
jne    130c <freplex+0x19c>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
lea    0xd1f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x1b8(%rbp)
ff
movl   $0x0,-0x18c(%rbp)
movl   $0x0,-0x17c(%rbp)
mov    -0x17c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13dc <freplex+0x26c>
mov    -0x28(%rbp),%rax
movslq -0x17c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1384 <freplex+0x214>
jp     1384 <freplex+0x214>
mov    -0x18c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18c(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x17c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xc53(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x128(%rbp),%rax
movslq -0x17c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    1344 <freplex+0x1d4>
mov    -0x18c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1459 <freplex+0x2e9>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
lea    0xbf5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
movl   $0x0,-0x1a0(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x148(%rbp),%rdx
mov    $0x0,%al
call   1060 <dsort@plt>
mov    -0x128(%rbp),%rax
mov    -0x148(%rbp),%rcx
movslq -0x18c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <log@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1b4(%rbp)
ff
mov    -0x18c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
mov    -0x17c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    155a <freplex+0x3ea>
mov    -0x128(%rbp),%rax
mov    -0x148(%rbp),%rcx
movslq -0x17c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <log@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1b0(%rbp)
ff
movss  -0x1b0(%rbp),%xmm0
ff
subss  -0x1b4(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rax
movslq -0x17c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x18c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
movss  %xmm0,-0x4(%rax,%rcx,4)
movss  -0x1b0(%rbp),%xmm0
ff
movss  %xmm0,-0x1b4(%rbp)
ff
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    14bd <freplex+0x34d>
movl   $0x2,-0x168(%rbp)
mov    -0x18c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x150(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x150(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%eax
sub    -0x18c(%rbp),%eax
cmp    $0x4,%eax
jl     16c5 <freplex+0x555>
mov    -0x130(%rbp),%rdi
mov    -0x2c(%rbp),%esi
sub    -0x18c(%rbp),%esi
sub    $0x1,%esi
mov    -0x140(%rbp),%rdx
mov    $0x0,%al
call   1060 <dsort@plt>
mov    -0x2c(%rbp),%eax
sub    -0x18c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x17c(%rbp)
cmpl   $0x0,-0x17c(%rbp)
jl     16c0 <freplex+0x550>
mov    -0x140(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x18c(%rbp),%eax
mov    %eax,-0x164(%rbp)
movl   $0x1,-0x174(%rbp)
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x168(%rbp),%eax
jge    1674 <freplex+0x504>
mov    -0x164(%rbp),%eax
mov    -0x150(%rbp),%rcx
movslq -0x180(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%edi
call   1040 <abs@plt>
cmp    $0x2,%eax
jge    165b <freplex+0x4eb>
movl   $0x0,-0x174(%rbp)
jmp    1674 <freplex+0x504>
jmp    1660 <freplex+0x4f0>
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1609 <freplex+0x499>
cmpl   $0x0,-0x174(%rbp)
je     16a7 <freplex+0x537>
mov    -0x164(%rbp),%edx
mov    -0x150(%rbp),%rax
movslq -0x168(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    16ac <freplex+0x53c>
mov    -0x17c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x17c(%rbp)
jmp    15cb <freplex+0x45b>
jmp    16c5 <freplex+0x555>
mov    -0x158(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x158(%rbp),%rax
movl   $0x0,0x4(%rax)
mov    -0x2c(%rbp),%ecx
sub    -0x18c(%rbp),%ecx
mov    -0x160(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x160(%rbp),%rax
movl   $0x0,0x4(%rax)
movl   $0x2,-0x17c(%rbp)
mov    -0x17c(%rbp),%eax
cmp    -0x168(%rbp),%eax
jge    191e <freplex+0x7ae>
mov    -0x150(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x164(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x18c(%rbp),%eax
mov    %eax,-0x188(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x18c(%rbp),%eax
mov    %eax,-0x184(%rbp)
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x17c(%rbp),%eax
jge    1824 <freplex+0x6b4>
mov    -0x150(%rbp),%rax
movslq -0x180(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x164(%rbp),%eax
mov    %eax,-0x16c(%rbp)
cmpl   $0x0,-0x16c(%rbp)
jle    17c6 <freplex+0x656>
mov    -0x16c(%rbp),%eax
cmp    -0x188(%rbp),%eax
jge    17c1 <freplex+0x651>
mov    -0x16c(%rbp),%eax
mov    %eax,-0x188(%rbp)
mov    -0x180(%rbp),%eax
mov    %eax,-0x198(%rbp)
jmp    180b <freplex+0x69b>
cmpl   $0x0,-0x16c(%rbp)
jge    1806 <freplex+0x696>
xor    %eax,%eax
sub    -0x16c(%rbp),%eax
cmp    -0x184(%rbp),%eax
jge    1801 <freplex+0x691>
xor    %eax,%eax
sub    -0x16c(%rbp),%eax
mov    %eax,-0x184(%rbp)
mov    -0x180(%rbp),%eax
mov    %eax,-0x194(%rbp)
jmp    1806 <freplex+0x696>
jmp    180b <freplex+0x69b>
jmp    1810 <freplex+0x6a0>
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    175b <freplex+0x5eb>
mov    -0x188(%rbp),%edx
mov    -0x160(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x184(%rbp),%edx
mov    -0x160(%rbp),%rax
movslq -0x194(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x198(%rbp),%edx
mov    -0x158(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x17c(%rbp),%edx
mov    -0x158(%rbp),%rax
movslq -0x194(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x19c(%rbp)
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x17c(%rbp),%eax
jg     18f3 <freplex+0x783>
mov    -0x160(%rbp),%rax
movslq -0x180(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x19c(%rbp),%eax
jle    18da <freplex+0x76a>
mov    -0x160(%rbp),%rax
movslq -0x180(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x19c(%rbp)
jmp    18df <freplex+0x76f>
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1894 <freplex+0x724>
cmpl   $0x5,-0x19c(%rbp)
jg     1905 <freplex+0x795>
jmp    191e <freplex+0x7ae>
jmp    190a <freplex+0x79a>
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    170a <freplex+0x59a>
movl   $0x0,-0x17c(%rbp)
mov    -0x150(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x164(%rbp)
mov    -0x160(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x190(%rbp)
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x190(%rbp),%eax
jge    1ab9 <freplex+0x949>
mov    -0x148(%rbp),%rax
movslq -0x164(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x180(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%ecx
movslq -0x180(%rbp),%rax
mov    %ecx,-0x120(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movslq -0x180(%rbp),%rax
movss  %xmm0,-0xe0(%rbp,%rax,4)
ff ff
movslq -0x180(%rbp),%rax
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x180(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
movl   $0x0,-0x178(%rbp)
mov    -0x178(%rbp),%eax
cmp    -0x190(%rbp),%eax
jge    1a60 <freplex+0x8f0>
mov    -0x20(%rbp),%rax
mov    -0x148(%rbp),%rcx
movslq -0x164(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x178(%rbp),%rdx
movslq 0x4(%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x180(%rbp),%eax
add    $0x1,%eax
imul   -0x190(%rbp),%eax
add    -0x178(%rbp),%eax
cltq
movss  %xmm0,-0xe0(%rbp,%rax,4)
ff ff
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    19ef <freplex+0x87f>
mov    -0x128(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
mov    -0x180(%rbp),%eax
add    $0x1,%eax
imul   -0x190(%rbp),%eax
add    -0x180(%rbp),%eax
cltq
addss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xe0(%rbp,%rax,4)
ff ff
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1960 <freplex+0x7f0>
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x190(%rbp),%eax
jge    1b72 <freplex+0xa02>
movl   $0x0,-0x178(%rbp)
mov    -0x178(%rbp),%eax
cmp    -0x190(%rbp),%eax
jge    1b3e <freplex+0x9ce>
mov    -0x180(%rbp),%eax
add    $0x1,%eax
imul   -0x190(%rbp),%eax
add    -0x178(%rbp),%eax
cltq
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x178(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  %xmm0,(%rax,%rcx,4)
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    1adf <freplex+0x96f>
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
mov    -0x180(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x100(%rbp,%rax,4)
ff ff
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1ac3 <freplex+0x953>
lea    -0xe0(%rbp),%rdi
lea    -0x100(%rbp),%rsi
mov    -0x190(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x2c(%rbp),%r8d
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    -0x120(%rbp),%r9
mov    -0x38(%rbp),%r14
mov    -0x3c(%rbp),%ebx
lea    -0x170(%rbp),%r11
lea    -0x1ac(%rbp),%r10
lea    -0x1a8(%rbp),%rax
mov    %r14,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x2,%al
call   1070 <fsimplex@plt>
cmp    $0x0,%eax
jne    1bf6 <freplex+0xa86>
movl   $0x0,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
movl   $0x0,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x190(%rbp),%eax
jge    1d6b <freplex+0xbfb>
mov    -0x1ac(%rbp),%eax
imul   -0x190(%rbp),%eax
add    -0x180(%rbp),%eax
cltq
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x180(%rbp),%rax
subss  -0x60(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x3b8(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x128(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  %xmm0,(%rax,%rcx,4)
mov    -0x128(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  0x23c6(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x347(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1d21 <freplex+0xbb1>
movss  0x2385(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0x306(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x128(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1ac(%rbp),%eax
imul   -0x190(%rbp),%eax
add    -0x180(%rbp),%eax
cltq
movss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x180(%rbp),%rcx
movslq -0x120(%rbp,%rcx,4),%rcx
ff
movss  %xmm0,(%rax,%rcx,4)
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    1c00 <freplex+0xa90>
movslq -0x1a8(%rbp),%rax
movss  -0x100(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0x1b8(%rbp),%xmm0
jbe    1da0 <freplex+0xc30>
movslq -0x1a8(%rbp),%rax
movss  -0x100(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1b8(%rbp)
ff
movslq -0x1ac(%rbp),%rax
movss  -0x100(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x158(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x17c(%rbp)
cmp    $0x1,%eax
jg     1928 <freplex+0x7b8>
movslq -0x1ac(%rbp),%rax
movss  -0x100(%rbp,%rax,4),%xmm0
ff ff
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x1b8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x1e6(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1ea(%rip),%xmm0
mulsd  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x1ba(%rip),%xmm3
pand   %xmm3,%xmm2
movss  -0x1b8(%rbp),%xmm3
ff
cvtss2sd %xmm3,%xmm3
movaps 0x1a3(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1ed3 <freplex+0xd63>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1f49 <freplex+0xdd9>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
mov    -0x1a0(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1fb8 <freplex+0xe48>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
movl   $0x3,-0x14(%rbp)
jmp    1fcd <freplex+0xe5d>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1b8(%rbp)
ff
jmp    1463 <freplex+0x2f3>
mov    -0x14(%rbp),%eax
add    $0x1d0,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<freplex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
movd   %xmm1,0x3c(%rsp)
movss  %xmm0,0x20(%rsp)
mov    %r9d,0x74(%rsp)
mov    %r8,0x140(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,%r12d
mov    %rsi,0xb0(%rsp)
mov    %rdi,%rbp
movslq %edx,%r15
lea    0x0(,%r15,4),%r14
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
lea    -0x4(,%r15,4),%rbx
ff
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r14,%rdi
mov    %r12,%r14
call   1080 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x28(%rsp)
lea    0x4(,%r15,4),%rdi
call   1080 <malloc@plt>
mov    %rax,%r12
mov    %r14d,%eax
shr    $0x1f,%eax
add    %r14d,%eax
sar    %eax
cltq
lea    0x4(,%rax,4),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
je     1282 <freplex+0x112>
mov    %rbx,%rdi
call   1080 <malloc@plt>
test   %rax,%rax
je     1282 <freplex+0x112>
mov    %rax,%r13
mov    %rbp,%rdi
xor    %eax,%eax
call   *0x58(%rsp)
xor    %esi,%esi
movaps %xmm0,%xmm7
movss  %xmm0,0xe0(%rsp)
test   %r14d,%r14d
mov    0x18(%rsp),%rdi
mov    0xb0(%rsp),%rbx
mov    0x30(%rsp),%r15
jle    1375 <freplex+0x205>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    12c8 <freplex+0x158>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1346 <freplex+0x1d6>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
lea    0xd55(%rip),%rdi
jmp    13bc <freplex+0x24c>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    0x0(,%rax,4),%rdx
and    $0xffffffffffffffe0,%rdx
xorps  %xmm0,%xmm0
xor    %esi,%esi
movaps 0xd1b(%rip),%xmm3
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   (%rax)
movups (%rbx,%rsi,1),%xmm4
movups 0x10(%rbx,%rsi,1),%xmm5
movaps %xmm4,%xmm6
cmpeqps %xmm0,%xmm6
psubd  %xmm6,%xmm2
movaps %xmm5,%xmm6
cmpeqps %xmm0,%xmm6
psubd  %xmm6,%xmm1
andps  %xmm3,%xmm4
andps  %xmm3,%xmm5
movups %xmm4,(%rdi,%rsi,1)
movups %xmm5,0x10(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    12f0 <freplex+0x180>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %rax,%rcx
je     1375 <freplex+0x205>
movaps 0xcb3(%rip),%xmm0
nopl   (%rax)
movss  (%rbx,%rcx,4),%xmm1
pxor   %xmm2,%xmm2
cmpeqss %xmm1,%xmm2
movd   %xmm2,%edx
sub    %edx,%esi
andps  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1350 <freplex+0x1e0>
cmp    %r14d,%esi
jne    13d5 <freplex+0x265>
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
lea    0xc7e(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r14),%eax
mov    %eax,0x70(%rsp)
mov    %esi,%ebx
lea    0x1(%rsi),%edx
lea    -0x1(%rsi),%eax
mov    %eax,0x6c(%rsp)
mov    %r14d,%eax
mov    %rsi,0x110(%rsp)
sub    %esi,%eax
lea    -0x1(%rax),%ecx
mov    %ecx,0x64(%rsp)
mov    %rax,0x98(%rsp)
add    $0xfffffffe,%eax
mov    %rax,0x108(%rsp)
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xa8(%rsp)
movss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x138(%rsp)
lea    0x4(%r15),%rax
mov    %rax,0x128(%rsp)
lea    0x4(%r15,%rbx,4),%rax
mov    %rax,0x118(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x120(%rsp)
xor    %eax,%eax
mov    %rdx,0xa0(%rsp)
mov    %r12,0x48(%rsp)
mov    %r13,0x130(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x100(%rsp)
mov    %eax,0x68(%rsp)
movaps %xmm7,0xd0(%rsp)
mov    %r14d,%esi
mov    %rdx,%r12
mov    %r15,%rdx
xor    %eax,%eax
mov    %rdi,%r14
call   1050 <dsort@plt>
movslq (%r15,%rbx,4),%rax
movss  (%r14,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <log@plt>
mov    0x50(%rsp),%r15
cmp    %r15d,%r12d
mov    0x118(%rsp),%r14
mov    0x10(%rsp),%r12
jge    1513 <freplex+0x3a3>
cvtsd2ss %xmm0,%xmm0
xor    %ebx,%ebx
xchg   %ax,%ax
movss  %xmm0,0x20(%rsp)
movslq (%r14,%rbx,4),%rax
mov    0x18(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <log@plt>
cvtsd2ss %xmm0,%xmm0
movaps %xmm0,%xmm1
subss  0x20(%rsp),%xmm1
movss  %xmm1,(%r12,%rbx,4)
add    $0x1,%rbx
mov    0xa0(%rsp),%rax
add    %ebx,%eax
cmp    %r15d,%eax
jl     14d0 <freplex+0x360>
mov    0x6c(%rsp),%eax
mov    0x48(%rsp),%r12
mov    %eax,(%r12)
mov    0x70(%rsp),%eax
mov    %eax,0x4(%r12)
mov    0x98(%rsp),%r14
cmp    $0x3,%r14d
jle    15bd <freplex+0x44d>
mov    0x10(%rsp),%rdi
mov    0x64(%rsp),%esi
mov    0x28(%rsp),%rbx
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <dsort@plt>
mov    %rbx,%r9
mov    $0x2,%r8d
mov    0x108(%rsp),%rcx
mov    0x110(%rsp),%r10
jmp    1586 <freplex+0x416>
xchg   %ax,%ax
movslq %r8d,%rdx
mov    %eax,(%r12,%rdx,4)
add    $0x1,%r8d
lea    -0x1(%rcx),%rax
test   %ecx,%ecx
mov    %rax,%rcx
jle    15e2 <freplex+0x472>
mov    (%r9,%rcx,4),%eax
add    %r10d,%eax
test   %r8d,%r8d
jle    1570 <freplex+0x400>
mov    %r8d,%esi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    %eax,%ebx
sub    (%r12,%rdi,4),%ebx
mov    %ebx,%edx
neg    %edx
cmovs  %ebx,%edx
cmp    $0x2,%edx
jb     157b <freplex+0x40b>
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    15a0 <freplex+0x430>
jmp    1570 <freplex+0x400>
mov    0x8(%rsp),%rax
movq   $0x1,(%rax)
mov    %r14d,0x0(%r13)
movl   $0x0,0x4(%r13)
movaps 0xd0(%rsp),%xmm7
jmp    1830 <freplex+0x6c0>
mov    0x8(%rsp),%rax
movq   $0x1,(%rax)
mov    %r14d,0x0(%r13)
movl   $0x0,0x4(%r13)
cmp    $0x3,%r8d
movaps 0xd0(%rsp),%xmm7
jl     1830 <freplex+0x6c0>
mov    %r8d,%r8d
mov    $0x3,%r11d
mov    $0x2,%r14d
nopl   0x0(%rax,%rax,1)
mov    %r11,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %r11,%rsi
movabs $0x7ffffffffffffff8,%rax
ff ff 7f
and    %rax,%rsi
lea    -0x8(%rsi),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    (%r12,%r14,4),%eax
xor    %edi,%edi
mov    0x98(%rsp),%rbx
mov    %ebx,%edx
mov    %ebx,%r15d
jmp    1689 <freplex+0x519>
nopl   0x0(%rax,%rax,1)
cmp    %edx,%ebx
cmovl  %ebx,%edx
mov    0x44(%rsp),%ebx
cmovl  %edi,%ebx
mov    %ebx,0x44(%rsp)
add    $0x1,%rdi
cmp    %rdi,%r14
je     16b0 <freplex+0x540>
mov    (%r12,%rdi,4),%ebx
sub    %eax,%ebx
jg     1670 <freplex+0x500>
jns    1680 <freplex+0x510>
neg    %ebx
cmp    %ebx,%r15d
cmovg  %ebx,%r15d
mov    0x40(%rsp),%ebx
cmovg  %edi,%ebx
mov    %ebx,0x40(%rsp)
jmp    1680 <freplex+0x510>
nopl   0x0(%rax)
mov    %edx,0x0(%r13,%r14,4)
movslq 0x40(%rsp),%rax
mov    %r15d,0x0(%r13,%rax,4)
mov    0x8(%rsp),%rdx
mov    0x44(%rsp),%edi
mov    %edi,(%rdx,%r14,4)
mov    %r14d,(%rdx,%rax,4)
cmp    $0x8,%r11
jae    16e0 <freplex+0x570>
xor    %esi,%esi
xor    %eax,%eax
jmp    1800 <freplex+0x690>
nop
xorps  %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
test   %r9,%r9
je     1766 <freplex+0x5f6>
xchg   %ax,%ax
movdqu 0x0(%r13,%rax,4),%xmm2
movdqu 0x10(%r13,%rax,4),%xmm3
movdqu 0x20(%r13,%rax,4),%xmm4
movdqu 0x30(%r13,%rax,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    16f0 <freplex+0x580>
test   $0x1,%r10b
je     17aa <freplex+0x63a>
movdqu 0x0(%r13,%rax,4),%xmm2
movdqu 0x10(%r13,%rax,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%eax
jmp    180e <freplex+0x69e>
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rsi,4),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
add    $0x1,%rsi
cmp    %rsi,%r11
jne    1800 <freplex+0x690>
cmp    $0x6,%eax
jl     1830 <freplex+0x6c0>
add    $0x1,%r14
add    $0x1,%r11
cmp    %r8,%r14
jb     1620 <freplex+0x4b0>
nopl   0x0(%rax)
xor    %ecx,%ecx
jmp    1881 <freplex+0x711>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x7c(%rsp),%rcx
movss  0xe0(%rsp,%rcx,4),%xmm0
maxss  %xmm3,%xmm0
movd   0xe0(%rsp,%r8,4),%xmm1
movd   %xmm1,0xe0(%rsp)
mov    0x8(%rsp),%rcx
mov    0xb8(%rsp),%rdx
mov    (%rcx,%rdx,4),%ecx
movaps %xmm0,%xmm7
cmp    $0x1,%ecx
jle    1cac <freplex+0xb3c>
movaps %xmm7,0xd0(%rsp)
mov    %ecx,%eax
mov    %rax,0xb8(%rsp)
mov    0x0(%r13,%rax,4),%r8d
test   %r8d,%r8d
jle    1b80 <freplex+0xa10>
mov    0x48(%rsp),%rax
mov    0xb8(%rsp),%rcx
movslq (%rax,%rcx,4),%rbx
mov    0x128(%rsp),%rax
lea    (%rax,%rbx,4),%rsi
lea    0x0(,%r8,4),%rdx
lea    0x80(%rsp),%rdi
mov    %rsi,0x148(%rsp)
mov    %rdx,0xc8(%rsp)
mov    %r8,0x20(%rsp)
call   1070 <memcpy@plt>
mov    0x20(%rsp),%r8
mov    0x30(%rsp),%rax
lea    (%rax,%rbx,4),%rax
add    $0x4,%rax
mov    %rax,0x150(%rsp)
lea    -0x1(%r8),%rax
mov    %rax,0xc0(%rsp)
mov    %r8d,%r15d
and    $0x3,%r15d
mov    %r8d,%r13d
and    $0xfffffffc,%r13d
mov    0x120(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
lea    0x18c(%rsp),%rax
lea    (%rax,%r8,4),%r12
mov    %r8,%r11
mov    %r12,%rsi
xor    %r14d,%r14d
jmp    197c <freplex+0x80c>
nop
mov    0x18(%rsp),%rax
movss  (%rax,%r9,4),%xmm0
add    %r14,%rbx
addss  0x180(%rsp,%rbx,4),%xmm0
movss  %xmm0,0x180(%rsp,%rbx,4)
add    0xc8(%rsp),%rsi
mov    0x20(%rsp),%r8
add    %r8,%r11
mov    %r10,%r14
cmp    %r8,%r10
je     1a70 <freplex+0x900>
lea    0x1(%r14),%r10
mov    0x150(%rsp),%rax
movslq (%rax,%r14,4),%r9
movss  0x0(%rbp,%r9,4),%xmm0
movss  %xmm0,0x180(%rsp,%r14,4)
movss  %xmm0,0x160(%rsp,%r14,4)
cmpq   $0x3,0xc0(%rsp)
jae    19c0 <freplex+0x850>
xor    %eax,%eax
jmp    1a1b <freplex+0x8ab>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq -0xc(%rcx,%rax,4),%rdx
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rax,4)
movslq -0x8(%rcx,%rax,4),%rdx
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rax,4)
movslq -0x4(%rcx,%rax,4),%rdx
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rax,4)
movslq (%rcx,%rax,4),%rdx
movss  0x0(%rbp,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    19d0 <freplex+0x860>
mov    %r10,%rbx
imul   %r8,%rbx
test   %r15,%r15
je     1940 <freplex+0x7d0>
lea    (%rax,%r11,1),%rdx
lea    (%rsp,%rdx,4),%rdx
add    $0x180,%rdx
mov    0x148(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movslq (%rax,%rdi,4),%r8
movss  0x0(%rbp,%r8,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%r15
jne    1a50 <freplex+0x8e0>
jmp    1940 <freplex+0x7d0>
xchg   %ax,%ax
test   %r8d,%r8d
jle    1b80 <freplex+0xa10>
mov    %r8,%r14
xor    %ebx,%ebx
jmp    1aab <freplex+0x93b>
mov    %rbp,%rdi
xor    %eax,%eax
call   *0x58(%rsp)
movss  %xmm0,0xe0(%rsp,%rbx,4)
add    0xc8(%rsp),%r12
mov    0x20(%rsp),%r8
add    %r8,%r14
cmp    %r8,%rbx
je     1b80 <freplex+0xa10>
cmpq   $0x3,0xc0(%rsp)
jae    1ac0 <freplex+0x950>
xor    %eax,%eax
jmp    1b2c <freplex+0x9bc>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0xc(%r12,%rax,4),%xmm0
movslq 0x80(%rsp,%rax,4),%rcx
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  -0x8(%r12,%rax,4),%xmm0
movslq 0x84(%rsp,%rax,4),%rcx
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  -0x4(%r12,%rax,4),%xmm0
movslq 0x88(%rsp,%rax,4),%rcx
movss  %xmm0,0x0(%rbp,%rcx,4)
movss  (%r12,%rax,4),%xmm0
movslq 0x8c(%rsp,%rax,4),%rcx
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    1ad0 <freplex+0x960>
add    $0x1,%rbx
test   $0x3,%r8b
je     1a80 <freplex+0x910>
lea    (%rsp,%rax,4),%rcx
add    $0x80,%rcx
add    %r14,%rax
lea    (%rsp,%rax,4),%rax
add    $0x180,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
movslq (%rcx,%rdx,4),%rsi
movss  %xmm0,0x0(%rbp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1b60 <freplex+0x9f0>
jmp    1a80 <freplex+0x910>
nopl   (%rax)
sub    $0x8,%rsp
lea    0x188(%rsp),%rdi
lea    0xe8(%rsp),%rsi
mov    %r8d,%edx
mov    %rbp,%rcx
mov    %r8,%r15
mov    0x58(%rsp),%r8
movsd  0xb0(%rsp),%xmm0
movsd  0x140(%rsp),%xmm1
lea    0x88(%rsp),%r9
mov    $0x2,%al
lea    0x84(%rsp),%rbx
push   %rbx
lea    0x88(%rsp),%rbx
push   %rbx
lea    0x174(%rsp),%rbx
push   %rbx
push   0x160(%rsp)
push   0x80(%rsp)
call   1060 <fsimplex@plt>
add    $0x30,%rsp
test   %eax,%eax
je     13c1 <freplex+0x251>
movslq 0x78(%rsp),%r8
test   %r15d,%r15d
mov    0x130(%rsp),%r13
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%rdi
mov    0xb0(%rsp),%rbx
movaps 0xd0(%rsp),%xmm3
movaps 0x3d7(%rip),%xmm4
movsd  0x3df(%rip),%xmm5
jle    1840 <freplex+0x6d0>
mov    %r15,%rax
movslq %eax,%rcx
imul   %r8,%rcx
lea    (%rsp,%rcx,4),%rcx
add    $0x180,%rcx
xor    %edx,%edx
jmp    1c63 <freplex+0xaf3>
movss  %xmm0,0x0(%rbp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
je     1840 <freplex+0x6d0>
movss  (%rcx,%rdx,4),%xmm0
movaps %xmm0,%xmm1
subss  0x160(%rsp,%rdx,4),%xmm1
andps  %xmm4,%xmm1
movslq 0x80(%rsp,%rdx,4),%rsi
movss  %xmm1,(%rdi,%rsi,4)
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movss  (%rbx,%rsi,4),%xmm1
andps  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm5,%xmm1
ucomisd %xmm2,%xmm1
jbe    1c50 <freplex+0xae0>
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdi,%rsi,4)
jmp    1c50 <freplex+0xae0>
movss  0xe0(%rsp,%r8,4),%xmm7
mov    0x230(%rsp),%rax
movss  %xmm7,(%rax)
movaps %xmm7,%xmm1
subss  %xmm0,%xmm1
movaps 0x330(%rip),%xmm2
andps  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
unpcklps %xmm7,%xmm0
andps  %xmm2,%xmm0
cvtps2pd %xmm0,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  %xmm0,%xmm2
mulsd  0xa8(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jae    1d8c <freplex+0xc1c>
movss  0x3c(%rsp),%xmm0
ucomiss %xmm7,%xmm0
mov    0x48(%rsp),%r12
mov    0x30(%rsp),%r15
mov    0x18(%rsp),%rdi
mov    0x50(%rsp),%r14
ja     1dd8 <freplex+0xc68>
mov    0x68(%rsp),%eax
add    $0x1,%eax
cmp    0x74(%rsp),%eax
mov    0x100(%rsp),%rbx
mov    0xa0(%rsp),%rdx
jne    147f <freplex+0x30f>
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    $0x3,%eax
jmp    13c3 <freplex+0x253>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
jmp    13c3 <freplex+0x253>
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    $0x2,%eax
jmp    13c3 <freplex+0x253>

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

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