int replex(double *pr, double *shift, int na, double (*func)(), int itmax,
           int maxits, double ftol, double atol, double *fret) {
  static double tiny = (double)1e-15;
  double pgrp[5], p[(5 + 1) * 5], y[5 + 1];
  int lista[5];
  double *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, numgap;
  int ihi, ilo;
  double logsft, olgsft;
  double fp;
  if (!(pshft = (double *)malloc(na * sizeof(double))) ||
      !(gap = (double *)malloc((na - 1) * sizeof(double))) ||
      !(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)))) {
    printf("REPLEX: Error - not enough memory\n");
    return (0);
  }
  y[0] = (*func)(pr);
  fp = y[0];
  printf("Start of downhill simplex: function = %12g\n", fp);
  printf("Point  ");
  for (j = 0; j < na; j++) {
    printf(" %12g ", pr[j]);
  }
  nzero = 0;
  ptr = pshft;
  for (j = 0; j < na; j++) {
    if (shift[j] == (double)0.0) {
      ++nzero;
    }
    *ptr++ = fabs(shift[j]);
  }
  mainit = 0;
  while (1) {
    dsort(pshft, na, inds);
    ptr = gap;
    olgsft = log(*(pshft + *(inds + nzero)));
    for (j = nzero + 1; j < na; j++) {
      logsft = log(*(pshft + *(inds + nzero + j)));
      *ptr++ = logsft - olgsft;
      olgsft = logsft;
    }
    dsort(gap, na - 1, indg);
    igap = 2;
    *ngap = nzero - 1;
    *(ngap + 1) = na - 1;
    for (j = na - 2; j >= nzero; j--) {
      jpos = *(indg + j);
      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 + 1) = na - nzero;
    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) = mingl;
      *(lengrp + nr) = mingr;
      *(nxtgap + j) = nr;
      *(nxtgap + nl) = j;
      maxgap = 0;
      for (k = 1; k <= j; k++) {
        if (*(lengrp + k) > maxgap) {
          maxgap = *(lengrp + k);
        }
      }
      if (maxgap <= 5) {
        numgap = j + 1;
        break;
      }
    }
    j = 0;
    do {
      j = *(nxtgap + j);
      jpos = *(ngap + j);
      ndim = *(lengrp + j);
      for (k = 0; k < ndim; k++) {
        lista[k] = *(inds + jpos - k);
        p[k] = pr[lista[k]];
        pgrp[k] = p[k];
        for (i = 0; i < ndim; i++) {
          p[(k + 1) * ndim + i] = pr[*(inds + jpos - i)];
        }
        p[(k + 1) * ndim + k] += pshft[*(inds + jpos - 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 (!(simplx(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 > 1);
    *fret = y[ilo];
    ++mainit;
    printf("\n\nAfter iteration %6d       function = %12g\n", mainit, *fret);
    printf("Point  ");
    for (j = 0; j < na; j++) {
      printf(" %12g ", pr[j]);
    }
    printf("\nShifts ");
    for (j = 0; j < na; j++) {
      printf(" %12g ", *(pshft + j));
    }
    if (fabs(*fret - fp) * (double)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):
<replex>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x280,%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)
movsd  %xmm0,-0x48(%rbp)
movsd  %xmm1,-0x50(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x1c8(%rbp)
cmp    $0x0,%rax
je     129e <replex+0x12e>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x1d0(%rbp)
cmp    $0x0,%rax
je     129e <replex+0x12e>
movslq -0x2c(%rbp),%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x1e8(%rbp)
cmp    $0x0,%rax
je     129e <replex+0x12e>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x1e0(%rbp)
cmp    $0x0,%rax
je     129e <replex+0x12e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x1f0(%rbp)
cmp    $0x0,%rax
je     129e <replex+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,-0x1f8(%rbp)
cmp    $0x0,%rax
je     129e <replex+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,-0x200(%rbp)
cmp    $0x0,%rax
jne    12b8 <replex+0x148>
lea    0x1d73(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
jmp    2003 <replex+0xe93>
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0x268(%rbp),%xmm0
ff
lea    0x1d50(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x1d6e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    134b <replex+0x1db>
mov    -0x20(%rbp),%rax
movslq -0x21c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1d3f(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    130a <replex+0x19a>
movl   $0x0,-0x22c(%rbp)
mov    -0x1c8(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13f6 <replex+0x286>
mov    -0x28(%rbp),%rax
movslq -0x21c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13ae <replex+0x23e>
jp     13ae <replex+0x23e>
mov    -0x22c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x22c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x21c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1c3b(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x1d8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1d8(%rbp)
movsd  %xmm0,(%rax)
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    136d <replex+0x1fd>
movl   $0x0,-0x240(%rbp)
mov    -0x1c8(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x1e8(%rbp),%rdx
mov    $0x0,%al
call   1060 <dsort@plt>
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1c8(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq -0x22c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1090 <log@plt>
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x22c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14f5 <replex+0x385>
mov    -0x1c8(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq -0x22c(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x21c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1090 <log@plt>
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x258(%rbp),%xmm0
ff
subsd  -0x260(%rbp),%xmm0
ff
mov    -0x1d8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x1d8(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x258(%rbp),%xmm0
ff
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1460 <replex+0x2f0>
mov    -0x1d0(%rbp),%rdi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
mov    -0x1e0(%rbp),%rdx
mov    $0x0,%al
call   1060 <dsort@plt>
movl   $0x2,-0x208(%rbp)
mov    -0x22c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1f0(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1f0(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x22c(%rbp),%eax
jl     163c <replex+0x4cc>
mov    -0x1e0(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x204(%rbp)
movl   $0x1,-0x214(%rbp)
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x208(%rbp),%eax
jge    15f0 <replex+0x480>
mov    -0x204(%rbp),%eax
mov    -0x1f0(%rbp),%rcx
movslq -0x220(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x20c(%rbp)
mov    -0x20c(%rbp),%edi
call   1040 <abs@plt>
cmp    $0x2,%eax
jge    15d7 <replex+0x467>
movl   $0x0,-0x214(%rbp)
jmp    15f0 <replex+0x480>
jmp    15dc <replex+0x46c>
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    1585 <replex+0x415>
cmpl   $0x0,-0x214(%rbp)
je     1623 <replex+0x4b3>
mov    -0x204(%rbp),%edx
mov    -0x1f0(%rbp),%rax
movslq -0x208(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    1628 <replex+0x4b8>
mov    -0x21c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x21c(%rbp)
jmp    1548 <replex+0x3d8>
mov    -0x1f8(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x1f8(%rbp),%rax
movl   $0x0,0x4(%rax)
mov    -0x2c(%rbp),%ecx
sub    -0x22c(%rbp),%ecx
mov    -0x200(%rbp),%rax
mov    %ecx,0x4(%rax)
movl   $0x2,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x208(%rbp),%eax
jge    1897 <replex+0x727>
mov    -0x1f0(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x204(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x22c(%rbp),%eax
mov    %eax,-0x228(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x22c(%rbp),%eax
mov    %eax,-0x224(%rbp)
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x21c(%rbp),%eax
jge    178e <replex+0x61e>
mov    -0x1f0(%rbp),%rax
movslq -0x220(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x204(%rbp),%eax
mov    %eax,-0x20c(%rbp)
cmpl   $0x0,-0x20c(%rbp)
jle    1730 <replex+0x5c0>
mov    -0x20c(%rbp),%eax
cmp    -0x228(%rbp),%eax
jge    172b <replex+0x5bb>
mov    -0x20c(%rbp),%eax
mov    %eax,-0x228(%rbp)
mov    -0x220(%rbp),%eax
mov    %eax,-0x238(%rbp)
jmp    1775 <replex+0x605>
cmpl   $0x0,-0x20c(%rbp)
jge    1770 <replex+0x600>
xor    %eax,%eax
sub    -0x20c(%rbp),%eax
cmp    -0x224(%rbp),%eax
jge    176b <replex+0x5fb>
xor    %eax,%eax
sub    -0x20c(%rbp),%eax
mov    %eax,-0x224(%rbp)
mov    -0x220(%rbp),%eax
mov    %eax,-0x234(%rbp)
jmp    1770 <replex+0x600>
jmp    1775 <replex+0x605>
jmp    177a <replex+0x60a>
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    16c5 <replex+0x555>
mov    -0x224(%rbp),%edx
mov    -0x200(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x228(%rbp),%edx
mov    -0x200(%rbp),%rax
movslq -0x238(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x238(%rbp),%edx
mov    -0x1f8(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x21c(%rbp),%edx
mov    -0x1f8(%rbp),%rax
movslq -0x234(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x23c(%rbp)
movl   $0x1,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x21c(%rbp),%eax
jg     185d <replex+0x6ed>
mov    -0x200(%rbp),%rax
movslq -0x220(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x23c(%rbp),%eax
jle    1844 <replex+0x6d4>
mov    -0x200(%rbp),%rax
movslq -0x220(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x23c(%rbp)
jmp    1849 <replex+0x6d9>
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    17fe <replex+0x68e>
cmpl   $0x5,-0x23c(%rbp)
jg     187e <replex+0x70e>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    1897 <replex+0x727>
jmp    1883 <replex+0x713>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1674 <replex+0x504>
movl   $0x0,-0x21c(%rbp)
mov    -0x1f8(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x21c(%rbp)
mov    -0x1f0(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x204(%rbp)
mov    -0x200(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x230(%rbp)
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x230(%rbp),%eax
jge    1a67 <replex+0x8f7>
mov    -0x1e8(%rbp),%rax
movslq -0x204(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x220(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x220(%rbp),%rax
mov    %ecx,-0x1c0(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  (%rax,%rcx,8),%xmm0
movslq -0x220(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
movslq -0x220(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
movslq -0x220(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
movl   $0x0,-0x218(%rbp)
mov    -0x218(%rbp),%eax
cmp    -0x230(%rbp),%eax
jge    19f8 <replex+0x888>
mov    -0x20(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq -0x204(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x218(%rbp),%rsi
xor    %edx,%edx
sub    %rsi,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x220(%rbp),%eax
add    $0x1,%eax
imul   -0x230(%rbp),%eax
add    -0x218(%rbp),%eax
cltq
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    1983 <replex+0x813>
mov    -0x1c8(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq -0x204(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x220(%rbp),%rsi
xor    %edx,%edx
sub    %rsi,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x220(%rbp),%eax
add    $0x1,%eax
imul   -0x230(%rbp),%eax
add    -0x220(%rbp),%eax
cltq
addsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    18f0 <replex+0x780>
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x230(%rbp),%eax
jge    1b20 <replex+0x9b0>
movl   $0x0,-0x218(%rbp)
mov    -0x218(%rbp),%eax
cmp    -0x230(%rbp),%eax
jge    1aec <replex+0x97c>
mov    -0x220(%rbp),%eax
add    $0x1,%eax
imul   -0x230(%rbp),%eax
add    -0x218(%rbp),%eax
cltq
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x218(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    1a8d <replex+0x91d>
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
mov    -0x220(%rbp),%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    1a71 <replex+0x901>
lea    -0x170(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
mov    -0x230(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x2c(%rbp),%r8d
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
lea    -0x1c0(%rbp),%r9
mov    -0x38(%rbp),%r14
mov    -0x3c(%rbp),%ebx
lea    -0x210(%rbp),%r11
lea    -0x24c(%rbp),%r10
lea    -0x248(%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 <simplx@plt>
cmp    $0x0,%eax
jne    1b9c <replex+0xa2c>
movl   $0x0,-0x14(%rbp)
jmp    2003 <replex+0xe93>
movl   $0x0,-0x220(%rbp)
mov    -0x220(%rbp),%eax
cmp    -0x230(%rbp),%eax
jge    1cf1 <replex+0xb81>
mov    -0x24c(%rbp),%eax
imul   -0x230(%rbp),%eax
add    -0x220(%rbp),%eax
cltq
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
movslq -0x220(%rbp),%rax
subsd  -0x80(%rbp,%rax,8),%xmm0
movaps 0x1416(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x1c8(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c8(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  (%rax,%rcx,8),%xmm1
movsd  0x342c(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  (%rax,%rcx,8),%xmm2
movaps 0x13b5(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ca7 <replex+0xb37>
movsd  0x33f3(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  (%rax,%rcx,8),%xmm1
movaps 0x137c(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x1c8(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24c(%rbp),%eax
imul   -0x230(%rbp),%eax
add    -0x220(%rbp),%eax
cltq
movsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x220(%rbp),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    1ba6 <replex+0xa36>
movslq -0x248(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x268(%rbp),%xmm0
ff
jbe    1d27 <replex+0xbb7>
movslq -0x248(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x268(%rbp)
ff
movslq -0x24c(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x1a0(%rbp)
ff
cmpl   $0x1,-0x21c(%rbp)
jg     18a1 <replex+0x731>
movslq -0x24c(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x240(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x240(%rbp)
mov    -0x240(%rbp),%esi
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
lea    0x12ee(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x12d1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1de8 <replex+0xc78>
mov    -0x20(%rbp),%rax
movslq -0x21c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x12a2(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1da7 <replex+0xc37>
lea    0x12b4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1e44 <replex+0xcd4>
mov    -0x1c8(%rbp),%rax
movslq -0x21c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1246(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1e00 <replex+0xc90>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
subsd  -0x268(%rbp),%xmm1
ff
movaps 0x11a5(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x11a9(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm2
movaps 0x1181(%rip),%xmm3
pand   %xmm3,%xmm2
movsd  -0x268(%rbp),%xmm3
ff
movaps 0x116e(%rip),%xmm4
pand   %xmm4,%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1f08 <replex+0xd98>
mov    -0x1c8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1d0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x14(%rbp)
jmp    2003 <replex+0xe93>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f7f <replex+0xe0f>
mov    -0x1c8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1d0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
movl   $0x2,-0x14(%rbp)
jmp    2003 <replex+0xe93>
mov    -0x240(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1fee <replex+0xe7e>
mov    -0x1c8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1d0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1e0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1f0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x200(%rbp),%rdi
call   1030 <free@plt>
movl   $0x3,-0x14(%rbp)
jmp    2003 <replex+0xe93>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
jmp    1400 <replex+0x290>
mov    -0x14(%rbp),%eax
add    $0x280,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<replex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x288,%rsp
movq   %xmm1,0xd8(%rsp)
movsd  %xmm0,0xe0(%rsp)
mov    %r9d,%ebp
mov    %r8,0x110(%rsp)
mov    %rcx,0x88(%rsp)
mov    %rsi,0x80(%rsp)
mov    %rdi,%r15
mov    %rdx,0x18(%rsp)
movslq %edx,%rbx
lea    0x0(,%rbx,8),%rdi
call   1080 <malloc@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
je     1325 <replex+0x1b5>
lea    -0x8(,%rbx,8),%rdi
ff
call   1080 <malloc@plt>
mov    %rax,0x38(%rsp)
test   %rax,%rax
je     1325 <replex+0x1b5>
lea    0x0(,%rbx,4),%rdi
call   1080 <malloc@plt>
test   %rax,%rax
je     1325 <replex+0x1b5>
mov    %rax,%r13
lea    -0x1(%rbx),%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
test   %rax,%rax
je     1325 <replex+0x1b5>
mov    %rax,%r14
lea    0x4(,%rbx,4),%rdi
call   1080 <malloc@plt>
test   %rax,%rax
je     1325 <replex+0x1b5>
mov    %rax,%r12
mov    0x18(%rsp),%rcx
mov    %ecx,%eax
shr    $0x1f,%eax
add    %ecx,%eax
sar    %eax
cltq
lea    0x4(,%rax,4),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x10(%rsp)
test   %rax,%rax
je     1325 <replex+0x1b5>
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x28(%rsp)
test   %rax,%rax
je     1325 <replex+0x1b5>
mov    %r15,%rdi
xor    %eax,%eax
call   *0x88(%rsp)
movsd  %xmm0,0x130(%rsp)
lea    0xd7e(%rip),%rdi
movapd %xmm0,0x50(%rsp)
mov    $0x1,%al
call   1050 <printf@plt>
lea    0xd96(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0xc8(%rsp)
mov    $0x0,%edi
test   %eax,%eax
mov    %ebp,0x94(%rsp)
mov    %r14,0x68(%rsp)
jle    1437 <replex+0x2c7>
mov    0xc8(%rsp),%rax
mov    %eax,%ebx
xor    %ebp,%ebp
lea    0xd5c(%rip),%r14
movsd  (%r15,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    12f0 <replex+0x180>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    1345 <replex+0x1d5>
cmp    $0x4,%eax
jae    134c <replex+0x1dc>
xor    %ecx,%ecx
mov    0x8(%rsp),%rax
xor    %edi,%edi
jmp    13f0 <replex+0x280>
lea    0xd5d(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x288,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
jmp    1437 <replex+0x2c7>
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
mov    0x8(%rsp),%rbp
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
lea    0x0(,%rbx,8),%rdx
and    $0xffffffffffffffe0,%rdx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
movapd 0xc85(%rip),%xmm3
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
mov    0x80(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rsi,1),%xmm4
movupd 0x10(%rdi,%rsi,1),%xmm5
movapd %xmm4,%xmm6
cmpeqpd %xmm0,%xmm6
shufps $0xe8,%xmm6,%xmm6
psubd  %xmm6,%xmm2
movapd %xmm5,%xmm6
cmpeqpd %xmm0,%xmm6
shufps $0xe8,%xmm6,%xmm6
psubd  %xmm6,%xmm1
andpd  %xmm3,%xmm4
andpd  %xmm3,%xmm5
movupd %xmm4,0x0(%rbp,%rsi,1)
movupd %xmm5,0x10(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1390 <replex+0x220>
paddd  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %rbx,%rcx
je     1437 <replex+0x2c7>
mov    0x80(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
sub    %rcx,%rbx
xor    %ecx,%ecx
movapd 0xbf7(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rdx,%rcx,8),%xmm1
pxor   %xmm2,%xmm2
cmpeqsd %xmm1,%xmm2
movq   %xmm2,%rsi
sub    %esi,%edi
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1410 <replex+0x2a0>
mov    0x18(%rsp),%rbx
lea    -0x1(%rbx),%eax
mov    %eax,0xa0(%rsp)
mov    %edi,%r14d
lea    0x1(%rdi),%edx
lea    -0x1(%rdi),%eax
mov    %eax,0x9c(%rsp)
lea    -0x2(%rbx),%eax
mov    %ebx,%ecx
sub    %edi,%ecx
mov    %ecx,0x24(%rsp)
mov    %eax,0x98(%rsp)
cltq
mov    %rax,0xf8(%rsp)
mov    %rdi,0x108(%rsp)
movslq %edi,%rax
mov    %rax,0xf0(%rsp)
lea    0x4(%r13,%r14,8),%rax
mov    %rax,0x100(%rsp)
movl   $0x0,0x20(%rsp)
mov    %r13,0x78(%rsp)
mov    %r12,0x70(%rsp)
mov    %r14,0xe8(%rsp)
mov    %rdx,0xd0(%rsp)
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r13,%rdx
xor    %eax,%eax
call   1060 <dsort@plt>
movslq 0x0(%r13,%r14,4),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
call   1090 <log@plt>
mov    0xd0(%rsp),%rcx
cmp    %ebx,%ecx
mov    0x38(%rsp),%rbp
mov    0x100(%rsp),%r14
jge    153d <replex+0x3cd>
mov    %rbx,%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,0x40(%rsp)
movslq (%r14,%rbx,4),%rax
mov    0x8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
call   1090 <log@plt>
mov    0xd0(%rsp),%rcx
movapd %xmm0,%xmm1
subsd  0x40(%rsp),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
lea    (%rbx,%rcx,1),%eax
cmp    %r13d,%eax
jl     1500 <replex+0x390>
mov    %rbp,%rdi
mov    0xa0(%rsp),%ebx
mov    %ebx,%esi
mov    0x68(%rsp),%r14
mov    %r14,%rdx
xor    %eax,%eax
call   1060 <dsort@plt>
mov    0x9c(%rsp),%eax
mov    %eax,(%r12)
mov    %ebx,0x4(%r12)
mov    0x98(%rsp),%eax
cmp    0x108(%rsp),%eax
mov    0x28(%rsp),%r13
jge    159c <replex+0x42c>
mov    0x10(%rsp),%rax
movq   $0x1,(%rax)
mov    0x24(%rsp),%eax
mov    %eax,0x4(%r13)
movdqa 0x50(%rsp),%xmm0
jmp    1879 <replex+0x709>
mov    $0x2,%eax
mov    0xf8(%rsp),%rcx
mov    0xf0(%rsp),%r8
jmp    15d6 <replex+0x466>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rdx
mov    %ebx,(%r12,%rdx,4)
add    $0x1,%eax
lea    -0x1(%rcx),%rdx
cmp    %r8,%rcx
mov    %rdx,%rcx
jle    160d <replex+0x49d>
mov    (%r14,%rcx,4),%ebx
test   %eax,%eax
jle    15c0 <replex+0x450>
mov    %eax,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%ebp
sub    (%r12,%rdi,4),%ebp
mov    %ebp,%edx
neg    %edx
cmovs  %ebp,%edx
cmp    $0x2,%edx
jb     15ca <replex+0x45a>
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    15f0 <replex+0x480>
jmp    15c0 <replex+0x450>
mov    0x10(%rsp),%rcx
movq   $0x1,(%rcx)
mov    0x24(%rsp),%ecx
mov    %ecx,0x4(%r13)
cmp    $0x3,%eax
movdqa 0x50(%rsp),%xmm0
jl     1879 <replex+0x709>
mov    %eax,%r8d
mov    $0x3,%r11d
mov    $0x2,%r14d
nop
mov    %r14,%rdx
and    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r14,%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    0x24(%rsp),%ecx
mov    %ecx,%ebp
jmp    16a9 <replex+0x539>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ebp,%ebx
cmovl  %ebx,%ebp
mov    0x34(%rsp),%ebx
cmovl  %edi,%ebx
mov    %ebx,0x34(%rsp)
add    $0x1,%rdi
cmp    %rdi,%r14
je     16d0 <replex+0x560>
mov    (%r12,%rdi,4),%ebx
sub    %eax,%ebx
jg     1690 <replex+0x520>
jns    16a0 <replex+0x530>
neg    %ebx
cmp    %ebx,%ecx
cmovg  %ebx,%ecx
mov    0x30(%rsp),%ebx
cmovg  %edi,%ebx
mov    %ebx,0x30(%rsp)
jmp    16a0 <replex+0x530>
nopw   0x0(%rax,%rax,1)
mov    %ecx,0x0(%r13,%r14,4)
movslq 0x34(%rsp),%rax
mov    %ebp,0x0(%r13,%rax,4)
mov    0x10(%rsp),%rcx
mov    %eax,(%rcx,%r14,4)
movslq 0x30(%rsp),%rax
mov    %r14d,(%rcx,%rax,4)
cmp    $0x8,%r14
jae    1710 <replex+0x5a0>
xor    %eax,%eax
mov    $0x1,%esi
jmp    1850 <replex+0x6e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
test   %r9,%r9
je     1796 <replex+0x626>
nop
movdqu 0x4(%r13,%rbp,4),%xmm2
movdqu 0x14(%r13,%rbp,4),%xmm3
movdqu 0x24(%r13,%rbp,4),%xmm4
movdqu 0x34(%r13,%rbp,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,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1720 <replex+0x5b0>
test   $0x1,%r10b
je     17e2 <replex+0x672>
shl    $0x2,%rbp
or     $0x4,%rbp
movdqu 0x0(%r13,%rbp,1),%xmm2
movdqu 0x10(%r13,%rbp,1),%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
cmp    %rsi,%r14
jne    1839 <replex+0x6c9>
movdqa 0x50(%rsp),%xmm0
jmp    1863 <replex+0x6f3>
or     $0x1,%rsi
movdqa 0x50(%rsp),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rsi,4),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
add    $0x1,%rsi
cmp    %rsi,%r11
jne    1850 <replex+0x6e0>
cmp    $0x6,%eax
jl     1879 <replex+0x709>
add    $0x1,%r14
add    $0x1,%r11
cmp    %r8,%r14
jb     1640 <replex+0x4d0>
xor    %ecx,%ecx
jmp    18bd <replex+0x74d>
nopl   (%rax)
movslq 0xac(%rsp),%rcx
movsd  0x130(%rsp,%rcx,8),%xmm1
maxsd  0x50(%rsp),%xmm1
movsd  0x130(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x130(%rsp)
movapd %xmm1,%xmm0
mov    0xa4(%rsp),%ecx
cmp    $0x1,%ecx
jle    1c72 <replex+0xb02>
movdqa %xmm0,0x50(%rsp)
mov    %ecx,%eax
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,0xa4(%rsp)
cltq
mov    0x0(%r13,%rax,4),%ecx
mov    %rcx,0x40(%rsp)
test   %ecx,%ecx
jle    1b50 <replex+0x9e0>
mov    0x70(%rsp),%rcx
movslq (%rcx,%rax,4),%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%r8
mov    0x40(%rsp),%r14
lea    -0x1(%r14),%r12
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
lea    0x198(%rsp),%rax
lea    (%rax,%r14,8),%rdx
lea    0x0(,%r14,8),%r13
xor    %esi,%esi
mov    0x8(%rsp),%r11
jmp    195a <replex+0x7ea>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r11,%rbp,8),%xmm0
add    %rsi,%rdi
addsd  0x190(%rsp,%rdi,8),%xmm0
movsd  %xmm0,0x190(%rsp,%rdi,8)
add    %r13,%rdx
mov    %r9,%rsi
cmp    %r14,%r9
je     1a10 <replex+0x8a0>
lea    0x0(,%rsi,4),%rax
mov    %r8,%rdi
sub    %rax,%rdi
lea    0x1(%rsi),%r9
movslq (%rdi),%rbp
mov    %ebp,0xb0(%rsp,%rsi,4)
movq   (%r15,%rbp,8),%xmm0
movq   %xmm0,0x190(%rsp,%rsi,8)
movq   %xmm0,0x160(%rsp,%rsi,8)
test   %r12,%r12
je     19d0 <replex+0x860>
mov    %r8,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movslq (%rdi),%rax
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbx,8)
movslq -0x4(%rdi),%rax
movq   (%r15,%rax,8),%xmm0
movq   %xmm0,(%rdx,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffffffffff8,%rdi
cmp    %rbx,%rcx
jne    19a0 <replex+0x830>
jmp    19d2 <replex+0x862>
nopl   (%rax)
xor    %ebx,%ebx
mov    %r9,%rdi
imul   %r14,%rdi
test   $0x1,%r14b
je     1930 <replex+0x7c0>
lea    0x0(,%rbx,4),%r10
mov    %r8,%rax
sub    %r10,%rax
movslq (%rax),%rax
movq   (%r15,%rax,8),%xmm0
add    %rdi,%rbx
movq   %xmm0,0x190(%rsp,%rbx,8)
jmp    1930 <replex+0x7c0>
nopl   0x0(%rax,%rax,1)
mov    %r13,0x118(%rsp)
mov    %r12,0x120(%rsp)
test   %r14d,%r14d
jle    1b50 <replex+0x9e0>
mov    0x40(%rsp),%r12
mov    %r12d,%r14d
and    $0x3,%r14d
mov    %r12d,%ebp
and    $0xfffffffc,%ebp
lea    0x198(%rsp),%rax
lea    (%rax,%r12,8),%r13
add    $0x10,%r13
xor    %ebx,%ebx
jmp    1a7e <replex+0x90e>
nop
mov    %r15,%rdi
xor    %eax,%eax
call   *0x88(%rsp)
movsd  %xmm0,0x130(%rsp,%rbx,8)
add    0x118(%rsp),%r13
mov    0x40(%rsp),%rax
add    %rax,%r12
cmp    %rax,%rbx
je     1b50 <replex+0x9e0>
cmpq   $0x3,0x120(%rsp)
jae    1a90 <replex+0x920>
xor    %eax,%eax
jmp    1afd <replex+0x98d>
nopl   (%rax)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x18(%r13,%rax,8),%xmm0
movslq 0xb0(%rsp,%rax,4),%rcx
movsd  %xmm0,(%r15,%rcx,8)
movsd  -0x10(%r13,%rax,8),%xmm0
movslq 0xb4(%rsp,%rax,4),%rcx
movsd  %xmm0,(%r15,%rcx,8)
movsd  -0x8(%r13,%rax,8),%xmm0
movslq 0xb8(%rsp,%rax,4),%rcx
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x0(%r13,%rax,8),%xmm0
movslq 0xbc(%rsp,%rax,4),%rcx
movsd  %xmm0,(%r15,%rcx,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1aa0 <replex+0x930>
add    $0x1,%rbx
test   %r14,%r14
je     1a50 <replex+0x8e0>
lea    (%rsp,%rax,4),%rcx
add    $0xb0,%rcx
add    %r12,%rax
lea    (%rsp,%rax,8),%rax
add    $0x190,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
movslq (%rcx,%rdx,4),%rsi
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1b30 <replex+0x9c0>
jmp    1a50 <replex+0x8e0>
nopl   (%rax)
sub    $0x8,%rsp
lea    0x198(%rsp),%rdi
lea    0x138(%rsp),%rsi
mov    0x48(%rsp),%rbx
mov    %ebx,%edx
mov    %r15,%rcx
mov    0x20(%rsp),%r8
movsd  0xe8(%rsp),%xmm0
movsd  0xe0(%rsp),%xmm1
lea    0xb8(%rsp),%r9
mov    $0x2,%al
lea    0xb4(%rsp),%rbp
push   %rbp
lea    0xb8(%rsp),%rbp
push   %rbp
lea    0x144(%rsp),%rbp
push   %rbp
push   0x130(%rsp)
push   0xb0(%rsp)
call   1070 <simplx@plt>
add    $0x30,%rsp
test   %eax,%eax
je     1331 <replex+0x1c1>
movslq 0xa8(%rsp),%rax
test   %ebx,%ebx
mov    0x28(%rsp),%r13
mov    0x80(%rsp),%rdi
mov    0x8(%rsp),%rbp
movapd 0x413(%rip),%xmm3
movsd  0x41b(%rip),%xmm4
jle    1880 <replex+0x710>
movslq %ebx,%rcx
imul   %rax,%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x190,%rcx
xor    %edx,%edx
jmp    1c33 <replex+0xac3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
je     1880 <replex+0x710>
movsd  (%rcx,%rdx,8),%xmm0
movapd %xmm0,%xmm2
subsd  0x160(%rsp,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
movslq 0xb0(%rsp,%rdx,4),%rsi
movlpd %xmm2,0x0(%rbp,%rsi,8)
movsd  (%rdi,%rsi,8),%xmm1
andpd  %xmm3,%xmm1
mulsd  %xmm4,%xmm1
ucomisd %xmm2,%xmm1
jbe    1c20 <replex+0xab0>
movsd  %xmm1,0x0(%rbp,%rsi,8)
jmp    1c20 <replex+0xab0>
movapd %xmm1,0x40(%rsp)
movq   0x130(%rsp,%rax,8),%xmm0
mov    0x2c0(%rsp),%rax
movq   %xmm0,(%rax)
mov    0x20(%rsp),%esi
add    $0x1,%esi
lea    0x3b8(%rip),%rdi
mov    %esi,0x20(%rsp)
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x397(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%rsp),%r14
test   %r14d,%r14d
jle    1d2b <replex+0xbbb>
xor    %ebx,%ebx
mov    0xc8(%rsp),%rbp
lea    0x37d(%rip),%r13
nop
movq   (%r15,%rbx,8),%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1cd0 <replex+0xb60>
lea    0x390(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r14d,%r14d
mov    0x70(%rsp),%r12
mov    %rbp,%r14
mov    0x8(%rsp),%rbp
jle    1d3e <replex+0xbce>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movq   0x0(%rbp,%rbx,8),%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1d10 <replex+0xba0>
jmp    1d3e <replex+0xbce>
lea    0x34e(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp),%r12
mov    0x2c0(%rsp),%rax
movsd  (%rax),%xmm2
movapd %xmm2,%xmm0
movapd 0x40(%rsp),%xmm4
subsd  %xmm4,%xmm0
movapd 0x2a0(%rip),%xmm3
andpd  %xmm3,%xmm0
addsd  %xmm0,%xmm0
movapd %xmm2,%xmm1
andpd  %xmm3,%xmm1
andpd  %xmm3,%xmm4
addsd  %xmm1,%xmm4
mulsd  0xe0(%rsp),%xmm4
ucomisd %xmm0,%xmm4
jae    1e16 <replex+0xca6>
movsd  0xd8(%rsp),%xmm0
ucomisd %xmm2,%xmm0
mov    0x68(%rsp),%rbp
mov    0x78(%rsp),%r13
ja     1e64 <replex+0xcf4>
movapd %xmm2,0x50(%rsp)
mov    0x94(%rsp),%eax
cmp    %eax,0x20(%rsp)
mov    0x18(%rsp),%rbx
mov    0xe8(%rsp),%r14
jne    14b4 <replex+0x344>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    $0x3,%eax
jmp    1333 <replex+0x1c3>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%eax
jmp    1333 <replex+0x1c3>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    $0x2,%eax
jmp    1333 <replex+0x1c3>

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

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