#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(float *);
scalar_t__ malloc(int);
float stub1(float *);
void dhill(float **p, float *y, int ndim, float ftol, float (*funk)(float[]),
           int *nfunk) {
  float dhtry(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 = (float *)malloc(ndim * sizeof(float));
  *nfunk = 0;
  for (j = 0; j < ndim; j++) {
    for (sum = 0.0, i = 0; i < mpts; i++)
      sum += p[i][j];
    psum[j] = sum;
  }
  for (;;) {
    ilo = 0;
    ihi = y[0] > y[1] ? (inhi = 1, 0) : (inhi = 0, 1);
    for (i = 0; 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 || *nfunk >= 5000) {
      {
        swap = (y[0]);
        (y[0]) = (y[ilo]);
        (y[ilo]) = swap;
      }
      for (i = 0; i < ndim; i++) {
        swap = (p[0][i]);
        (p[0][i]) = (p[ilo][i]);
        (p[ilo][i]) = swap;
      }
      break;
    }
    *nfunk += 2;
    ytry = dhtry(p, y, psum, ndim, funk, ihi, -1.0);
    if (ytry <= y[ilo])
      ytry = dhtry(p, y, psum, ndim, funk, ihi, 2.0);
    else if (ytry >= y[inhi]) {
      ysave = y[ihi];
      ytry = dhtry(p, y, psum, ndim, funk, ihi, 0.5);
      if (ytry >= ysave) {
        for (i = 0; i < mpts; i++) {
          if (i != ilo) {
            for (j = 0; j < ndim; j++)
              p[i][j] = psum[j] = 0.5 * (p[i][j] + p[ilo][j]);
            y[i] = (*funk)(psum);
          }
        }
        *nfunk += ndim;
        for (j = 0; j < ndim; j++) {
          for (sum = 0.0, i = 0; i < mpts; i++)
            sum += p[i][j];
          psum[j] = sum;
        }
      }
    } else
      --(*nfunk);
  }
  free(psum);
}


x86 assembly (clang, -O0):
<dhill>:
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)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1204 <dhill+0xc4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    11e4 <dhill+0xa4>
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    11ab <dhill+0x6b>
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    1190 <dhill+0x50>
jmp    1209 <dhill+0xc9>
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
jbe    1237 <dhill+0xf7>
movl   $0x1,-0x38(%rbp)
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    1246 <dhill+0x106>
movl   $0x0,-0x38(%rbp)
mov    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1301 <dhill+0x1c1>
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     1288 <dhill+0x148>
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    12b8 <dhill+0x178>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    12ee <dhill+0x1ae>
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    12e9 <dhill+0x1a9>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     12e9 <dhill+0x1a9>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    12ee <dhill+0x1ae>
jmp    12f3 <dhill+0x1b3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1253 <dhill+0x113>
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   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xcdd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1040 <fabs@plt>
movsd  -0x78(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
addsd  %xmm2,%xmm1
movsd  0xc8a(%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
ja     13aa <dhill+0x26a>
mov    -0x28(%rbp),%rax
cmpl   $0x1388,(%rax)
jl     1458 <dhill+0x318>
mov    -0x10(%rbp),%rax
movss  (%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,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1453 <dhill+0x313>
mov    -0x8(%rbp),%rax
mov    (%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    (%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    13e5 <dhill+0x2a5>
jmp    16a5 <dhill+0x565>
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  0xb96(%rip),%xmm0
call   1060 <dhtry@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     14d5 <dhill+0x395>
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  0xb5a(%rip),%xmm0
call   1060 <dhtry@plt>
movss  %xmm0,-0x54(%rbp)
jmp    16a0 <dhill+0x560>
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jb     1690 <dhill+0x550>
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  0xaff(%rip),%xmm0
call   1060 <dhtry@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x50(%rbp),%xmm0
jb     168b <dhill+0x54b>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1600 <dhill+0x4c0>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     15ed <dhill+0x4ad>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15d6 <dhill+0x496>
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  0xa72(%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    155c <dhill+0x41c>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rdi
call   *%rax
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15f2 <dhill+0x4b2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    153d <dhill+0x3fd>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1686 <dhill+0x546>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1666 <dhill+0x526>
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    162d <dhill+0x4ed>
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    1612 <dhill+0x4d2>
jmp    168b <dhill+0x54b>
jmp    169b <dhill+0x55b>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
jmp    16a0 <dhill+0x560>
jmp    1209 <dhill+0xc9>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dhill>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r8,%r14
mov    %rcx,0x10(%rsp)
movss  %xmm0,0x54(%rsp)
mov    %edx,%ebp
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0x0(,%rbp,4),%edi
call   1050 <malloc@plt>
mov    %rbp,%r10
mov    %rax,%r15
mov    %r14,0x40(%rsp)
movl   $0x0,(%r14)
lea    0x1(%rbp),%eax
mov    %r10d,%r9d
mov    %eax,%eax
mov    %rax,0x48(%rsp)
test   %r10d,%r10d
jle    1224 <dhill+0xe4>
mov    0x48(%rsp),%rdx
lea    -0x1(%rdx),%r8
mov    %edx,%ecx
and    $0x3,%ecx
and    $0xfffffffc,%edx
xor    %esi,%esi
jmp    11bf <dhill+0x7f>
movss  %xmm0,(%r15,%rsi,4)
add    $0x1,%rsi
cmp    %r9,%rsi
je     1224 <dhill+0xe4>
xorps  %xmm0,%xmm0
xor    %edi,%edi
cmp    $0x3,%r8
jb     1201 <dhill+0xc1>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdi,8),%rbp
mov    0x8(%rbx,%rdi,8),%rax
addss  0x0(%rbp,%rsi,4),%xmm0
addss  (%rax,%rsi,4),%xmm0
mov    0x10(%rbx,%rdi,8),%rax
addss  (%rax,%rsi,4),%xmm0
mov    0x18(%rbx,%rdi,8),%rax
addss  (%rax,%rsi,4),%xmm0
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    11d0 <dhill+0x90>
test   %rcx,%rcx
je     11b0 <dhill+0x70>
lea    (%rbx,%rdi,8),%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%rdi,%rbp,8),%rax
addss  (%rax,%rsi,4),%xmm0
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1210 <dhill+0xd0>
jmp    11b0 <dhill+0x70>
lea    (%r15,%r9,4),%rax
mov    %rax,0x80(%rsp)
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x78(%rsp)
lea    -0x8(%rax),%rdx
mov    %rdx,0x58(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x60(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x30(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x68(%rsp)
mov    %r9,%rcx
neg    %rcx
mov    %rcx,0x90(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x88(%rsp)
mov    %eax,%edi
and    $0xfffffffc,%edi
mov    %r9,0x20(%rsp)
mov    %r10,0x18(%rsp)
mov    %r15,0x38(%rsp)
mov    %rdi,0x70(%rsp)
jmp    12d9 <dhill+0x199>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
mov    0x18(%rsp),%r14
mov    %r14d,%ecx
mov    0x10(%rsp),%r8
mov    %r13d,%r9d
movss  0xd3b(%rip),%xmm0
call   1060 <dhtry@plt>
mov    %r14,%r10
movss  (%r12),%xmm1
xor    %r13d,%r13d
xor    %r15d,%r15d
ucomiss 0x4(%r12),%xmm1
setbe  %r13b
seta   %r15b
test   %r10d,%r10d
js     1370 <dhill+0x230>
xor    %eax,%eax
movaps %xmm1,%xmm0
xor    %r14d,%r14d
mov    0x60(%rsp),%rsi
ucomiss %xmm0,%xmm1
jb     132c <dhill+0x1ec>
jmp    1329 <dhill+0x1e9>
nopl   0x0(%rax)
movss  0x4(%r12,%rax,4),%xmm0
movslq %r14d,%rcx
movss  (%r12,%rcx,4),%xmm1
add    $0x1,%rax
ucomiss %xmm0,%xmm1
jb     132c <dhill+0x1ec>
mov    %eax,%r14d
movslq %r13d,%rcx
ucomiss (%r12,%rcx,4),%xmm0
jbe    1340 <dhill+0x200>
mov    %r13d,%r15d
mov    %eax,%r13d
jmp    1358 <dhill+0x218>
xchg   %ax,%ax
movslq %r15d,%rdx
mov    %r13d,%ecx
cmp    %rcx,%rax
mov    %edx,%ecx
cmovne %eax,%ecx
ucomiss (%r12,%rdx,4),%xmm0
jbe    1358 <dhill+0x218>
mov    %ecx,%r15d
cmp    %rax,%rsi
jne    1310 <dhill+0x1d0>
movslq %r14d,%rax
movss  (%r12,%rax,4),%xmm1
jmp    1373 <dhill+0x233>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
movslq %r13d,%rbp
movss  (%r12,%rbp,4),%xmm0
subss  %xmm1,%xmm0
movslq %r14d,%rax
mov    %rax,0x28(%rsp)
call   1040 <fabs@plt>
addsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %rbp,0x98(%rsp)
movss  (%r12,%rbp,4),%xmm0
call   1040 <fabs@plt>
movsd  %xmm0,0xa0(%rsp)
mov    0x28(%rsp),%rax
movss  (%r12,%rax,4),%xmm0
call   1040 <fabs@plt>
addsd  0xa0(%rsp),%xmm0
addsd  0xc2c(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  0x54(%rsp),%xmm1
ucomiss %xmm0,%xmm1
mov    0x40(%rsp),%rcx
ja     17e7 <dhill+0x6a7>
mov    (%rcx),%eax
cmp    $0x1388,%eax
jge    17e7 <dhill+0x6a7>
add    $0x2,%eax
mov    %eax,(%rcx)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%r8
mov    %r13d,%r9d
movss  0xbda(%rip),%xmm0
call   1060 <dhtry@plt>
mov    0x28(%rsp),%rax
movss  (%r12,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jae    12b0 <dhill+0x170>
movslq %r15d,%rax
ucomiss (%r12,%rax,4),%xmm0
mov    0x88(%rsp),%rbp
jae    1470 <dhill+0x330>
mov    0x40(%rsp),%rax
addl   $0xffffffff,(%rax)
mov    0x18(%rsp),%r10
jmp    12d9 <dhill+0x199>
nopl   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rax
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x38(%rsp),%r15
mov    %r15,%rdx
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%r8
mov    %r13d,%r9d
movss  0xb69(%rip),%xmm0
call   1060 <dhtry@plt>
movss  0xb5c(%rip),%xmm3
mov    0x18(%rsp),%r10
ucomiss 0x8(%rsp),%xmm0
mov    0x20(%rsp),%r8
movaps 0xb56(%rip),%xmm4
jb     12d9 <dhill+0x199>
test   %r10d,%r10d
js     1736 <dhill+0x5f6>
mov    %r14d,%r14d
xor    %r13d,%r13d
mov    %r14,0x8(%rsp)
jmp    1524 <dhill+0x3e4>
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
call   *%r9
movaps 0xb23(%rip),%xmm4
movss  0xb0b(%rip),%xmm3
mov    0x18(%rsp),%r10
mov    0x20(%rsp),%r8
movss  %xmm0,(%r12,%r13,4)
add    $0x1,%r13
cmp    0x48(%rsp),%r13
je     1736 <dhill+0x5f6>
cmp    %r14,%r13
je     1515 <dhill+0x3d5>
test   %r10d,%r10d
mov    0x10(%rsp),%r9
jle    14f0 <dhill+0x3b0>
mov    (%rbx,%r13,8),%rax
mov    0x28(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
cmp    $0x8,%r10d
jae    154d <dhill+0x40d>
xor    %esi,%esi
jmp    16a0 <dhill+0x560>
lea    (%rax,%r8,4),%rsi
lea    (%rcx,%r8,4),%rdi
cmp    %rsi,%r15
setb   %r10b
mov    0x80(%rsp),%rdx
cmp    %rdx,%rax
setb   %r11b
cmp    %rdi,%r15
setb   %r14b
cmp    %rdx,%rcx
setb   %r9b
cmp    %rdi,%rax
setb   %dil
cmp    %rsi,%rcx
setb   %r8b
test   %r11b,%r10b
jne    168e <dhill+0x54e>
and    %r9b,%r14b
jne    168e <dhill+0x54e>
mov    $0x0,%esi
and    %r8b,%dil
mov    0x20(%rsp),%r8
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%r9
jne    16a0 <dhill+0x560>
cmpq   $0x0,0x58(%rsp)
je     1724 <dhill+0x5e4>
mov    0x68(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,(%r15,%rdx,4)
movups %xmm0,0x10(%r15,%rdx,4)
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
movups 0x20(%rax,%rdx,4),%xmm0
movups 0x30(%rax,%rdx,4),%xmm1
movups 0x20(%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x30(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,0x20(%r15,%rdx,4)
movups %xmm0,0x30(%r15,%rdx,4)
movups %xmm2,0x20(%rax,%rdx,4)
movups %xmm0,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    15d0 <dhill+0x490>
testb  $0x1,0x30(%rsp)
je     167b <dhill+0x53b>
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
mulps  %xmm4,%xmm2
mulps  %xmm4,%xmm0
movups %xmm2,(%r15,%rdx,4)
movups %xmm0,0x10(%r15,%rdx,4)
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
mov    0x78(%rsp),%rdx
mov    %rdx,%rsi
cmp    %r8,%rdx
je     14f0 <dhill+0x3b0>
jmp    16a0 <dhill+0x560>
xor    %esi,%esi
mov    0x20(%rsp),%r8
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%r9
nop
mov    %rsi,%rdx
test   $0x1,%r8b
je     16c9 <dhill+0x589>
movss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r15,%rsi,4)
movss  %xmm0,(%rax,%rsi,4)
mov    %rsi,%rdx
or     $0x1,%rdx
not    %rsi
cmp    0x90(%rsp),%rsi
je     14f0 <dhill+0x3b0>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%r15,%rdx,4)
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
addss  0x4(%rcx,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x4(%r15,%rdx,4)
movss  %xmm0,0x4(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r8
jne    16e0 <dhill+0x5a0>
jmp    14f0 <dhill+0x3b0>
xor    %edx,%edx
testb  $0x1,0x30(%rsp)
jne    1649 <dhill+0x509>
jmp    167b <dhill+0x53b>
mov    0x40(%rsp),%rax
add    %r10d,(%rax)
test   %r10d,%r10d
mov    0x70(%rsp),%rdi
jle    12d9 <dhill+0x199>
xor    %eax,%eax
jmp    1766 <dhill+0x626>
xorps  %xmm0,%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
cmp    %r8,%rax
je     12d9 <dhill+0x199>
test   %r10d,%r10d
js     1750 <dhill+0x610>
cmpq   $0x3,0x60(%rsp)
jae    1780 <dhill+0x640>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    17c0 <dhill+0x680>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rcx,8),%rdx
mov    0x8(%rbx,%rcx,8),%rsi
addss  (%rdx,%rax,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
mov    0x10(%rbx,%rcx,8),%rdx
addss  (%rdx,%rax,4),%xmm0
mov    0x18(%rbx,%rcx,8),%rdx
addss  (%rdx,%rax,4),%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    1790 <dhill+0x650>
test   %rbp,%rbp
je     1753 <dhill+0x613>
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
addss  (%rsi,%rax,4),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    17d0 <dhill+0x690>
jmp    1753 <dhill+0x613>
movss  (%r12),%xmm0
mov    0x28(%rsp),%rcx
movss  (%r12,%rcx,4),%xmm1
movss  %xmm1,(%r12)
movss  %xmm0,(%r12,%rcx,4)
mov    0x18(%rsp),%rdx
test   %edx,%edx
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%rbp
jle    195a <dhill+0x81a>
mov    (%rbx),%rax
mov    (%rbx,%rcx,8),%rcx
cmp    $0x8,%edx
jb     1839 <dhill+0x6f9>
lea    (%rcx,%rbp,4),%rdx
cmp    %rdx,%rax
jae    18aa <dhill+0x76a>
lea    (%rax,%rbp,4),%rdx
cmp    %rdx,%rcx
jae    18aa <dhill+0x76a>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%bpl
je     185f <dhill+0x71f>
movss  (%rax,%rdx,4),%xmm0
movss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rax,%rdx,4)
movss  %xmm0,(%rcx,%rdx,4)
or     $0x1,%rdx
add    %rbp,%rsi
je     195a <dhill+0x81a>
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rax,%rdx,4)
movss  %xmm0,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
movss  0x4(%rcx,%rdx,4),%xmm1
movss  %xmm1,0x4(%rax,%rdx,4)
movss  %xmm0,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rbp
jne    1870 <dhill+0x730>
jmp    195a <dhill+0x81a>
mov    %ebp,%edx
and    $0xfffffff8,%edx
cmpq   $0x0,0x58(%rsp)
je     1970 <dhill+0x830>
movabs $0x3ffffffffffffffe,%rbx
ff ff 3f
and    0x30(%rsp),%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups (%rcx,%rsi,4),%xmm2
movups 0x10(%rcx,%rsi,4),%xmm3
movups %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm1
movups 0x20(%rcx,%rsi,4),%xmm2
movups 0x30(%rcx,%rsi,4),%xmm3
movups %xmm2,0x20(%rax,%rsi,4)
movups %xmm3,0x30(%rax,%rsi,4)
movups %xmm0,0x20(%rcx,%rsi,4)
movups %xmm1,0x30(%rcx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbx
jne    18d0 <dhill+0x790>
testb  $0x1,0x30(%rsp)
je     1951 <dhill+0x811>
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups (%rcx,%rsi,4),%xmm2
movups 0x10(%rcx,%rsi,4),%xmm3
movups %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
cmp    %rbp,%rdx
jne    183b <dhill+0x6fb>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %esi,%esi
testb  $0x1,0x30(%rsp)
jne    192d <dhill+0x7ed>
jmp    1951 <dhill+0x811>

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

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