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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(float);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ nrerror(char *);
float stub1(float *);
float *vector(int, int);
void amoeba(float **p, float y[], int ndim, float ftol, float (*funk)(float[]),
            int *nfunk) {
  float amotry(float **p, float y[], float psum[], int ndim,
               float (*funk)(float[]), int ihi, float fac);
  int i, ihi, ilo, inhi, j, mpts = ndim + 1;
  float rtol, sum, swap, ysave, ytry, *psum;
  psum = vector(1, ndim);
  *nfunk = 0;
  for (j = 1; j <= ndim; j++) {
    for (sum = 0.0, i = 1; 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] && i != ihi)
        inhi = i;
    }
    rtol =
        2.0 * fabs(y[ihi] - y[ilo]) / (fabs(y[ihi]) + fabs(y[ilo]) + 1.0e-10);
    if (rtol < ftol) {
      {
        swap = (y[1]);
        (y[1]) = (y[ilo]);
        (y[ilo]) = swap;
      }
      for (i = 1; i <= ndim; i++) {
        swap = (p[1][i]);
        (p[1][i]) = (p[ilo][i]);
        (p[ilo][i]) = swap;
      }
      break;
    }
    if (*nfunk >= 5000)
      nrerror("NMAX exceeded");
    *nfunk += 2;
    ytry = amotry(p, y, psum, ndim, funk, ihi, -1.0);
    if (ytry <= y[ilo])
      ytry = amotry(p, y, psum, ndim, funk, ihi, 2.0);
    else if (ytry >= y[inhi]) {
      ysave = y[ihi];
      ytry = amotry(p, y, psum, ndim, funk, ihi, 0.5);
      if (ytry >= ysave) {
        for (i = 1; i <= mpts; i++) {
          if (i != ilo) {
            for (j = 1; j <= ndim; j++)
              p[i][j] = psum[j] = 0.5 * (p[i][j] + p[ilo][j]);
            y[i] = (*funk)(psum);
          }
        }
        *nfunk += ndim;
        for (j = 1; j <= ndim; j++) {
          for (sum = 0.0, i = 1; i <= mpts; i++)
            sum += p[i][j];
          psum[j] = sum;
        }
      }
    } else
      --(*nfunk);
  }
  free_vector(psum, 1, ndim);
}


x86 assembly (clang, -O0):
<amoeba>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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
call   1060 <vector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1212 <amoeba+0xc2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     11f2 <amoeba+0xa2>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b9 <amoeba+0x69>
movss  -0x48(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    119e <amoeba+0x4e>
jmp    1217 <amoeba+0xc7>
movl   $0x1,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x8(%rax),%xmm0
jbe    1249 <amoeba+0xf9>
movl   $0x2,-0x38(%rbp)
mov    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1258 <amoeba+0x108>
movl   $0x1,-0x38(%rbp)
mov    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1313 <amoeba+0x1c3>
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
jb     129a <amoeba+0x14a>
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 -0x30(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    12ca <amoeba+0x17a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1300 <amoeba+0x1b0>
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    12fb <amoeba+0x1ab>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     12fb <amoeba+0x1ab>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1300 <amoeba+0x1b0>
jmp    1305 <amoeba+0x1b5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1265 <amoeba+0x115>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xccb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movsd  -0x78(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
addsd  %xmm2,%xmm1
movsd  0xc78(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    145e <amoeba+0x30e>
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1459 <amoeba+0x309>
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e9 <amoeba+0x299>
jmp    16c7 <amoeba+0x577>
mov    -0x28(%rbp),%rax
cmpl   $0x1388,(%rax)
jl     147a <amoeba+0x32a>
lea    0xbaf(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x2,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x30(%rbp),%r9d
movss  0xb74(%rip),%xmm0
call   1070 <amotry@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     14f7 <amoeba+0x3a7>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x30(%rbp),%r9d
movss  0xb38(%rip),%xmm0
call   1070 <amotry@plt>
movss  %xmm0,-0x54(%rbp)
jmp    16c2 <amoeba+0x572>
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     16b2 <amoeba+0x562>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8
mov    -0x30(%rbp),%r9d
movss  0xadd(%rip),%xmm0
call   1070 <amotry@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x50(%rbp),%xmm0
jb     16ad <amoeba+0x55d>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1622 <amoeba+0x4d2>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     160f <amoeba+0x4bf>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     15f8 <amoeba+0x4a8>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa50(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    157e <amoeba+0x42e>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rdi
call   *%rax
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1614 <amoeba+0x4c4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    155f <amoeba+0x40f>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16a8 <amoeba+0x558>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1688 <amoeba+0x538>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164f <amoeba+0x4ff>
movss  -0x48(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1634 <amoeba+0x4e4>
jmp    16ad <amoeba+0x55d>
jmp    16bd <amoeba+0x56d>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
jmp    16c2 <amoeba+0x572>
jmp    1217 <amoeba+0xc7>
mov    -0x60(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
add    $0x80,%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,%r14
mov    %rcx,0x20(%rsp)
movss  %xmm0,0x4c(%rsp)
mov    %edx,%ebp
mov    %rsi,%r12
mov    %rdi,%rbx
mov    $0x1,%edi
mov    %edx,%esi
call   1060 <vector@plt>
mov    %rbp,%r10
mov    %rax,%r15
mov    %rax,%r11
mov    %r14,0x40(%rsp)
movl   $0x0,(%r14)
test   %r10d,%r10d
mov    %rbp,0x8(%rsp)
jle    125e <amoeba+0x10e>
lea    0x2(%r10),%r8d
lea    0x1(%r10),%r9d
mov    %r10d,%r10d
lea    0x1(%r10),%rsi
mov    %esi,%edi
and    $0x3,%edi
and    $0xfffffffffffffffc,%rsi
mov    $0x1,%ebp
jmp    11df <amoeba+0x8f>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %r9,%rbp
je     1257 <amoeba+0x107>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
cmp    $0x3,%r10d
jb     1235 <amoeba+0xe5>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    1200 <amoeba+0xb0>
add    $0x1,%rcx
test   %rdi,%rdi
je     11d0 <amoeba+0x80>
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    1240 <amoeba+0xf0>
jmp    11d0 <amoeba+0x80>
mov    0x8(%rsp),%r10
jmp    1266 <amoeba+0x116>
lea    0x1(%r10),%r9d
lea    0x2(%r10),%r8d
cmp    $0x2,%r9d
mov    $0x1,%eax
cmovge %r9d,%eax
mov    %rax,0x70(%rsp)
mov    %r8d,%ecx
mov    %r9d,%r13d
lea    (%r11,%r13,4),%rax
mov    %rax,0x60(%rsp)
add    $0x4,%r11
mov    %r11,0x68(%rsp)
lea    -0x1(%r13),%rax
lea    -0x1(%rcx),%rdx
mov    %rcx,0xa0(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x90(%rsp)
mov    %rax,0x38(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rsp)
add    $0x1,%rax
mov    %rax,0x58(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x78(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0x50(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x80(%rsp)
mov    %r15,(%rsp)
mov    %r13,0x10(%rsp)
jmp    1314 <amoeba+0x1c4>
nop
mov    %rbx,%rdi
mov    %r12,%rsi
mov    (%rsp),%rdx
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
mov    %r13d,%r9d
movss  0xd00(%rip),%xmm0
call   1070 <amotry@plt>
mov    %rbp,%r10
movss  0x4(%r12),%xmm1
xor    %r15d,%r15d
ucomiss 0x8(%r12),%xmm1
seta   %r15b
mov    $0x2,%r13d
sub    %r15d,%r13d
add    $0x1,%r15d
mov    $0x1,%r14d
test   %r10d,%r10d
js     13c9 <amoeba+0x279>
mov    $0x1,%eax
movaps %xmm1,%xmm0
mov    0x70(%rsp),%rsi
ucomiss %xmm0,%xmm1
jb     1363 <amoeba+0x213>
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%r14d
movslq %r13d,%rcx
ucomiss (%r12,%rcx,4),%xmm0
jbe    1380 <amoeba+0x230>
mov    %r13d,%r15d
mov    %eax,%r13d
jmp    1398 <amoeba+0x248>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %r15d,%rdx
mov    %r13d,%ecx
cmp    %rcx,%rax
mov    %edx,%ecx
cmovne %eax,%ecx
ucomiss (%r12,%rdx,4),%xmm0
jbe    1398 <amoeba+0x248>
mov    %ecx,%r15d
cmp    %rax,%rsi
je     13c0 <amoeba+0x270>
movss  0x4(%r12,%rax,4),%xmm0
movslq %r14d,%rcx
movss  (%r12,%rcx,4),%xmm1
add    $0x1,%rax
ucomiss %xmm0,%xmm1
jae    1360 <amoeba+0x210>
jmp    1363 <amoeba+0x213>
nopl   0x0(%rax,%rax,1)
movslq %r14d,%rax
movss  (%r12,%rax,4),%xmm1
movslq %r13d,%rbp
movss  (%r12,%rbp,4),%xmm0
subss  %xmm1,%xmm0
movslq %r14d,%rax
mov    %rax,0x28(%rsp)
call   1050 <fabs@plt>
addsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %rbp,0x88(%rsp)
movss  (%r12,%rbp,4),%xmm0
call   1050 <fabs@plt>
movsd  %xmm0,0x98(%rsp)
mov    0x28(%rsp),%rax
movss  (%r12,%rax,4),%xmm0
call   1050 <fabs@plt>
addsd  0x98(%rsp),%xmm0
addsd  0xbd6(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  0x4c(%rsp),%xmm1
ucomiss %xmm0,%xmm1
ja     17e7 <amoeba+0x697>
mov    0x40(%rsp),%rbp
mov    0x0(%rbp),%eax
cmp    $0x1388,%eax
jl     1468 <amoeba+0x318>
lea    0xbd0(%rip),%rdi
call   1030 <nrerror@plt>
mov    0x0(%rbp),%eax
add    $0x2,%eax
mov    %eax,0x0(%rbp)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    (%rsp),%rdx
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
mov    %r13d,%r9d
movss  0xb79(%rip),%xmm0
call   1070 <amotry@plt>
mov    0x28(%rsp),%rax
movss  (%r12,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jae    12f0 <amoeba+0x1a0>
movslq %r15d,%rax
ucomiss (%r12,%rax,4),%xmm0
jae    14d0 <amoeba+0x380>
mov    0x40(%rsp),%rax
addl   $0xffffffff,(%rax)
mov    0x8(%rsp),%r10
jmp    1314 <amoeba+0x1c4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x88(%rsp),%rax
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x18(%rsp)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    (%rsp),%r15
mov    %r15,%rdx
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
mov    %r13d,%r9d
movss  0xb08(%rip),%xmm0
call   1070 <amotry@plt>
mov    %rbp,%r10
movss  0xaf8(%rip),%xmm3
ucomiss 0x18(%rsp),%xmm0
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%rbp
movaps 0xaf2(%rip),%xmm4
jb     1314 <amoeba+0x1c4>
test   %r10d,%r10d
js     1704 <amoeba+0x5b4>
mov    %r14d,%eax
mov    $0x1,%r14d
mov    %rax,0x18(%rsp)
jmp    1588 <amoeba+0x438>
nopl   (%rax)
mov    %r15,%rdi
call   *0x20(%rsp)
movaps 0xac2(%rip),%xmm4
movss  0xaaa(%rip),%xmm3
movss  %xmm0,(%r12,%r14,4)
mov    0x50(%rsp),%rbp
mov    0x18(%rsp),%rax
add    $0x1,%r14
cmp    0xa0(%rsp),%r14
je     1704 <amoeba+0x5b4>
cmp    %rax,%r14
je     1576 <amoeba+0x426>
cmpl   $0x0,0x8(%rsp)
jle    1550 <amoeba+0x400>
mov    (%rbx,%r14,8),%rax
mov    0x28(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
mov    $0x1,%edx
cmpq   $0x8,0x38(%rsp)
jb     1680 <amoeba+0x530>
lea    0x4(%rax),%rdi
lea    (%rax,%r13,4),%r9
lea    0x4(%rcx),%r11
lea    (%rcx,%r13,4),%rsi
mov    0x68(%rsp),%r8
cmp    %r9,%r8
setb   %r15b
mov    0x60(%rsp),%rbp
cmp    %rbp,%rdi
setb   %r13b
cmp    %rsi,%r8
setb   %r10b
cmp    %rbp,%r11
setb   %r8b
cmp    %rsi,%rdi
setb   %dil
cmp    %r9,%r11
setb   %r9b
test   %r13b,%r15b
jne    1671 <amoeba+0x521>
and    %r8b,%r10b
jne    1671 <amoeba+0x521>
and    %r9b,%dil
mov    (%rsp),%r15
mov    0x10(%rsp),%r13
mov    0x30(%rsp),%rsi
jne    1680 <amoeba+0x530>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
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(%r15,%rdx,4)
movups %xmm0,0x14(%r15,%rdx,4)
movups %xmm2,0x4(%rax,%rdx,4)
movups %xmm0,0x14(%rax,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1620 <amoeba+0x4d0>
mov    0x58(%rsp),%rdx
cmp    %rsi,0x38(%rsp)
je     1550 <amoeba+0x400>
jmp    1680 <amoeba+0x530>
mov    (%rsp),%r15
mov    0x10(%rsp),%r13
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rsi
test   $0x1,%r13b
jne    16a6 <amoeba+0x556>
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r15,%rdx,4)
movss  %xmm0,(%rax,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x78(%rsp),%rdx
je     1550 <amoeba+0x400>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r15,%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(%r15,%rsi,4)
movss  %xmm0,0x4(%rax,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r13
jne    16c0 <amoeba+0x570>
jmp    1550 <amoeba+0x400>
mov    0x8(%rsp),%r10
mov    0x40(%rsp),%rax
add    %r10d,(%rax)
test   %r10d,%r10d
jle    1314 <amoeba+0x1c4>
mov    $0x1,%eax
jmp    1746 <amoeba+0x5f6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
cmp    %r13,%rax
je     1314 <amoeba+0x1c4>
test   %r10d,%r10d
js     1730 <amoeba+0x5e0>
cmpq   $0x3,0x90(%rsp)
jae    1770 <amoeba+0x620>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
test   %rbp,%rbp
jne    17be <amoeba+0x66e>
jmp    1733 <amoeba+0x5e3>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x80(%rsp),%rdi
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,%rdi
jne    1780 <amoeba+0x630>
add    $0x1,%rcx
test   %rbp,%rbp
je     1733 <amoeba+0x5e3>
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,%rbp
jne    17d0 <amoeba+0x680>
jmp    1733 <amoeba+0x5e3>
movss  0x4(%r12),%xmm0
mov    0x28(%rsp),%rcx
movss  (%r12,%rcx,4),%xmm1
movss  %xmm1,0x4(%r12)
movss  %xmm0,(%r12,%rcx,4)
mov    0x8(%rsp),%rdx
test   %edx,%edx
mov    (%rsp),%rdi
mov    0x10(%rsp),%r8
jle    1975 <amoeba+0x825>
mov    0x8(%rbx),%rax
mov    (%rbx,%rcx,8),%rcx
mov    $0x1,%esi
mov    0x38(%rsp),%r10
cmp    $0x8,%r10
jb     190d <amoeba+0x7bd>
lea    0x4(%rax),%rbp
lea    (%rcx,%r8,4),%rbx
cmp    %rbx,%rbp
jae    1856 <amoeba+0x706>
lea    (%rax,%r8,4),%rbp
lea    0x4(%rcx),%rbx
cmp    %rbp,%rbx
jb     190d <amoeba+0x7bd>
mov    0x30(%rsp),%r9
lea    -0x8(%r9),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1990 <amoeba+0x840>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ebp
nop
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
movups (%rcx,%rbp,4),%xmm2
movups 0x10(%rcx,%rbp,4),%xmm3
movups %xmm2,(%rax,%rbp,4)
movups %xmm3,0x10(%rax,%rbp,4)
movups %xmm0,(%rcx,%rbp,4)
movups %xmm1,0x10(%rcx,%rbp,4)
movups 0x20(%rax,%rbp,4),%xmm0
movups 0x30(%rax,%rbp,4),%xmm1
movups 0x20(%rcx,%rbp,4),%xmm2
movups 0x30(%rcx,%rbp,4),%xmm3
movups %xmm2,0x20(%rax,%rbp,4)
movups %xmm3,0x30(%rax,%rbp,4)
movups %xmm0,0x20(%rcx,%rbp,4)
movups %xmm1,0x30(%rcx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1880 <amoeba+0x730>
test   $0x1,%bl
je     18ff <amoeba+0x7af>
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
movups (%rcx,%rbp,4),%xmm2
movups 0x10(%rcx,%rbp,4),%xmm3
movups %xmm2,(%rax,%rbp,4)
movups %xmm3,0x10(%rax,%rbp,4)
movups %xmm0,(%rcx,%rbp,4)
movups %xmm1,0x10(%rcx,%rbp,4)
cmp    %r9,%r10
je     1975 <amoeba+0x825>
mov    0x30(%rsp),%rsi
or     $0x1,%rsi
mov    %rsi,%rbp
not    %rbp
test   $0x1,%r8b
jne    1931 <amoeba+0x7e1>
movss  (%rax,%rsi,4),%xmm0
movss  (%rcx,%rsi,4),%xmm1
movss  %xmm1,(%rax,%rsi,4)
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rsi
add    %r8,%rbp
je     1975 <amoeba+0x825>
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm0
movss  (%rcx,%rsi,4),%xmm1
movss  %xmm1,(%rax,%rsi,4)
movss  %xmm0,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
movss  0x4(%rcx,%rsi,4),%xmm1
movss  %xmm1,0x4(%rax,%rsi,4)
movss  %xmm0,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r8
jne    1940 <amoeba+0x7f0>
mov    $0x1,%esi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>
mov    $0x1,%ebp
test   $0x1,%bl
jne    18db <amoeba+0x78b>
jmp    18ff <amoeba+0x7af>

LLVM IR (-O0):
@.str = [14 x i8] c"NMAX exceeded\00"
define void @amoeba(float** %0, float* %1, i32 %2, float %3, float (float*)* %4, i32* %5) {
%7 = alloca float**
%8 = alloca float*
%9 = alloca i32
%10 = alloca float
%11 = alloca float (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 = alloca float*
store float** %0, float*** %7
store float* %1, float** %8
store i32 %2, i32* %9
store float %3, float* %10
store float (float*)* %4, float (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* @vector(i32 1, i32 %27)
store float* %28, float** %24
%29 = load i32*, i32** %12
store i32 0, i32* %29
store i32 1, i32* %17
br label %30
30: ; preds = %60, %6
%31 = load i32, i32* %17
%32 = load i32, i32* %9
%33 = icmp sle i32 %31, %32
br i1 %33, label %34, label %63
34: ; preds = %30
store float 0.000000e+00, float* %20
store i32 1, i32* %13
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* %17
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = load float, float* %20
%50 = fadd float %49, %48
store float %50, float* %20
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* %20
%56 = load float*, float** %24
%57 = load i32, i32* %17
%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* %17
%62 = add nsw i32 %61, 1
store i32 %62, i32* %17
br label %30
63: ; preds = %30
br label %64
64: ; preds = %386, %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* %16
br label %74
73: ; preds = %64
store i32 1, i32* %16
br label %74
74: ; preds = %73, %72
%75 = phi i32 [ 1, %72 ], [ 2, %73 ]
store i32 %75, i32* %14
store i32 1, i32* %13
br label %76
76: ; preds = %129, %74
%77 = load i32, i32* %13
%78 = load i32, i32* %18
%79 = icmp sle i32 %77, %78
br i1 %79, label %80, label %132
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 ole 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* %14
%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* %14
store i32 %107, i32* %16
%108 = load i32, i32* %13
store i32 %108, i32* %14
br label %128
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* %16
%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 %127
121: ; preds = %109
%122 = load i32, i32* %13
%123 = load i32, i32* %14
%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* %16
br label %127
127: ; preds = %125, %121, %109
br label %128
128: ; preds = %127, %106
br label %129
129: ; preds = %128
%130 = load i32, i32* %13
%131 = add nsw i32 %130, 1
store i32 %131, i32* %13
br label %76
132: ; preds = %76
%133 = load float*, float** %8
%134 = load i32, i32* %14
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
%137 = load float, float* %136
%138 = load float*, float** %8
%139 = load i32, i32* %15
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = fsub float %137, %142
%144 = call double @fabs(float %143)
%145 = fmul double 2.000000e+00, %144
%146 = load float*, float** %8
%147 = load i32, i32* %14
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %146, i64 %148
%150 = load float, float* %149
%151 = call double @fabs(float %150)
%152 = load float*, float** %8
%153 = load i32, i32* %15
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = call double @fabs(float %156)
%158 = fadd double %151, %157
%159 = fadd double %158, 1.000000e-10
%160 = fdiv double %145, %159
%161 = fptrunc double %160 to float
store float %161, float* %19
%162 = load float, float* %19
%163 = load float, float* %10
%164 = fcmp olt float %162, %163
br i1 %164, label %165, label %221
165: ; preds = %132
%166 = load float*, float** %8
%167 = getelementptr inbounds float, float* %166, i64 1
%168 = load float, float* %167
store float %168, float* %21
%169 = load float*, float** %8
%170 = load i32, i32* %15
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
%173 = load float, float* %172
%174 = load float*, float** %8
%175 = getelementptr inbounds float, float* %174, i64 1
store float %173, float* %175
%176 = load float, float* %21
%177 = load float*, float** %8
%178 = load i32, i32* %15
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %177, i64 %179
store float %176, float* %180
store i32 1, i32* %13
br label %181
181: ; preds = %217, %165
%182 = load i32, i32* %13
%183 = load i32, i32* %9
%184 = icmp sle i32 %182, %183
br i1 %184, label %185, label %220
185: ; preds = %181
%186 = load float**, float*** %7
%187 = getelementptr inbounds float*, float** %186, i64 1
%188 = load float*, float** %187
%189 = load i32, i32* %13
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %188, i64 %190
%192 = load float, float* %191
store float %192, float* %21
%193 = load float**, float*** %7
%194 = load i32, i32* %15
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float*, float** %193, i64 %195
%197 = load float*, float** %196
%198 = load i32, i32* %13
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %197, i64 %199
%201 = load float, float* %200
%202 = load float**, float*** %7
%203 = getelementptr inbounds float*, float** %202, i64 1
%204 = load float*, float** %203
%205 = load i32, i32* %13
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
store float %201, float* %207
%208 = load float, float* %21
%209 = load float**, float*** %7
%210 = load i32, i32* %15
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float*, float** %209, i64 %211
%213 = load float*, float** %212
%214 = load i32, i32* %13
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* %213, i64 %215
store float %208, float* %216
br label %217
217: ; preds = %185
%218 = load i32, i32* %13
%219 = add nsw i32 %218, 1
store i32 %219, i32* %13
br label %181
220: ; preds = %181
br label %387
221: ; preds = %132
%222 = load i32*, i32** %12
%223 = load i32, i32* %222
%224 = icmp sge i32 %223, 5000
br i1 %224, label %225, label %227
225: ; preds = %221
%226 = call i32 @nrerror(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
br label %227
227: ; preds = %225, %221
%228 = load i32*, i32** %12
%229 = load i32, i32* %228
%230 = add nsw i32 %229, 2
store i32 %230, i32* %228
%231 = load float**, float*** %7
%232 = load float*, float** %8
%233 = load float*, float** %24
%234 = load i32, i32* %9
%235 = load float (float*)*, float (float*)** %11
%236 = load i32, i32* %14
%237 = call float @amotry(float** %231, float* %232, float* %233, i32 %234, float (float*)* %235, i32 %236, float -1.000000e+00)
store float %237, float* %23
%238 = load float, float* %23
%239 = load float*, float** %8
%240 = load i32, i32* %15
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %239, i64 %241
%243 = load float, float* %242
%244 = fcmp ole float %238, %243
br i1 %244, label %245, label %253
245: ; preds = %227
%246 = load float**, float*** %7
%247 = load float*, float** %8
%248 = load float*, float** %24
%249 = load i32, i32* %9
%250 = load float (float*)*, float (float*)** %11
%251 = load i32, i32* %14
%252 = call float @amotry(float** %246, float* %247, float* %248, i32 %249, float (float*)* %250, i32 %251, float 2.000000e+00)
store float %252, float* %23
br label %386
253: ; preds = %227
%254 = load float, float* %23
%255 = load float*, float** %8
%256 = load i32, i32* %16
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %255, i64 %257
%259 = load float, float* %258
%260 = fcmp oge float %254, %259
br i1 %260, label %261, label %381
261: ; preds = %253
%262 = load float*, float** %8
%263 = load i32, i32* %14
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %262, i64 %264
%266 = load float, float* %265
store float %266, float* %22
%267 = load float**, float*** %7
%268 = load float*, float** %8
%269 = load float*, float** %24
%270 = load i32, i32* %9
%271 = load float (float*)*, float (float*)** %11
%272 = load i32, i32* %14
%273 = call float @amotry(float** %267, float* %268, float* %269, i32 %270, float (float*)* %271, i32 %272, float 5.000000e-01)
store float %273, float* %23
%274 = load float, float* %23
%275 = load float, float* %22
%276 = fcmp oge float %274, %275
br i1 %276, label %277, label %380
277: ; preds = %261
store i32 1, i32* %13
br label %278
278: ; preds = %338, %277
%279 = load i32, i32* %13
%280 = load i32, i32* %18
%281 = icmp sle i32 %279, %280
br i1 %281, label %282, label %341
282: ; preds = %278
%283 = load i32, i32* %13
%284 = load i32, i32* %15
%285 = icmp ne i32 %283, %284
br i1 %285, label %286, label %337
286: ; preds = %282
store i32 1, i32* %17
br label %287
287: ; preds = %326, %286
%288 = load i32, i32* %17
%289 = load i32, i32* %9
%290 = icmp sle i32 %288, %289
br i1 %290, label %291, label %329
291: ; preds = %287
%292 = load float**, float*** %7
%293 = load i32, i32* %13
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float*, float** %292, i64 %294
%296 = load float*, float** %295
%297 = load i32, i32* %17
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %296, i64 %298
%300 = load float, float* %299
%301 = load float**, float*** %7
%302 = load i32, i32* %15
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds float*, float** %301, i64 %303
%305 = load float*, float** %304
%306 = load i32, i32* %17
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %305, i64 %307
%309 = load float, float* %308
%310 = fadd float %300, %309
%311 = fpext float %310 to double
%312 = fmul double 5.000000e-01, %311
%313 = fptrunc double %312 to float
%314 = load float*, float** %24
%315 = load i32, i32* %17
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
store float %313, float* %317
%318 = load float**, float*** %7
%319 = load i32, i32* %13
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds float*, float** %318, i64 %320
%322 = load float*, float** %321
%323 = load i32, i32* %17
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %322, i64 %324
store float %313, float* %325
br label %326
326: ; preds = %291
%327 = load i32, i32* %17
%328 = add nsw i32 %327, 1
store i32 %328, i32* %17
br label %287
329: ; preds = %287
%330 = load float (float*)*, float (float*)** %11
%331 = load float*, float** %24
%332 = call float %330(float* %331)
%333 = load float*, float** %8
%334 = load i32, i32* %13
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
store float %332, float* %336
br label %337
337: ; preds = %329, %282
br label %338
338: ; preds = %337
%339 = load i32, i32* %13
%340 = add nsw i32 %339, 1
store i32 %340, i32* %13
br label %278
341: ; preds = %278
%342 = load i32, i32* %9
%343 = load i32*, i32** %12
%344 = load i32, i32* %343
%345 = add nsw i32 %344, %342
store i32 %345, i32* %343
store i32 1, i32* %17
br label %346
346: ; preds = %376, %341
%347 = load i32, i32* %17
%348 = load i32, i32* %9
%349 = icmp sle i32 %347, %348
br i1 %349, label %350, label %379
350: ; preds = %346
store float 0.000000e+00, float* %20
store i32 1, i32* %13
br label %351
351: ; preds = %367, %350
%352 = load i32, i32* %13
%353 = load i32, i32* %18
%354 = icmp sle i32 %352, %353
br i1 %354, label %355, label %370
355: ; preds = %351
%356 = load float**, float*** %7
%357 = load i32, i32* %13
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float*, float** %356, i64 %358
%360 = load float*, float** %359
%361 = load i32, i32* %17
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %360, i64 %362
%364 = load float, float* %363
%365 = load float, float* %20
%366 = fadd float %365, %364
store float %366, float* %20
br label %367
367: ; preds = %355
%368 = load i32, i32* %13
%369 = add nsw i32 %368, 1
store i32 %369, i32* %13
br label %351
370: ; preds = %351
%371 = load float, float* %20
%372 = load float*, float** %24
%373 = load i32, i32* %17
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %372, i64 %374
store float %371, float* %375
br label %376
376: ; preds = %370
%377 = load i32, i32* %17
%378 = add nsw i32 %377, 1
store i32 %378, i32* %17
br label %346
379: ; preds = %346
br label %380
380: ; preds = %379, %261
br label %385
381: ; preds = %253
%382 = load i32*, i32** %12
%383 = load i32, i32* %382
%384 = add nsw i32 %383, -1
store i32 %384, i32* %382
br label %385
385: ; preds = %381, %380
br label %386
386: ; preds = %385, %245
br label %64
387: ; preds = %220
%388 = load float*, float** %24
%389 = load i32, i32* %9
%390 = call i32 @free_vector(float* %388, i32 1, i32 %389)
ret void
}

LLVM IR (-O2):
@.str = [14 x i8] c"NMAX exceeded\00"
define void @amoeba(float** %0, float* %1, i32 %2, float %3, float (float*)* %4, i32* nocapture %5) {
%7 = tail call float* @vector(i32 1, i32 %2)
store i32 0, i32* %5
%8 = icmp slt i32 %2, 1
br i1 %8, label %9, label %12
9: ; preds = %6
%10 = add nsw i32 %2, 1
%11 = add nsw i32 %2, 2
br label %25
12: ; preds = %6
%13 = add nuw i32 %2, 2
%14 = add nuw nsw i32 %2, 1
%15 = zext i32 %14 to i64
%16 = zext i32 %13 to i64
%17 = add nsw i64 %16, -1
%18 = add nsw i64 %16, -2
%19 = and i64 %17, 3
%20 = icmp ult i64 %18, 3
%21 = and i64 %17, -4
%22 = icmp eq i64 %19, 0
br label %23
23: ; preds = %99, %12
%24 = phi i64 [ 1, %12 ], [ %102, %99 ]
br i1 %20, label %83, label %53
25: ; preds = %99, %9
%26 = phi i32 [ %11, %9 ], [ %13, %99 ]
%27 = phi i32 [ %10, %9 ], [ %14, %99 ]
%28 = getelementptr inbounds float, float* %1, i64 1
%29 = getelementptr inbounds float, float* %1, i64 2
%30 = icmp slt i32 %2, 0
%31 = call i32 @llvm.smax.i32(i32 %27, i32 1)
%32 = add nuw i32 %31, 1
%33 = zext i32 %32 to i64
%34 = zext i32 %26 to i64
%35 = zext i32 %27 to i64
%36 = zext i32 %27 to i64
%37 = getelementptr float, float* %7, i64 1
%38 = getelementptr float, float* %7, i64 %35
%39 = add nsw i64 %35, -1
%40 = add nsw i64 %34, -1
%41 = add nsw i64 %34, -2
%42 = icmp ult i64 %39, 8
%43 = and i64 %39, -8
%44 = or i64 %43, 1
%45 = icmp eq i64 %39, %43
%46 = and i64 %35, 1
%47 = icmp eq i64 %46, 0
%48 = sub nsw i64 0, %35
%49 = and i64 %40, 3
%50 = icmp ult i64 %41, 3
%51 = and i64 %40, -4
%52 = icmp eq i64 %49, 0
br label %104
53: ; preds = %23, %53
%54 = phi i64 [ %80, %53 ], [ 1, %23 ]
%55 = phi float [ %79, %53 ], [ 0.000000e+00, %23 ]
%56 = phi i64 [ %81, %53 ], [ 0, %23 ]
%57 = getelementptr inbounds float*, float** %0, i64 %54
%58 = load float*, float** %57
%59 = getelementptr inbounds float, float* %58, i64 %24
%60 = load float, float* %59
%61 = fadd float %55, %60
%62 = add nuw nsw i64 %54, 1
%63 = getelementptr inbounds float*, float** %0, i64 %62
%64 = load float*, float** %63
%65 = getelementptr inbounds float, float* %64, i64 %24
%66 = load float, float* %65
%67 = fadd float %61, %66
%68 = add nuw nsw i64 %54, 2
%69 = getelementptr inbounds float*, float** %0, i64 %68
%70 = load float*, float** %69
%71 = getelementptr inbounds float, float* %70, i64 %24
%72 = load float, float* %71
%73 = fadd float %67, %72
%74 = add nuw nsw i64 %54, 3
%75 = getelementptr inbounds float*, float** %0, i64 %74
%76 = load float*, float** %75
%77 = getelementptr inbounds float, float* %76, i64 %24
%78 = load float, float* %77
%79 = fadd float %73, %78
%80 = add nuw nsw i64 %54, 4
%81 = add i64 %56, 4
%82 = icmp eq i64 %81, %21
br i1 %82, label %83, label %53
83: ; preds = %53, %23
%84 = phi float [ undef, %23 ], [ %79, %53 ]
%85 = phi i64 [ 1, %23 ], [ %80, %53 ]
%86 = phi float [ 0.000000e+00, %23 ], [ %79, %53 ]
br i1 %22, label %99, label %87
87: ; preds = %83, %87
%88 = phi i64 [ %96, %87 ], [ %85, %83 ]
%89 = phi float [ %95, %87 ], [ %86, %83 ]
%90 = phi i64 [ %97, %87 ], [ 0, %83 ]
%91 = getelementptr inbounds float*, float** %0, i64 %88
%92 = load float*, float** %91
%93 = getelementptr inbounds float, float* %92, i64 %24
%94 = load float, float* %93
%95 = fadd float %89, %94
%96 = add nuw nsw i64 %88, 1
%97 = add i64 %90, 1
%98 = icmp eq i64 %97, %19
br i1 %98, label %99, label %87
99: ; preds = %87, %83
%100 = phi float [ %84, %83 ], [ %95, %87 ]
%101 = getelementptr inbounds float, float* %7, i64 %24
store float %100, float* %101
%102 = add nuw nsw i64 %24, 1
%103 = icmp eq i64 %102, %15
br i1 %103, label %25, label %23
104: ; preds = %413, %25
%105 = load float, float* %28
%106 = load float, float* %29
%107 = fcmp ogt float %105, %106
%108 = select i1 %107, i32 2, i32 1
%109 = select i1 %107, i32 1, i32 2
br i1 %30, label %148, label %110
110: ; preds = %104, %138
%111 = phi float [ %143, %138 ], [ %105, %104 ]
%112 = phi float [ %140, %138 ], [ %105, %104 ]
%113 = phi i64 [ %136, %138 ], [ 1, %104 ]
%114 = phi i32 [ %135, %138 ], [ %109, %104 ]
%115 = phi i32 [ %119, %138 ], [ 1, %104 ]
%116 = phi i32 [ %134, %138 ], [ %108, %104 ]
%117 = fcmp ugt float %112, %111
%118 = trunc i64 %113 to i32
%119 = select i1 %117, i32 %115, i32 %118
%120 = sext i32 %114 to i64
%121 = getelementptr inbounds float, float* %1, i64 %120
%122 = load float, float* %121
%123 = fcmp ogt float %112, %122
br i1 %123, label %133, label %124
124: ; preds = %110
%125 = sext i32 %116 to i64
%126 = getelementptr inbounds float, float* %1, i64 %125
%127 = load float, float* %126
%128 = fcmp ule float %112, %127
%129 = zext i32 %114 to i64
%130 = icmp eq i64 %113, %129
%131 = select i1 %128, i1 true, i1 %130
%132 = select i1 %131, i32 %116, i32 %118
br label %133
133: ; preds = %124, %110
%134 = phi i32 [ %114, %110 ], [ %132, %124 ]
%135 = phi i32 [ %118, %110 ], [ %114, %124 ]
%136 = add nuw nsw i64 %113, 1
%137 = icmp eq i64 %136, %33
br i1 %137, label %144, label %138
138: ; preds = %133
%139 = getelementptr inbounds float, float* %1, i64 %136
%140 = load float, float* %139
%141 = sext i32 %119 to i64
%142 = getelementptr inbounds float, float* %1, i64 %141
%143 = load float, float* %142
br label %110
144: ; preds = %133
%145 = sext i32 %119 to i64
%146 = getelementptr inbounds float, float* %1, i64 %145
%147 = load float, float* %146
br label %148
148: ; preds = %104, %144
%149 = phi float [ %147, %144 ], [ %105, %104 ]
%150 = phi i32 [ %134, %144 ], [ %108, %104 ]
%151 = phi i32 [ %119, %144 ], [ 1, %104 ]
%152 = phi i32 [ %135, %144 ], [ %109, %104 ]
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %1, i64 %153
%155 = load float, float* %154
%156 = sext i32 %151 to i64
%157 = getelementptr inbounds float, float* %1, i64 %156
%158 = fsub float %155, %149
%159 = tail call double @fabs(float %158)
%160 = fmul double %159, 2.000000e+00
%161 = load float, float* %154
%162 = tail call double @fabs(float %161)
%163 = load float, float* %157
%164 = tail call double @fabs(float %163)
%165 = fadd double %162, %164
%166 = fadd double %165, 1.000000e-10
%167 = fdiv double %160, %166
%168 = fptrunc double %167 to float
%169 = fcmp olt float %168, %3
br i1 %169, label %170, label %291
170: ; preds = %148
%171 = load float, float* %28
%172 = load float, float* %157
store float %172, float* %28
store float %171, float* %157
br i1 %8, label %471, label %173
173: ; preds = %170
%174 = getelementptr inbounds float*, float** %0, i64 1
%175 = load float*, float** %174
%176 = getelementptr inbounds float*, float** %0, i64 %156
%177 = load float*, float** %176
%178 = zext i32 %27 to i64
%179 = add nsw i64 %35, -1
%180 = icmp ult i64 %179, 8
br i1 %180, label %263, label %181
181: ; preds = %173
%182 = getelementptr float, float* %175, i64 1
%183 = getelementptr float, float* %175, i64 %35
%184 = getelementptr float, float* %177, i64 1
%185 = getelementptr float, float* %177, i64 %35
%186 = icmp ult float* %182, %185
%187 = icmp ult float* %184, %183
%188 = and i1 %186, %187
br i1 %188, label %263, label %189
189: ; preds = %181
%190 = and i64 %179, -8
%191 = or i64 %190, 1
%192 = add nsw i64 %190, -8
%193 = lshr exact i64 %192, 3
%194 = add nuw nsw i64 %193, 1
%195 = and i64 %194, 1
%196 = icmp eq i64 %192, 0
br i1 %196, label %241, label %197
197: ; preds = %189
%198 = and i64 %194, 4611686018427387902
br label %199
199: ; preds = %199, %197
%200 = phi i64 [ 0, %197 ], [ %236, %199 ]
%201 = phi i64 [ 0, %197 ], [ %237, %199 ]
%202 = or i64 %200, 1
%203 = getelementptr inbounds float, float* %175, i64 %202
%204 = bitcast float* %203 to <4 x float>*
%205 = load <4 x float>, <4 x float>* %204
%206 = getelementptr inbounds float, float* %203, i64 4
%207 = bitcast float* %206 to <4 x float>*
%208 = load <4 x float>, <4 x float>* %207
%209 = getelementptr inbounds float, float* %177, i64 %202
%210 = bitcast float* %209 to <4 x float>*
%211 = load <4 x float>, <4 x float>* %210
%212 = getelementptr inbounds float, float* %209, i64 4
%213 = bitcast float* %212 to <4 x float>*
%214 = load <4 x float>, <4 x float>* %213
%215 = bitcast float* %203 to <4 x float>*
store <4 x float> %211, <4 x float>* %215
%216 = bitcast float* %206 to <4 x float>*
store <4 x float> %214, <4 x float>* %216
%217 = bitcast float* %209 to <4 x float>*
store <4 x float> %205, <4 x float>* %217
%218 = bitcast float* %212 to <4 x float>*
store <4 x float> %208, <4 x float>* %218
%219 = or i64 %200, 9
%220 = getelementptr inbounds float, float* %175, i64 %219
%221 = bitcast float* %220 to <4 x float>*
%222 = load <4 x float>, <4 x float>* %221
%223 = getelementptr inbounds float, float* %220, i64 4
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = getelementptr inbounds float, float* %177, i64 %219
%227 = bitcast float* %226 to <4 x float>*
%228 = load <4 x float>, <4 x float>* %227
%229 = getelementptr inbounds float, float* %226, i64 4
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = bitcast float* %220 to <4 x float>*
store <4 x float> %228, <4 x float>* %232
%233 = bitcast float* %223 to <4 x float>*
store <4 x float> %231, <4 x float>* %233
%234 = bitcast float* %226 to <4 x float>*
store <4 x float> %222, <4 x float>* %234
%235 = bitcast float* %229 to <4 x float>*
store <4 x float> %225, <4 x float>* %235
%236 = add nuw i64 %200, 16
%237 = add i64 %201, 2
%238 = icmp eq i64 %237, %198
br i1 %238, label %239, label %199
239: ; preds = %199
%240 = or i64 %236, 1
br label %241
241: ; preds = %239, %189
%242 = phi i64 [ 1, %189 ], [ %240, %239 ]
%243 = icmp eq i64 %195, 0
br i1 %243, label %261, label %244
244: ; preds = %241
%245 = getelementptr inbounds float, float* %175, i64 %242
%246 = bitcast float* %245 to <4 x float>*
%247 = load <4 x float>, <4 x float>* %246
%248 = getelementptr inbounds float, float* %245, i64 4
%249 = bitcast float* %248 to <4 x float>*
%250 = load <4 x float>, <4 x float>* %249
%251 = getelementptr inbounds float, float* %177, i64 %242
%252 = bitcast float* %251 to <4 x float>*
%253 = load <4 x float>, <4 x float>* %252
%254 = getelementptr inbounds float, float* %251, i64 4
%255 = bitcast float* %254 to <4 x float>*
%256 = load <4 x float>, <4 x float>* %255
%257 = bitcast float* %245 to <4 x float>*
store <4 x float> %253, <4 x float>* %257
%258 = bitcast float* %248 to <4 x float>*
store <4 x float> %256, <4 x float>* %258
%259 = bitcast float* %251 to <4 x float>*
store <4 x float> %247, <4 x float>* %259
%260 = bitcast float* %254 to <4 x float>*
store <4 x float> %250, <4 x float>* %260
br label %261
261: ; preds = %241, %244
%262 = icmp eq i64 %179, %190
br i1 %262, label %471, label %263
263: ; preds = %181, %173, %261
%264 = phi i64 [ 1, %181 ], [ 1, %173 ], [ %191, %261 ]
%265 = xor i64 %264, -1
%266 = and i64 %35, 1
%267 = icmp eq i64 %266, 0
br i1 %267, label %268, label %274
268: ; preds = %263
%269 = getelementptr inbounds float, float* %175, i64 %264
%270 = load float, float* %269
%271 = getelementptr inbounds float, float* %177, i64 %264
%272 = load float, float* %271
store float %272, float* %269
store float %270, float* %271
%273 = add nuw nsw i64 %264, 1
br label %274
274: ; preds = %268, %263
%275 = phi i64 [ %264, %263 ], [ %273, %268 ]
%276 = sub nsw i64 0, %35
%277 = icmp eq i64 %265, %276
br i1 %277, label %471, label %278
278: ; preds = %274, %278
%279 = phi i64 [ %289, %278 ], [ %275, %274 ]
%280 = getelementptr inbounds float, float* %175, i64 %279
%281 = load float, float* %280
%282 = getelementptr inbounds float, float* %177, i64 %279
%283 = load float, float* %282
store float %283, float* %280
store float %281, float* %282
%284 = add nuw nsw i64 %279, 1
%285 = getelementptr inbounds float, float* %175, i64 %284
%286 = load float, float* %285
%287 = getelementptr inbounds float, float* %177, i64 %284
%288 = load float, float* %287
store float %288, float* %285
store float %286, float* %287
%289 = add nuw nsw i64 %279, 2
%290 = icmp eq i64 %289, %178
br i1 %290, label %471, label %278
291: ; preds = %148
%292 = load i32, i32* %5
%293 = icmp sgt i32 %292, 4999
br i1 %293, label %294, label %297
294: ; preds = %291
%295 = tail call i32 @nrerror(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
%296 = load i32, i32* %5
br label %297
297: ; preds = %294, %291
%298 = phi i32 [ %296, %294 ], [ %292, %291 ]
%299 = add nsw i32 %298, 2
store i32 %299, i32* %5
%300 = tail call float @amotry(float** %0, float* %1, float* %7, i32 %2, float (float*)* %4, i32 %152, float -1.000000e+00)
%301 = load float, float* %157
%302 = fcmp ugt float %300, %301
br i1 %302, label %305, label %303
303: ; preds = %297
%304 = tail call float @amotry(float** %0, float* %1, float* %7, i32 %2, float (float*)* %4, i32 %152, float 2.000000e+00)
br label %413
305: ; preds = %297
%306 = sext i32 %150 to i64
%307 = getelementptr inbounds float, float* %1, i64 %306
%308 = load float, float* %307
%309 = fcmp ult float %300, %308
br i1 %309, label %468, label %310
310: ; preds = %305
%311 = load float, float* %154
%312 = tail call float @amotry(float** %0, float* %1, float* %7, i32 %2, float (float*)* %4, i32 %152, float 5.000000e-01)
%313 = fcmp ult float %312, %311
br i1 %313, label %413, label %314
314: ; preds = %310
br i1 %30, label %410, label %315
315: ; preds = %314
%316 = getelementptr inbounds float*, float** %0, i64 %156
%317 = zext i32 %151 to i64
br label %318
318: ; preds = %315, %407
%319 = phi i64 [ 1, %315 ], [ %408, %407 ]
%320 = icmp eq i64 %319, %317
br i1 %320, label %407, label %321
321: ; preds = %318
br i1 %8, label %404, label %322
322: ; preds = %321
%323 = getelementptr inbounds float*, float** %0, i64 %319
%324 = load float*, float** %323
%325 = load float*, float** %316
br i1 %42, label %370, label %326
326: ; preds = %322
%327 = getelementptr float, float* %324, i64 1
%328 = getelementptr float, float* %324, i64 %35
%329 = getelementptr float, float* %325, i64 1
%330 = getelementptr float, float* %325, i64 %35
%331 = icmp ult float* %37, %328
%332 = icmp ult float* %327, %38
%333 = and i1 %331, %332
%334 = icmp ult float* %37, %330
%335 = icmp ult float* %329, %38
%336 = and i1 %334, %335
%337 = or i1 %333, %336
%338 = icmp ult float* %327, %330
%339 = icmp ult float* %329, %328
%340 = and i1 %338, %339
%341 = or i1 %337, %340
br i1 %341, label %370, label %342
342: ; preds = %326, %342
%343 = phi i64 [ %367, %342 ], [ 0, %326 ]
%344 = or i64 %343, 1
%345 = getelementptr inbounds float, float* %324, i64 %344
%346 = bitcast float* %345 to <4 x float>*
%347 = load <4 x float>, <4 x float>* %346
%348 = getelementptr inbounds float, float* %345, i64 4
%349 = bitcast float* %348 to <4 x float>*
%350 = load <4 x float>, <4 x float>* %349
%351 = getelementptr inbounds float, float* %325, i64 %344
%352 = bitcast float* %351 to <4 x float>*
%353 = load <4 x float>, <4 x float>* %352
%354 = getelementptr inbounds float, float* %351, i64 4
%355 = bitcast float* %354 to <4 x float>*
%356 = load <4 x float>, <4 x float>* %355
%357 = fadd <4 x float> %347, %353
%358 = fadd <4 x float> %350, %356
%359 = fmul <4 x float> %357, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%360 = fmul <4 x float> %358, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%361 = getelementptr inbounds float, float* %7, i64 %344
%362 = bitcast float* %361 to <4 x float>*
store <4 x float> %359, <4 x float>* %362
%363 = getelementptr inbounds float, float* %361, i64 4
%364 = bitcast float* %363 to <4 x float>*
store <4 x float> %360, <4 x float>* %364
%365 = bitcast float* %345 to <4 x float>*
store <4 x float> %359, <4 x float>* %365
%366 = bitcast float* %348 to <4 x float>*
store <4 x float> %360, <4 x float>* %366
%367 = add nuw i64 %343, 8
%368 = icmp eq i64 %367, %43
br i1 %368, label %369, label %342
369: ; preds = %342
br i1 %45, label %404, label %370
370: ; preds = %326, %322, %369
%371 = phi i64 [ 1, %326 ], [ 1, %322 ], [ %44, %369 ]
%372 = xor i64 %371, -1
br i1 %47, label %373, label %382
373: ; preds = %370
%374 = getelementptr inbounds float, float* %324, i64 %371
%375 = load float, float* %374
%376 = getelementptr inbounds float, float* %325, i64 %371
%377 = load float, float* %376
%378 = fadd float %375, %377
%379 = fmul float %378, 5.000000e-01
%380 = getelementptr inbounds float, float* %7, i64 %371
store float %379, float* %380
store float %379, float* %374
%381 = add nuw nsw i64 %371, 1
br label %382
382: ; preds = %373, %370
%383 = phi i64 [ %371, %370 ], [ %381, %373 ]
%384 = icmp eq i64 %372, %48
br i1 %384, label %404, label %385
385: ; preds = %382, %385
%386 = phi i64 [ %402, %385 ], [ %383, %382 ]
%387 = getelementptr inbounds float, float* %324, i64 %386
%388 = load float, float* %387
%389 = getelementptr inbounds float, float* %325, i64 %386
%390 = load float, float* %389
%391 = fadd float %388, %390
%392 = fmul float %391, 5.000000e-01
%393 = getelementptr inbounds float, float* %7, i64 %386
store float %392, float* %393
store float %392, float* %387
%394 = add nuw nsw i64 %386, 1
%395 = getelementptr inbounds float, float* %324, i64 %394
%396 = load float, float* %395
%397 = getelementptr inbounds float, float* %325, i64 %394
%398 = load float, float* %397
%399 = fadd float %396, %398
%400 = fmul float %399, 5.000000e-01
%401 = getelementptr inbounds float, float* %7, i64 %394
store float %400, float* %401
store float %400, float* %395
%402 = add nuw nsw i64 %386, 2
%403 = icmp eq i64 %402, %35
br i1 %403, label %404, label %385
404: ; preds = %382, %385, %369, %321
%405 = tail call float %4(float* %7)
%406 = getelementptr inbounds float, float* %1, i64 %319
store float %405, float* %406
br label %407
407: ; preds = %318, %404
%408 = add nuw nsw i64 %319, 1
%409 = icmp eq i64 %408, %34
br i1 %409, label %410, label %318
410: ; preds = %407, %314
%411 = load i32, i32* %5
%412 = add nsw i32 %411, %2
store i32 %412, i32* %5
br i1 %8, label %413, label %414
413: ; preds = %463, %410, %468, %310, %303
br label %104
414: ; preds = %410, %463
%415 = phi i64 [ %466, %463 ], [ 1, %410 ]
br i1 %30, label %463, label %416
416: ; preds = %414
br i1 %50, label %447, label %417
417: ; preds = %416, %417
%418 = phi i64 [ %444, %417 ], [ 1, %416 ]
%419 = phi float [ %443, %417 ], [ 0.000000e+00, %416 ]
%420 = phi i64 [ %445, %417 ], [ 0, %416 ]
%421 = getelementptr inbounds float*, float** %0, i64 %418
%422 = load float*, float** %421
%423 = getelementptr inbounds float, float* %422, i64 %415
%424 = load float, float* %423
%425 = fadd float %419, %424
%426 = add nuw nsw i64 %418, 1
%427 = getelementptr inbounds float*, float** %0, i64 %426
%428 = load float*, float** %427
%429 = getelementptr inbounds float, float* %428, i64 %415
%430 = load float, float* %429
%431 = fadd float %425, %430
%432 = add nuw nsw i64 %418, 2
%433 = getelementptr inbounds float*, float** %0, i64 %432
%434 = load float*, float** %433
%435 = getelementptr inbounds float, float* %434, i64 %415
%436 = load float, float* %435
%437 = fadd float %431, %436
%438 = add nuw nsw i64 %418, 3
%439 = getelementptr inbounds float*, float** %0, i64 %438
%440 = load float*, float** %439
%441 = getelementptr inbounds float, float* %440, i64 %415
%442 = load float, float* %441
%443 = fadd float %437, %442
%444 = add nuw nsw i64 %418, 4
%445 = add i64 %420, 4
%446 = icmp eq i64 %445, %51
br i1 %446, label %447, label %417
447: ; preds = %417, %416
%448 = phi float [ undef, %416 ], [ %443, %417 ]
%449 = phi i64 [ 1, %416 ], [ %444, %417 ]
%450 = phi float [ 0.000000e+00, %416 ], [ %443, %417 ]
br i1 %52, label %463, label %451
451: ; preds = %447, %451
%452 = phi i64 [ %460, %451 ], [ %449, %447 ]
%453 = phi float [ %459, %451 ], [ %450, %447 ]
%454 = phi i64 [ %461, %451 ], [ 0, %447 ]
%455 = getelementptr inbounds float*, float** %0, i64 %452
%456 = load float*, float** %455
%457 = getelementptr inbounds float, float* %456, i64 %415
%458 = load float, float* %457
%459 = fadd float %453, %458
%460 = add nuw nsw i64 %452, 1
%461 = add i64 %454, 1
%462 = icmp eq i64 %461, %49
br i1 %462, label %463, label %451
463: ; preds = %447, %451, %414
%464 = phi float [ 0.000000e+00, %414 ], [ %448, %447 ], [ %459, %451 ]
%465 = getelementptr inbounds float, float* %7, i64 %415
store float %464, float* %465
%466 = add nuw nsw i64 %415, 1
%467 = icmp eq i64 %466, %36
br i1 %467, label %413, label %414
468: ; preds = %305
%469 = load i32, i32* %5
%470 = add nsw i32 %469, -1
store i32 %470, i32* %5
br label %413
471: ; preds = %274, %278, %261, %170
%472 = tail call i32 @free_vector(float* %7, i32 1, i32 %2)
ret void
}