void amoeba(p, y, ndim, ftol, funk, nfunk) float **p, y[], ftol, (*funk)();
int ndim, *nfunk;
{
  int i, j, ilo, ihi, inhi, mpts = ndim + 1;
  float ytry, ysave, sum, rtol, amotry(), *psum, *vector();
  void nrerror(), free_vector();
  psum = vector(1, ndim);
  *nfunk = 0;
  for (j = 1; j <= ndim; j++) {
    for (i = 1, sum = 0.0; i <= mpts; i++)
      sum += p[i][j];
    psum[j] = sum;
  }
  for (;;) {
    ilo = 1;
    ihi = y[1] > y[2] ? (inhi = 2, 1) : (inhi = 1, 2);
    for (i = 1; i <= mpts; i++) {
      if (y[i] < y[ilo])
        ilo = i;
      if (y[i] > y[ihi]) {
        inhi = ihi;
        ihi = i;
      } else if (y[i] > y[inhi])
        if (i != ihi)
          inhi = i;
    }
    rtol = 2.0 * fabs(y[ihi] - y[ilo]) / (fabs(y[ihi]) + fabs(y[ilo]));
    if (rtol < ftol)
      break;
    if (*nfunk >= 5000)
      nrerror("Too many iterations in AMOEBA");
    ytry = amotry(p, y, psum, ndim, funk, ihi, nfunk, -1.0);
    if (ytry <= y[ilo])
      ytry = amotry(p, y, psum, ndim, funk, ihi, nfunk, 2.0);
    else if (ytry >= y[inhi]) {
      ysave = y[ihi];
      ytry = amotry(p, y, psum, ndim, funk, ihi, nfunk, 0.5);
      if (ytry >= ysave) {
        for (i = 1; i <= mpts; i++) {
          if (i != ilo) {
            for (j = 1; j <= ndim; j++) {
              psum[j] = 0.5 * (p[i][j] + p[ilo][j]);
              p[i][j] = psum[j];
            }
            y[i] = (*funk)(psum);
          }
        }
        *nfunk += ndim;
        for (j = 1; j <= ndim; j++) {
          for (i = 1, sum = 0.0; i <= mpts; i++)
            sum += p[i][j];
          psum[j] = sum;
        }
      }
    }
  }
  free_vector(psum, 1, ndim);
}


x86 assembly (clang, -O0):
<amoeba>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1050 <vector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1205 <amoeba+0xc5>
movl   $0x1,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     11e5 <amoeba+0xa5>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ac <amoeba+0x6c>
movss  -0x4c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1191 <amoeba+0x51>
jmp    120a <amoeba+0xca>
movl   $0x1,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x8(%rax),%xmm0
jbe    123c <amoeba+0xfc>
movl   $0x2,-0x3c(%rbp)
mov    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    124b <amoeba+0x10b>
movl   $0x1,-0x3c(%rbp)
mov    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     130b <amoeba+0x1cb>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    128d <amoeba+0x14d>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    12bd <amoeba+0x17d>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    12f8 <amoeba+0x1b8>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    12f3 <amoeba+0x1b3>
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     12ee <amoeba+0x1ae>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    12f3 <amoeba+0x1b3>
jmp    12f8 <amoeba+0x1b8>
jmp    12fd <amoeba+0x1bd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1258 <amoeba+0x118>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xcd0(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xcd4(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movaps 0xca8(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xc8c(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13a1 <amoeba+0x261>
jmp    1623 <amoeba+0x4e3>
mov    -0x28(%rbp),%rax
cmpl   $0x1388,(%rax)
jl     13bf <amoeba+0x27f>
lea    0xc70(%rip),%rdi
mov    $0x0,%al
call   1030 <nrerror@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x38(%rbp),%r9d
mov    -0x28(%rbp),%rax
movsd  0xc36(%rip),%xmm0
mov    %rax,(%rsp)
mov    $0x1,%al
call   1060 <amotry@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     1445 <amoeba+0x305>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x38(%rbp),%r9d
mov    -0x28(%rbp),%rax
movsd  0xbe0(%rip),%xmm0
mov    %rax,(%rsp)
mov    $0x1,%al
call   1060 <amotry@plt>
movss  %xmm0,-0x44(%rbp)
jmp    161e <amoeba+0x4de>
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     1619 <amoeba+0x4d9>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x38(%rbp),%r9d
mov    -0x28(%rbp),%rax
movsd  0xb8f(%rip),%xmm0
mov    %rax,(%rsp)
mov    $0x1,%al
call   1060 <amotry@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
ucomiss -0x48(%rbp),%xmm0
jb     1614 <amoeba+0x4d4>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1589 <amoeba+0x449>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1576 <amoeba+0x436>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     155d <amoeba+0x41d>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb08(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14d6 <amoeba+0x396>
mov    -0x20(%rbp),%rcx
mov    -0x58(%rbp),%rdi
mov    $0x0,%al
call   *%rcx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    157b <amoeba+0x43b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b7 <amoeba+0x377>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     160f <amoeba+0x4cf>
movl   $0x1,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     15ef <amoeba+0x4af>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15b6 <amoeba+0x476>
movss  -0x4c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    159b <amoeba+0x45b>
jmp    1614 <amoeba+0x4d4>
jmp    1619 <amoeba+0x4d9>
jmp    161e <amoeba+0x4de>
jmp    120a <amoeba+0xca>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1040 <free_vector@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<amoeba>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r8,%rbp
mov    %r8,0x40(%rsp)
mov    %rcx,0x20(%rsp)
movsd  %xmm0,0x48(%rsp)
mov    %edx,%r15d
mov    %rsi,%r13
mov    %rdi,%rbx
mov    $0x1,%edi
mov    %edx,%esi
xor    %eax,%eax
call   1050 <vector@plt>
mov    %rax,%r11
mov    %rax,%r14
movl   $0x0,0x0(%rbp)
test   %r15d,%r15d
jle    1237 <amoeba+0xf7>
lea    0x2(%r15),%r8d
lea    0x1(%r15),%r9d
mov    %r15d,%r10d
lea    0x1(%r10),%rsi
mov    %esi,%edi
and    $0x3,%edi
and    $0xfffffffffffffffc,%rsi
mov    $0x1,%ebp
jmp    11c3 <amoeba+0x83>
movss  %xmm0,(%r11,%rbp,4)
add    $0x1,%rbp
cmp    %r9,%rbp
je     123f <amoeba+0xff>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
cmp    $0x3,%r10d
jb     1215 <amoeba+0xd5>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rax
mov    0x10(%rbx,%rcx,8),%rdx
addss  (%rax,%rbp,4),%xmm0
addss  (%rdx,%rbp,4),%xmm0
mov    0x18(%rbx,%rcx,8),%rax
addss  (%rax,%rbp,4),%xmm0
mov    0x20(%rbx,%rcx,8),%rax
addss  (%rax,%rbp,4),%xmm0
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    11e0 <amoeba+0xa0>
add    $0x1,%rcx
test   %rdi,%rdi
je     11b0 <amoeba+0x70>
lea    (%rbx,%rcx,8),%rcx
xor    %eax,%eax
mov    (%rcx,%rax,8),%rdx
addss  (%rdx,%rbp,4),%xmm0
add    $0x1,%rax
cmp    %rax,%rdi
jne    1220 <amoeba+0xe0>
jmp    11b0 <amoeba+0x70>
lea    0x1(%r15),%r9d
lea    0x2(%r15),%r8d
movsd  0x48(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x54(%rsp)
cmp    $0x2,%r9d
mov    $0x1,%eax
cmovge %r9d,%eax
mov    %rax,0x80(%rsp)
mov    %r8d,%eax
mov    %r9d,%edi
lea    (%r14,%rdi,4),%rcx
mov    %rcx,0x70(%rsp)
add    $0x4,%r14
mov    %r14,0x78(%rsp)
lea    -0x1(%rdi),%rcx
lea    -0x1(%rax),%rdx
mov    %rax,0xa0(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x98(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    0x1(%r8),%rax
mov    %rax,0x60(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x88(%rsp)
mov    %edx,%r12d
and    $0x3,%r12d
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x90(%rsp)
mov    %r11,0x18(%rsp)
mov    %r15,0x28(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r8,0x68(%rsp)
jmp    1329 <amoeba+0x1e9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdx
mov    0x28(%rsp),%r15
mov    %r15d,%ecx
mov    0x20(%rsp),%r8
mov    %r14d,%r9d
movsd  0xd09(%rip),%xmm0
mov    $0x1,%al
call   1060 <amotry@plt>
mov    %rbp,%r11
movss  0x4(%r13),%xmm0
mov    %r15,%rax
xor    %r15d,%r15d
ucomiss 0x8(%r13),%xmm0
seta   %r15b
mov    $0x2,%r14d
sub    %r15d,%r14d
add    $0x1,%r15d
test   %eax,%eax
js     13e0 <amoeba+0x2a0>
mov    $0x1,%ecx
mov    $0x1,%eax
movaps %xmm0,%xmm1
mov    0x80(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
ucomiss %xmm1,%xmm0
mov    %eax,%ebp
ja     1379 <amoeba+0x239>
mov    %ecx,%ebp
movslq %r14d,%rcx
ucomiss 0x0(%r13,%rcx,4),%xmm1
jbe    1390 <amoeba+0x250>
mov    %r14d,%r15d
mov    %eax,%r14d
jmp    13a9 <amoeba+0x269>
nopl   0x0(%rax)
movslq %r15d,%rdx
mov    %r14d,%ecx
cmp    %rcx,%rax
mov    %edx,%ecx
cmovne %eax,%ecx
ucomiss 0x0(%r13,%rdx,4),%xmm1
jbe    13a9 <amoeba+0x269>
mov    %ecx,%r15d
cmp    %rax,%rsi
je     13d0 <amoeba+0x290>
movss  0x4(%r13,%rax,4),%xmm1
movslq %ebp,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
add    $0x1,%rax
mov    %ebp,%ecx
jmp    1370 <amoeba+0x230>
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rax
movss  0x0(%r13,%rax,4),%xmm0
jmp    13e5 <amoeba+0x2a5>
nopl   0x0(%rax)
mov    $0x1,%ebp
movslq %r14d,%rax
movss  0x0(%r13,%rax,4),%xmm1
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movaps 0xc03(%rip),%xmm3
andps  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
unpcklps %xmm0,%xmm1
andps  %xmm3,%xmm1
cvtps2pd %xmm1,%xmm0
addsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  0x54(%rsp),%xmm1
ucomiss %xmm0,%xmm1
ja     17e7 <amoeba+0x6a7>
mov    %rax,0x30(%rsp)
mov    0x40(%rsp),%rax
cmpl   $0x1388,(%rax)
jl     1461 <amoeba+0x321>
lea    0xbec(%rip),%rdi
xor    %eax,%eax
call   1030 <nrerror@plt>
mov    0x40(%rsp),%rax
mov    0x18(%rsp),%r11
movslq %ebp,%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r11,%rdx
mov    0x28(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    %r14d,%r9d
movsd  0xb95(%rip),%xmm0
mov    $0x1,%al
call   1060 <amotry@plt>
mov    0x48(%rsp),%rax
movss  0x0(%r13,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jae    12f0 <amoeba+0x1b0>
movslq %r15d,%rax
ucomiss 0x0(%r13,%rax,4),%xmm0
mov    0x28(%rsp),%r15
mov    0x18(%rsp),%r11
jb     1329 <amoeba+0x1e9>
mov    0x30(%rsp),%rax
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x30(%rsp)
mov    0x40(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r11,%rdx
mov    %r15d,%ecx
mov    0x20(%rsp),%r8
mov    %r14d,%r9d
movsd  0xb39(%rip),%xmm0
mov    $0x1,%al
call   1060 <amotry@plt>
movaps 0xb0b(%rip),%xmm4
movss  0xb2b(%rip),%xmm3
mov    0x38(%rsp),%rdi
mov    0x18(%rsp),%r11
ucomiss 0x30(%rsp),%xmm0
jb     1329 <amoeba+0x1e9>
test   %r15d,%r15d
mov    0x20(%rsp),%r14
js     1714 <amoeba+0x5d4>
mov    %ebp,%eax
mov    $0x1,%ebp
mov    %rax,0x30(%rsp)
jmp    157f <amoeba+0x43f>
xchg   %ax,%ax
mov    %r11,%rdi
xor    %eax,%eax
call   *%r14
movaps 0xac1(%rip),%xmm4
movss  0xae1(%rip),%xmm3
mov    0x38(%rsp),%rdi
mov    0x18(%rsp),%r11
movss  %xmm0,0x0(%r13,%rbp,4)
mov    0x30(%rsp),%rax
add    $0x1,%rbp
cmp    0xa0(%rsp),%rbp
je     1714 <amoeba+0x5d4>
cmp    %rax,%rbp
je     156d <amoeba+0x42d>
test   %r15d,%r15d
jle    1540 <amoeba+0x400>
mov    (%rbx,%rbp,8),%rax
mov    0x48(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
mov    $0x1,%edx
cmpq   $0x8,0x58(%rsp)
jb     1690 <amoeba+0x550>
lea    0x4(%rax),%r10
lea    (%rax,%rdi,4),%r9
lea    0x4(%rcx),%r11
lea    (%rcx,%rdi,4),%rsi
mov    0x78(%rsp),%r8
cmp    %r9,%r8
setb   %r15b
mov    0x70(%rsp),%rdi
cmp    %rdi,%r10
setb   %r14b
cmp    %rsi,%r8
setb   %r8b
cmp    %rdi,%r11
setb   0x17(%rsp)
cmp    %rsi,%r10
setb   %dil
cmp    %r9,%r11
setb   %r9b
test   %r14b,%r15b
jne    1671 <amoeba+0x531>
and    0x17(%rsp),%r8b
mov    0x28(%rsp),%r15
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r11
jne    1680 <amoeba+0x540>
and    %r9b,%dil
mov    0x38(%rsp),%rdi
mov    0x68(%rsp),%rsi
jne    1690 <amoeba+0x550>
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x4(%rax,%rdx,4),%xmm0
movups 0x14(%rax,%rdx,4),%xmm1
movups 0x4(%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,0x4(%r11,%rdx,4)
movups %xmm0,0x14(%r11,%rdx,4)
movups %xmm2,0x4(%rax,%rdx,4)
movups %xmm0,0x14(%rax,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1620 <amoeba+0x4e0>
mov    0x60(%rsp),%rdx
cmp    %rsi,0x58(%rsp)
je     1540 <amoeba+0x400>
jmp    1690 <amoeba+0x550>
mov    0x28(%rsp),%r15
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r11
mov    0x38(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdx,%rsi
test   $0x1,%dil
jne    16b6 <amoeba+0x576>
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r11,%rdx,4)
movss  %xmm0,(%rax,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x88(%rsp),%rdx
je     1540 <amoeba+0x400>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r11,%rsi,4)
movss  %xmm0,(%rax,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
addss  0x4(%rcx,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x4(%r11,%rsi,4)
movss  %xmm0,0x4(%rax,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    16d0 <amoeba+0x590>
jmp    1540 <amoeba+0x400>
mov    0x40(%rsp),%rax
add    %r15d,(%rax)
test   %r15d,%r15d
jle    1329 <amoeba+0x1e9>
mov    $0x1,%eax
jmp    1746 <amoeba+0x606>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,(%r11,%rax,4)
add    $0x1,%rax
cmp    %rdi,%rax
je     1329 <amoeba+0x1e9>
test   %r15d,%r15d
js     1730 <amoeba+0x5f0>
cmpq   $0x3,0x98(%rsp)
jae    1770 <amoeba+0x630>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
test   %r12,%r12
jne    17be <amoeba+0x67e>
jmp    1733 <amoeba+0x5f3>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x90(%rsp),%rbp
nopl   (%rax)
mov    0x8(%rbx,%rcx,8),%rdx
mov    0x10(%rbx,%rcx,8),%rsi
addss  (%rdx,%rax,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
mov    0x18(%rbx,%rcx,8),%rdx
addss  (%rdx,%rax,4),%xmm0
mov    0x20(%rbx,%rcx,8),%rdx
addss  (%rdx,%rax,4),%xmm0
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1780 <amoeba+0x640>
add    $0x1,%rcx
test   %r12,%r12
je     1733 <amoeba+0x5f3>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rcx,%rdx,8),%rsi
addss  (%rsi,%rax,4),%xmm0
add    $0x1,%rdx
cmp    %rdx,%r12
jne    17d0 <amoeba+0x690>
jmp    1733 <amoeba+0x5f3>
mov    %r11,%rdi
mov    $0x1,%esi
mov    0x28(%rsp),%rdx
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>

LLVM IR (-O0):
@.str = [30 x i8] c"Too many iterations in AMOEBA\00"
define void @amoeba(float** %0, float* %1, i32 %2, double %3, float (...)* %4, i32* %5) {
%7 = alloca float**
%8 = alloca float*
%9 = alloca i32
%10 = alloca float
%11 = alloca float (...)*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float*
%24 = fptrunc double %3 to float
store float** %0, float*** %7
store float* %1, float** %8
store i32 %2, i32* %9
store float %24, float* %10
store float (...)* %4, float (...)** %11
store i32* %5, i32** %12
%25 = load i32, i32* %9
%26 = add nsw i32 %25, 1
store i32 %26, i32* %18
%27 = load i32, i32* %9
%28 = call float* (i32, i32, ...) bitcast (float* (...)* @vector to float* (i32, i32, ...)*)(i32 1, i32 %27)
store float* %28, float** %23
%29 = load i32*, i32** %12
store i32 0, i32* %29
store i32 1, i32* %14
br label %30
30: ; preds = %60, %6
%31 = load i32, i32* %14
%32 = load i32, i32* %9
%33 = icmp sle i32 %31, %32
br i1 %33, label %34, label %63
34: ; preds = %30
store i32 1, i32* %13
store float 0.000000e+00, float* %21
br label %35
35: ; preds = %51, %34
%36 = load i32, i32* %13
%37 = load i32, i32* %18
%38 = icmp sle i32 %36, %37
br i1 %38, label %39, label %54
39: ; preds = %35
%40 = load float**, float*** %7
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float*, float** %40, i64 %42
%44 = load float*, float** %43
%45 = load i32, i32* %14
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = load float, float* %21
%50 = fadd float %49, %48
store float %50, float* %21
br label %51
51: ; preds = %39
%52 = load i32, i32* %13
%53 = add nsw i32 %52, 1
store i32 %53, i32* %13
br label %35
54: ; preds = %35
%55 = load float, float* %21
%56 = load float*, float** %23
%57 = load i32, i32* %14
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
store float %55, float* %59
br label %60
60: ; preds = %54
%61 = load i32, i32* %14
%62 = add nsw i32 %61, 1
store i32 %62, i32* %14
br label %30
63: ; preds = %30
br label %64
64: ; preds = %335, %63
store i32 1, i32* %15
%65 = load float*, float** %8
%66 = getelementptr inbounds float, float* %65, i64 1
%67 = load float, float* %66
%68 = load float*, float** %8
%69 = getelementptr inbounds float, float* %68, i64 2
%70 = load float, float* %69
%71 = fcmp ogt float %67, %70
br i1 %71, label %72, label %73
72: ; preds = %64
store i32 2, i32* %17
br label %74
73: ; preds = %64
store i32 1, i32* %17
br label %74
74: ; preds = %73, %72
%75 = phi i32 [ 1, %72 ], [ 2, %73 ]
store i32 %75, i32* %16
store i32 1, i32* %13
br label %76
76: ; preds = %130, %74
%77 = load i32, i32* %13
%78 = load i32, i32* %18
%79 = icmp sle i32 %77, %78
br i1 %79, label %80, label %133
80: ; preds = %76
%81 = load float*, float** %8
%82 = load i32, i32* %13
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %81, i64 %83
%85 = load float, float* %84
%86 = load float*, float** %8
%87 = load i32, i32* %15
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = fcmp olt float %85, %90
br i1 %91, label %92, label %94
92: ; preds = %80
%93 = load i32, i32* %13
store i32 %93, i32* %15
br label %94
94: ; preds = %92, %80
%95 = load float*, float** %8
%96 = load i32, i32* %13
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
%100 = load float*, float** %8
%101 = load i32, i32* %16
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %100, i64 %102
%104 = load float, float* %103
%105 = fcmp ogt float %99, %104
br i1 %105, label %106, label %109
106: ; preds = %94
%107 = load i32, i32* %16
store i32 %107, i32* %17
%108 = load i32, i32* %13
store i32 %108, i32* %16
br label %129
109: ; preds = %94
%110 = load float*, float** %8
%111 = load i32, i32* %13
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %110, i64 %112
%114 = load float, float* %113
%115 = load float*, float** %8
%116 = load i32, i32* %17
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
%119 = load float, float* %118
%120 = fcmp ogt float %114, %119
br i1 %120, label %121, label %128
121: ; preds = %109
%122 = load i32, i32* %13
%123 = load i32, i32* %16
%124 = icmp ne i32 %122, %123
br i1 %124, label %125, label %127
125: ; preds = %121
%126 = load i32, i32* %13
store i32 %126, i32* %17
br label %127
127: ; preds = %125, %121
br label %128
128: ; preds = %127, %109
br label %129
129: ; preds = %128, %106
br label %130
130: ; preds = %129
%131 = load i32, i32* %13
%132 = add nsw i32 %131, 1
store i32 %132, i32* %13
br label %76
133: ; preds = %76
%134 = load float*, float** %8
%135 = load i32, i32* %16
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %134, i64 %136
%138 = load float, float* %137
%139 = load float*, float** %8
%140 = load i32, i32* %15
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %139, i64 %141
%143 = load float, float* %142
%144 = fsub float %138, %143
%145 = fpext float %144 to double
%146 = call double @llvm.fabs.f64(double %145)
%147 = fmul double 2.000000e+00, %146
%148 = load float*, float** %8
%149 = load i32, i32* %16
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
%153 = fpext float %152 to double
%154 = call double @llvm.fabs.f64(double %153)
%155 = load float*, float** %8
%156 = load i32, i32* %15
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = call double @llvm.fabs.f64(double %160)
%162 = fadd double %154, %161
%163 = fdiv double %147, %162
%164 = fptrunc double %163 to float
store float %164, float* %22
%165 = load float, float* %22
%166 = load float, float* %10
%167 = fcmp olt float %165, %166
br i1 %167, label %168, label %169
168: ; preds = %133
br label %336
169: ; preds = %133
%170 = load i32*, i32** %12
%171 = load i32, i32* %170
%172 = icmp sge i32 %171, 5000
br i1 %172, label %173, label %174
173: ; preds = %169
br label %174
174: ; preds = %173, %169
%175 = load float**, float*** %7
%176 = load float*, float** %8
%177 = load float*, float** %23
%178 = load i32, i32* %9
%179 = load float (...)*, float (...)** %11
%180 = load i32, i32* %16
%181 = load i32*, i32** %12
%182 = call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %175, float* %176, float* %177, i32 %178, float (...)* %179, i32 %180, i32* %181, double -1.000000e+00)
store float %182, float* %19
%183 = load float, float* %19
%184 = load float*, float** %8
%185 = load i32, i32* %15
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float, float* %184, i64 %186
%188 = load float, float* %187
%189 = fcmp ole float %183, %188
br i1 %189, label %190, label %199
190: ; preds = %174
%191 = load float**, float*** %7
%192 = load float*, float** %8
%193 = load float*, float** %23
%194 = load i32, i32* %9
%195 = load float (...)*, float (...)** %11
%196 = load i32, i32* %16
%197 = load i32*, i32** %12
%198 = call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %191, float* %192, float* %193, i32 %194, float (...)* %195, i32 %196, i32* %197, double 2.000000e+00)
store float %198, float* %19
br label %335
199: ; preds = %174
%200 = load float, float* %19
%201 = load float*, float** %8
%202 = load i32, i32* %17
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %201, i64 %203
%205 = load float, float* %204
%206 = fcmp oge float %200, %205
br i1 %206, label %207, label %334
207: ; preds = %199
%208 = load float*, float** %8
%209 = load i32, i32* %16
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %208, i64 %210
%212 = load float, float* %211
store float %212, float* %20
%213 = load float**, float*** %7
%214 = load float*, float** %8
%215 = load float*, float** %23
%216 = load i32, i32* %9
%217 = load float (...)*, float (...)** %11
%218 = load i32, i32* %16
%219 = load i32*, i32** %12
%220 = call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %213, float* %214, float* %215, i32 %216, float (...)* %217, i32 %218, i32* %219, double 5.000000e-01)
store float %220, float* %19
%221 = load float, float* %19
%222 = load float, float* %20
%223 = fcmp oge float %221, %222
br i1 %223, label %224, label %333
224: ; preds = %207
store i32 1, i32* %13
br label %225
225: ; preds = %291, %224
%226 = load i32, i32* %13
%227 = load i32, i32* %18
%228 = icmp sle i32 %226, %227
br i1 %228, label %229, label %294
229: ; preds = %225
%230 = load i32, i32* %13
%231 = load i32, i32* %15
%232 = icmp ne i32 %230, %231
br i1 %232, label %233, label %290
233: ; preds = %229
store i32 1, i32* %14
br label %234
234: ; preds = %278, %233
%235 = load i32, i32* %14
%236 = load i32, i32* %9
%237 = icmp sle i32 %235, %236
br i1 %237, label %238, label %281
238: ; preds = %234
%239 = load float**, float*** %7
%240 = load i32, i32* %13
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float*, float** %239, i64 %241
%243 = load float*, float** %242
%244 = load i32, i32* %14
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %243, i64 %245
%247 = load float, float* %246
%248 = load float**, float*** %7
%249 = load i32, i32* %15
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float*, float** %248, i64 %250
%252 = load float*, float** %251
%253 = load i32, i32* %14
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds float, float* %252, i64 %254
%256 = load float, float* %255
%257 = fadd float %247, %256
%258 = fpext float %257 to double
%259 = fmul double 5.000000e-01, %258
%260 = fptrunc double %259 to float
%261 = load float*, float** %23
%262 = load i32, i32* %14
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %261, i64 %263
store float %260, float* %264
%265 = load float*, float** %23
%266 = load i32, i32* %14
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %265, i64 %267
%269 = load float, float* %268
%270 = load float**, float*** %7
%271 = load i32, i32* %13
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float*, float** %270, i64 %272
%274 = load float*, float** %273
%275 = load i32, i32* %14
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds float, float* %274, i64 %276
store float %269, float* %277
br label %278
278: ; preds = %238
%279 = load i32, i32* %14
%280 = add nsw i32 %279, 1
store i32 %280, i32* %14
br label %234
281: ; preds = %234
%282 = load float (...)*, float (...)** %11
%283 = load float*, float** %23
%284 = bitcast float (...)* %282 to float (float*, ...)*
%285 = call float (float*, ...) %284(float* %283)
%286 = load float*, float** %8
%287 = load i32, i32* %13
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %286, i64 %288
store float %285, float* %289
br label %290
290: ; preds = %281, %229
br label %291
291: ; preds = %290
%292 = load i32, i32* %13
%293 = add nsw i32 %292, 1
store i32 %293, i32* %13
br label %225
294: ; preds = %225
%295 = load i32, i32* %9
%296 = load i32*, i32** %12
%297 = load i32, i32* %296
%298 = add nsw i32 %297, %295
store i32 %298, i32* %296
store i32 1, i32* %14
br label %299
299: ; preds = %329, %294
%300 = load i32, i32* %14
%301 = load i32, i32* %9
%302 = icmp sle i32 %300, %301
br i1 %302, label %303, label %332
303: ; preds = %299
store i32 1, i32* %13
store float 0.000000e+00, float* %21
br label %304
304: ; preds = %320, %303
%305 = load i32, i32* %13
%306 = load i32, i32* %18
%307 = icmp sle i32 %305, %306
br i1 %307, label %308, label %323
308: ; preds = %304
%309 = load float**, float*** %7
%310 = load i32, i32* %13
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float*, float** %309, i64 %311
%313 = load float*, float** %312
%314 = load i32, i32* %14
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %313, i64 %315
%317 = load float, float* %316
%318 = load float, float* %21
%319 = fadd float %318, %317
store float %319, float* %21
br label %320
320: ; preds = %308
%321 = load i32, i32* %13
%322 = add nsw i32 %321, 1
store i32 %322, i32* %13
br label %304
323: ; preds = %304
%324 = load float, float* %21
%325 = load float*, float** %23
%326 = load i32, i32* %14
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
store float %324, float* %328
br label %329
329: ; preds = %323
%330 = load i32, i32* %14
%331 = add nsw i32 %330, 1
store i32 %331, i32* %14
br label %299
332: ; preds = %299
br label %333
333: ; preds = %332, %207
br label %334
334: ; preds = %333, %199
br label %335
335: ; preds = %334, %190
br label %64
336: ; preds = %168
%337 = load float*, float** %23
%338 = load i32, i32* %9
ret void
}

LLVM IR (-O2):
@.str = [30 x i8] c"Too many iterations in AMOEBA\00"
define void @amoeba(float** %0, float* %1, i32 %2, double %3, float (...)* %4, i32* %5) {
%7 = fptrunc double %3 to float
%8 = tail call float* (i32, i32, ...) bitcast (float* (...)* @vector to float* (i32, i32, ...)*)(i32 1, i32 %2)
store i32 0, i32* %5
%9 = icmp slt i32 %2, 1
br i1 %9, label %10, label %13
10: ; preds = %6
%11 = add nsw i32 %2, 1
%12 = add nsw i32 %2, 2
br label %26
13: ; preds = %6
%14 = add nuw i32 %2, 2
%15 = add nuw nsw i32 %2, 1
%16 = zext i32 %15 to i64
%17 = zext i32 %14 to i64
%18 = add nsw i64 %17, -1
%19 = add nsw i64 %17, -2
%20 = and i64 %18, 3
%21 = icmp ult i64 %19, 3
%22 = and i64 %18, -4
%23 = icmp eq i64 %20, 0
br label %24
24: ; preds = %101, %13
%25 = phi i64 [ 1, %13 ], [ %104, %101 ]
br i1 %21, label %85, label %55
26: ; preds = %101, %10
%27 = phi i32 [ %12, %10 ], [ %14, %101 ]
%28 = phi i32 [ %11, %10 ], [ %15, %101 ]
%29 = getelementptr inbounds float, float* %1, i64 1
%30 = getelementptr inbounds float, float* %1, i64 2
%31 = icmp slt i32 %2, 0
%32 = bitcast float (...)* %4 to float (float*, ...)*
%33 = call i32 @llvm.smax.i32(i32 %28, i32 1)
%34 = add nuw i32 %33, 1
%35 = zext i32 %34 to i64
%36 = zext i32 %27 to i64
%37 = zext i32 %28 to i64
%38 = zext i32 %28 to i64
%39 = getelementptr float, float* %8, i64 1
%40 = getelementptr float, float* %8, i64 %37
%41 = add nsw i64 %37, -1
%42 = add nsw i64 %36, -1
%43 = add nsw i64 %36, -2
%44 = icmp ult i64 %41, 8
%45 = and i64 %41, -8
%46 = or i64 %45, 1
%47 = icmp eq i64 %41, %45
%48 = and i64 %37, 1
%49 = icmp eq i64 %48, 0
%50 = sub nsw i64 0, %37
%51 = and i64 %42, 3
%52 = icmp ult i64 %43, 3
%53 = and i64 %42, -4
%54 = icmp eq i64 %51, 0
br label %106
55: ; preds = %24, %55
%56 = phi i64 [ %82, %55 ], [ 1, %24 ]
%57 = phi float [ %81, %55 ], [ 0.000000e+00, %24 ]
%58 = phi i64 [ %83, %55 ], [ 0, %24 ]
%59 = getelementptr inbounds float*, float** %0, i64 %56
%60 = load float*, float** %59
%61 = getelementptr inbounds float, float* %60, i64 %25
%62 = load float, float* %61
%63 = fadd float %57, %62
%64 = add nuw nsw i64 %56, 1
%65 = getelementptr inbounds float*, float** %0, i64 %64
%66 = load float*, float** %65
%67 = getelementptr inbounds float, float* %66, i64 %25
%68 = load float, float* %67
%69 = fadd float %63, %68
%70 = add nuw nsw i64 %56, 2
%71 = getelementptr inbounds float*, float** %0, i64 %70
%72 = load float*, float** %71
%73 = getelementptr inbounds float, float* %72, i64 %25
%74 = load float, float* %73
%75 = fadd float %69, %74
%76 = add nuw nsw i64 %56, 3
%77 = getelementptr inbounds float*, float** %0, i64 %76
%78 = load float*, float** %77
%79 = getelementptr inbounds float, float* %78, i64 %25
%80 = load float, float* %79
%81 = fadd float %75, %80
%82 = add nuw nsw i64 %56, 4
%83 = add i64 %58, 4
%84 = icmp eq i64 %83, %22
br i1 %84, label %85, label %55
85: ; preds = %55, %24
%86 = phi float [ undef, %24 ], [ %81, %55 ]
%87 = phi i64 [ 1, %24 ], [ %82, %55 ]
%88 = phi float [ 0.000000e+00, %24 ], [ %81, %55 ]
br i1 %23, label %101, label %89
89: ; preds = %85, %89
%90 = phi i64 [ %98, %89 ], [ %87, %85 ]
%91 = phi float [ %97, %89 ], [ %88, %85 ]
%92 = phi i64 [ %99, %89 ], [ 0, %85 ]
%93 = getelementptr inbounds float*, float** %0, i64 %90
%94 = load float*, float** %93
%95 = getelementptr inbounds float, float* %94, i64 %25
%96 = load float, float* %95
%97 = fadd float %91, %96
%98 = add nuw nsw i64 %90, 1
%99 = add i64 %92, 1
%100 = icmp eq i64 %99, %20
br i1 %100, label %101, label %89
101: ; preds = %89, %85
%102 = phi float [ %86, %85 ], [ %97, %89 ]
%103 = getelementptr inbounds float, float* %8, i64 %25
store float %102, float* %103
%104 = add nuw nsw i64 %25, 1
%105 = icmp eq i64 %104, %16
br i1 %105, label %26, label %24
106: ; preds = %292, %26
%107 = load float, float* %29
%108 = load float, float* %30
%109 = fcmp ogt float %107, %108
%110 = select i1 %109, i32 2, i32 1
%111 = select i1 %109, i32 1, i32 2
br i1 %31, label %150, label %112
112: ; preds = %106, %140
%113 = phi float [ %145, %140 ], [ %107, %106 ]
%114 = phi float [ %142, %140 ], [ %107, %106 ]
%115 = phi i64 [ %138, %140 ], [ 1, %106 ]
%116 = phi i32 [ %121, %140 ], [ 1, %106 ]
%117 = phi i32 [ %137, %140 ], [ %111, %106 ]
%118 = phi i32 [ %136, %140 ], [ %110, %106 ]
%119 = fcmp olt float %114, %113
%120 = trunc i64 %115 to i32
%121 = select i1 %119, i32 %120, i32 %116
%122 = sext i32 %117 to i64
%123 = getelementptr inbounds float, float* %1, i64 %122
%124 = load float, float* %123
%125 = fcmp ogt float %114, %124
br i1 %125, label %135, label %126
126: ; preds = %112
%127 = sext i32 %118 to i64
%128 = getelementptr inbounds float, float* %1, i64 %127
%129 = load float, float* %128
%130 = fcmp ule float %114, %129
%131 = zext i32 %117 to i64
%132 = icmp eq i64 %115, %131
%133 = select i1 %130, i1 true, i1 %132
%134 = select i1 %133, i32 %118, i32 %120
br label %135
135: ; preds = %126, %112
%136 = phi i32 [ %117, %112 ], [ %134, %126 ]
%137 = phi i32 [ %120, %112 ], [ %117, %126 ]
%138 = add nuw nsw i64 %115, 1
%139 = icmp eq i64 %138, %35
br i1 %139, label %146, label %140
140: ; preds = %135
%141 = getelementptr inbounds float, float* %1, i64 %138
%142 = load float, float* %141
%143 = sext i32 %121 to i64
%144 = getelementptr inbounds float, float* %1, i64 %143
%145 = load float, float* %144
br label %112
146: ; preds = %135
%147 = sext i32 %121 to i64
%148 = getelementptr inbounds float, float* %1, i64 %147
%149 = load float, float* %148
br label %150
150: ; preds = %106, %146
%151 = phi float [ %149, %146 ], [ %107, %106 ]
%152 = phi i32 [ %136, %146 ], [ %110, %106 ]
%153 = phi i32 [ %137, %146 ], [ %111, %106 ]
%154 = phi i32 [ %121, %146 ], [ 1, %106 ]
%155 = sext i32 %153 to i64
%156 = getelementptr inbounds float, float* %1, i64 %155
%157 = load float, float* %156
%158 = sext i32 %154 to i64
%159 = getelementptr inbounds float, float* %1, i64 %158
%160 = fsub float %157, %151
%161 = tail call float @llvm.fabs.f32(float %160)
%162 = fpext float %161 to double
%163 = fmul double %162, 2.000000e+00
%164 = insertelement <2 x float> poison, float %157, i64 0
%165 = insertelement <2 x float> %164, float %151, i64 1
%166 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %165)
%167 = fpext <2 x float> %166 to <2 x double>
%168 = shufflevector <2 x double> %167, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%169 = fadd <2 x double> %168, %167
%170 = extractelement <2 x double> %169, i64 0
%171 = fdiv double %163, %170
%172 = fptrunc double %171 to float
%173 = fcmp olt float %172, %7
br i1 %173, label %347, label %174
174: ; preds = %150
%175 = load i32, i32* %5
%176 = icmp sgt i32 %175, 4999
br i1 %176, label %177, label %178
177: ; preds = %174
tail call void (i8*, ...) bitcast (void (...)* @nrerror to void (i8*, ...)*)(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0))
br label %178
178: ; preds = %177, %174
%179 = tail call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %0, float* %1, float* %8, i32 %2, float (...)* %4, i32 %153, i32* %5, double -1.000000e+00)
%180 = load float, float* %159
%181 = fcmp ugt float %179, %180
br i1 %181, label %184, label %182
182: ; preds = %178
%183 = tail call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %0, float* %1, float* %8, i32 %2, float (...)* %4, i32 %153, i32* %5, double 2.000000e+00)
br label %292
184: ; preds = %178
%185 = sext i32 %152 to i64
%186 = getelementptr inbounds float, float* %1, i64 %185
%187 = load float, float* %186
%188 = fcmp ult float %179, %187
br i1 %188, label %292, label %189
189: ; preds = %184
%190 = load float, float* %156
%191 = tail call float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...) bitcast (float (...)* @amotry to float (float**, float*, float*, i32, float (...)*, i32, i32*, double, ...)*)(float** %0, float* %1, float* %8, i32 %2, float (...)* %4, i32 %153, i32* %5, double 5.000000e-01)
%192 = fcmp ult float %191, %190
br i1 %192, label %292, label %193
193: ; preds = %189
br i1 %31, label %289, label %194
194: ; preds = %193
%195 = getelementptr inbounds float*, float** %0, i64 %158
%196 = zext i32 %154 to i64
br label %197
197: ; preds = %194, %286
%198 = phi i64 [ 1, %194 ], [ %287, %286 ]
%199 = icmp eq i64 %198, %196
br i1 %199, label %286, label %200
200: ; preds = %197
br i1 %9, label %283, label %201
201: ; preds = %200
%202 = getelementptr inbounds float*, float** %0, i64 %198
%203 = load float*, float** %202
%204 = load float*, float** %195
br i1 %44, label %249, label %205
205: ; preds = %201
%206 = getelementptr float, float* %203, i64 1
%207 = getelementptr float, float* %203, i64 %37
%208 = getelementptr float, float* %204, i64 1
%209 = getelementptr float, float* %204, i64 %37
%210 = icmp ult float* %39, %207
%211 = icmp ult float* %206, %40
%212 = and i1 %210, %211
%213 = icmp ult float* %39, %209
%214 = icmp ult float* %208, %40
%215 = and i1 %213, %214
%216 = or i1 %212, %215
%217 = icmp ult float* %206, %209
%218 = icmp ult float* %208, %207
%219 = and i1 %217, %218
%220 = or i1 %216, %219
br i1 %220, label %249, label %221
221: ; preds = %205, %221
%222 = phi i64 [ %246, %221 ], [ 0, %205 ]
%223 = or i64 %222, 1
%224 = getelementptr inbounds float, float* %203, i64 %223
%225 = bitcast float* %224 to <4 x float>*
%226 = load <4 x float>, <4 x float>* %225
%227 = getelementptr inbounds float, float* %224, i64 4
%228 = bitcast float* %227 to <4 x float>*
%229 = load <4 x float>, <4 x float>* %228
%230 = getelementptr inbounds float, float* %204, i64 %223
%231 = bitcast float* %230 to <4 x float>*
%232 = load <4 x float>, <4 x float>* %231
%233 = getelementptr inbounds float, float* %230, i64 4
%234 = bitcast float* %233 to <4 x float>*
%235 = load <4 x float>, <4 x float>* %234
%236 = fadd <4 x float> %226, %232
%237 = fadd <4 x float> %229, %235
%238 = fmul <4 x float> %236, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%239 = fmul <4 x float> %237, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%240 = getelementptr inbounds float, float* %8, i64 %223
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> %238, <4 x float>* %241
%242 = getelementptr inbounds float, float* %240, i64 4
%243 = bitcast float* %242 to <4 x float>*
store <4 x float> %239, <4 x float>* %243
%244 = bitcast float* %224 to <4 x float>*
store <4 x float> %238, <4 x float>* %244
%245 = bitcast float* %227 to <4 x float>*
store <4 x float> %239, <4 x float>* %245
%246 = add nuw i64 %222, 8
%247 = icmp eq i64 %246, %45
br i1 %247, label %248, label %221
248: ; preds = %221
br i1 %47, label %283, label %249
249: ; preds = %205, %201, %248
%250 = phi i64 [ 1, %205 ], [ 1, %201 ], [ %46, %248 ]
%251 = xor i64 %250, -1
br i1 %49, label %252, label %261
252: ; preds = %249
%253 = getelementptr inbounds float, float* %203, i64 %250
%254 = load float, float* %253
%255 = getelementptr inbounds float, float* %204, i64 %250
%256 = load float, float* %255
%257 = fadd float %254, %256
%258 = fmul float %257, 5.000000e-01
%259 = getelementptr inbounds float, float* %8, i64 %250
store float %258, float* %259
store float %258, float* %253
%260 = add nuw nsw i64 %250, 1
br label %261
261: ; preds = %252, %249
%262 = phi i64 [ %250, %249 ], [ %260, %252 ]
%263 = icmp eq i64 %251, %50
br i1 %263, label %283, label %264
264: ; preds = %261, %264
%265 = phi i64 [ %281, %264 ], [ %262, %261 ]
%266 = getelementptr inbounds float, float* %203, i64 %265
%267 = load float, float* %266
%268 = getelementptr inbounds float, float* %204, i64 %265
%269 = load float, float* %268
%270 = fadd float %267, %269
%271 = fmul float %270, 5.000000e-01
%272 = getelementptr inbounds float, float* %8, i64 %265
store float %271, float* %272
store float %271, float* %266
%273 = add nuw nsw i64 %265, 1
%274 = getelementptr inbounds float, float* %203, i64 %273
%275 = load float, float* %274
%276 = getelementptr inbounds float, float* %204, i64 %273
%277 = load float, float* %276
%278 = fadd float %275, %277
%279 = fmul float %278, 5.000000e-01
%280 = getelementptr inbounds float, float* %8, i64 %273
store float %279, float* %280
store float %279, float* %274
%281 = add nuw nsw i64 %265, 2
%282 = icmp eq i64 %281, %37
br i1 %282, label %283, label %264
283: ; preds = %261, %264, %248, %200
%284 = tail call float (float*, ...) %32(float* %8)
%285 = getelementptr inbounds float, float* %1, i64 %198
store float %284, float* %285
br label %286
286: ; preds = %197, %283
%287 = add nuw nsw i64 %198, 1
%288 = icmp eq i64 %287, %36
br i1 %288, label %289, label %197
289: ; preds = %286, %193
%290 = load i32, i32* %5
%291 = add nsw i32 %290, %2
store i32 %291, i32* %5
br i1 %9, label %292, label %293
292: ; preds = %342, %289, %184, %189, %182
br label %106
293: ; preds = %289, %342
%294 = phi i64 [ %345, %342 ], [ 1, %289 ]
br i1 %31, label %342, label %295
295: ; preds = %293
br i1 %52, label %326, label %296
296: ; preds = %295, %296
%297 = phi i64 [ %323, %296 ], [ 1, %295 ]
%298 = phi float [ %322, %296 ], [ 0.000000e+00, %295 ]
%299 = phi i64 [ %324, %296 ], [ 0, %295 ]
%300 = getelementptr inbounds float*, float** %0, i64 %297
%301 = load float*, float** %300
%302 = getelementptr inbounds float, float* %301, i64 %294
%303 = load float, float* %302
%304 = fadd float %298, %303
%305 = add nuw nsw i64 %297, 1
%306 = getelementptr inbounds float*, float** %0, i64 %305
%307 = load float*, float** %306
%308 = getelementptr inbounds float, float* %307, i64 %294
%309 = load float, float* %308
%310 = fadd float %304, %309
%311 = add nuw nsw i64 %297, 2
%312 = getelementptr inbounds float*, float** %0, i64 %311
%313 = load float*, float** %312
%314 = getelementptr inbounds float, float* %313, i64 %294
%315 = load float, float* %314
%316 = fadd float %310, %315
%317 = add nuw nsw i64 %297, 3
%318 = getelementptr inbounds float*, float** %0, i64 %317
%319 = load float*, float** %318
%320 = getelementptr inbounds float, float* %319, i64 %294
%321 = load float, float* %320
%322 = fadd float %316, %321
%323 = add nuw nsw i64 %297, 4
%324 = add i64 %299, 4
%325 = icmp eq i64 %324, %53
br i1 %325, label %326, label %296
326: ; preds = %296, %295
%327 = phi float [ undef, %295 ], [ %322, %296 ]
%328 = phi i64 [ 1, %295 ], [ %323, %296 ]
%329 = phi float [ 0.000000e+00, %295 ], [ %322, %296 ]
br i1 %54, label %342, label %330
330: ; preds = %326, %330
%331 = phi i64 [ %339, %330 ], [ %328, %326 ]
%332 = phi float [ %338, %330 ], [ %329, %326 ]
%333 = phi i64 [ %340, %330 ], [ 0, %326 ]
%334 = getelementptr inbounds float*, float** %0, i64 %331
%335 = load float*, float** %334
%336 = getelementptr inbounds float, float* %335, i64 %294
%337 = load float, float* %336
%338 = fadd float %332, %337
%339 = add nuw nsw i64 %331, 1
%340 = add i64 %333, 1
%341 = icmp eq i64 %340, %51
br i1 %341, label %342, label %330
342: ; preds = %326, %330, %293
%343 = phi float [ 0.000000e+00, %293 ], [ %327, %326 ], [ %338, %330 ]
%344 = getelementptr inbounds float, float* %8, i64 %294
store float %343, float* %344
%345 = add nuw nsw i64 %294, 1
%346 = icmp eq i64 %345, %38
br i1 %346, label %292, label %293
347: ; preds = %150
tail call void (float*, i32, i32, ...) bitcast (void (...)* @free_vector to void (float*, i32, i32, ...)*)(float* %8, i32 1, i32 %2)
ret void
}