#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 */
float fabs(float);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
float philike(float *, float *, int);
int /*<<< orphan*/ printf(char *, float);
int /*<<< orphan*/ stdout;
float sum_AB_lf(float *, float *, int, int, int);
float iterate_lf(float phi[], float lum[], float weight[], float *A, float *B,
                 float *Asum, float *Bsum, int nsample, int nparam,
                 float tolerance) {
  float sum, minphi;
  float bottom, bottomnumer, bottomdenom;
  float top, topnumer, topdenom;
  float newlike, oldlike;
  int i, k, niter, maxiter;
  maxiter = 300;
  sum = 0.;
  minphi = 1.;
  for (i = 0; i < nparam; i++)
    if (phi[i] < minphi && phi[i] > 0.)
      minphi = phi[i];
  for (i = 0; i < nparam; i++)
    if (phi[i] <= 0.)
      phi[i] = minphi;
  for (i = 0; i < nparam; i++)
    sum += phi[i] * (lum[i + 1] - lum[i]);
  for (i = 0; i < nparam; i++)
    phi[i] /= sum;
  oldlike = 0.;
  for (k = 0; k < nsample; k++)
    Asum[k] = sum_AB_lf(A, phi, k, nsample, nparam);
  for (k = 0; k < nsample; k++)
    Bsum[k] = sum_AB_lf(B, phi, k, nsample, nparam);
  newlike = philike(Asum, Bsum, nsample);
  niter = 0;
  while (fabs(newlike - oldlike) > tolerance && niter < maxiter) {
    printf("like=%f\n", newlike);
    fflush(stdout);
    for (i = 0; i < nparam; i++) {
      top = 0.;
      for (k = 0; k < nsample; k++) {
        topnumer = B[k * nparam + i];
        if (topnumer == 0.)
          topdenom = 1.;
        else
          topdenom = Bsum[k] / phi[i];
        top += weight[k] * topnumer / topdenom;
      }
      if (top == 0.) {
        bottom = 1.;
      } else {
        bottom = 0.;
        for (k = 0; k < nsample; k++) {
          bottomnumer = A[k * nparam + i];
          if (bottomnumer == 0.)
            bottomdenom = 1.;
          else
            bottomdenom = Asum[k];
          bottom += weight[k] * bottomnumer / bottomdenom;
        }
      }
      phi[i] = top / bottom;
    }
    sum = 0.;
    for (i = 0; i < nparam; i++)
      sum += phi[i] * (lum[i + 1] - lum[i]);
    for (i = 0; i < nparam; i++)
      phi[i] /= sum;
    for (k = 0; k < nsample; k++)
      Asum[k] = sum_AB_lf(A, phi, k, nsample, nparam);
    for (k = 0; k < nsample; k++)
      Bsum[k] = sum_AB_lf(B, phi, k, nsample, nparam);
    oldlike = newlike;
    newlike = philike(Asum, Bsum, nsample);
    oldlike = oldlike;
    niter++;
  }
  printf("like=%f\n", newlike);
  fflush(stdout);
  return (newlike);
}


x86 assembly (clang, -O0):
<iterate_lf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
movl   $0x12c,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xe6a(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    120c <iterate_lf+0xbc>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    11f9 <iterate_lf+0xa9>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    11f9 <iterate_lf+0xa9>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    11fe <iterate_lf+0xae>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11a2 <iterate_lf+0x52>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1262 <iterate_lf+0x112>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     124f <iterate_lf+0xff>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1254 <iterate_lf+0x104>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1213 <iterate_lf+0xc3>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    12c1 <iterate_lf+0x171>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1269 <iterate_lf+0x119>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    12fd <iterate_lf+0x1ad>
movss  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12c8 <iterate_lf+0x178>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    134a <iterate_lf+0x1fa>
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x64(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
call   1070 <sum_AB_lf@plt>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    130c <iterate_lf+0x1bc>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    138f <iterate_lf+0x23f>
mov    -0x28(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x64(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
call   1070 <sum_AB_lf@plt>
mov    0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1351 <iterate_lf+0x201>
mov    -0x30(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%edx
call   1040 <philike@plt>
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
call   1050 <fabs@plt>
xor    %eax,%eax
ucomiss -0x34(%rbp),%xmm0
mov    %al,-0x6d(%rbp)
jbe    13d5 <iterate_lf+0x285>
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
setl   %al
mov    %al,-0x6d(%rbp)
mov    -0x6d(%rbp),%al
test   $0x1,%al
jne    13e5 <iterate_lf+0x295>
jmp    172a <iterate_lf+0x5da>
movss  -0x58(%rbp),%xmm0
lea    0xc13(%rip),%rdi
call   1030 <printf@plt>
mov    0x2be3(%rip),%rax
mov    (%rax),%edi
call   1060 <fflush@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    15c6 <iterate_lf+0x476>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    14c9 <iterate_lf+0x379>
mov    -0x28(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   0x20(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    147b <iterate_lf+0x32b>
jp     147b <iterate_lf+0x32b>
movss  0xb8f(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    149a <iterate_lf+0x34a>
mov    0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x50(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1426 <iterate_lf+0x2d6>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f7 <iterate_lf+0x3a7>
jp     14f7 <iterate_lf+0x3a7>
movss  0xb13(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    15a1 <iterate_lf+0x451>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    159c <iterate_lf+0x44c>
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   0x20(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    155b <iterate_lf+0x40b>
jp     155b <iterate_lf+0x40b>
movss  0xaaf(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    156d <iterate_lf+0x41d>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x44(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1506 <iterate_lf+0x3b6>
jmp    15a1 <iterate_lf+0x451>
movss  -0x4c(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    140b <iterate_lf+0x2bb>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    162d <iterate_lf+0x4dd>
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    15d5 <iterate_lf+0x485>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1669 <iterate_lf+0x519>
movss  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1634 <iterate_lf+0x4e4>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16ae <iterate_lf+0x55e>
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x64(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
call   1070 <sum_AB_lf@plt>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1670 <iterate_lf+0x520>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16f3 <iterate_lf+0x5a3>
mov    -0x28(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x64(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
call   1070 <sum_AB_lf@plt>
mov    0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    16b5 <iterate_lf+0x565>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rdi
mov    0x10(%rbp),%rsi
mov    0x18(%rbp),%edx
call   1040 <philike@plt>
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ab <iterate_lf+0x25b>
movss  -0x58(%rbp),%xmm0
lea    0x8ce(%rip),%rdi
call   1030 <printf@plt>
mov    0x289e(%rip),%rax
mov    (%rax),%edi
call   1060 <fflush@plt>
movss  -0x58(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iterate_lf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movss  %xmm0,0x24(%rsp)
mov    %r9,0x18(%rsp)
mov    %r8,%r14
mov    %rcx,%r11
mov    %rdx,%r12
mov    %rsi,0x10(%rsp)
mov    %rdi,%rsi
mov    0xe0(%rsp),%r15d
mov    0xd8(%rsp),%ecx
mov    %r15d,%r10d
test   %r15d,%r15d
jle    1547 <iterate_lf+0x407>
lea    -0x1(%r10),%rbx
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rbx
jae    11a8 <iterate_lf+0x68>
movss  0xe5f(%rip),%xmm1
xor    %edx,%edx
jmp    126c <iterate_lf+0x12c>
mov    %r10d,%edi
and    $0xfffffffc,%edi
movss  0xe4a(%rip),%xmm1
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm0
movss  0x4(%rsi,%rdx,4),%xmm2
xorps  %xmm3,%xmm3
cmpltss %xmm0,%xmm3
movaps %xmm3,%xmm4
andps  %xmm0,%xmm4
andnps %xmm1,%xmm3
orps   %xmm4,%xmm3
cmpltss %xmm1,%xmm0
andps  %xmm0,%xmm3
andnps %xmm1,%xmm0
orps   %xmm3,%xmm0
movaps %xmm2,%xmm1
cmpltss %xmm0,%xmm1
xorps  %xmm3,%xmm3
cmpltss %xmm2,%xmm3
andps  %xmm3,%xmm2
andnps %xmm0,%xmm3
orps   %xmm2,%xmm3
andps  %xmm1,%xmm3
andnps %xmm0,%xmm1
orps   %xmm1,%xmm3
movss  0x8(%rsi,%rdx,4),%xmm0
xorps  %xmm2,%xmm2
cmpltss %xmm0,%xmm2
movaps %xmm2,%xmm1
andps  %xmm0,%xmm2
cmpltss %xmm3,%xmm0
andnps %xmm3,%xmm1
orps   %xmm1,%xmm2
andps  %xmm0,%xmm2
andnps %xmm3,%xmm0
orps   %xmm0,%xmm2
movss  0xc(%rsi,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cmpltss %xmm0,%xmm1
movaps %xmm1,%xmm3
andps  %xmm0,%xmm1
cmpltss %xmm2,%xmm0
andnps %xmm2,%xmm3
orps   %xmm3,%xmm1
andps  %xmm0,%xmm1
andnps %xmm2,%xmm0
orps   %xmm0,%xmm1
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    11c0 <iterate_lf+0x80>
movaps %xmm1,%xmm0
test   %r9,%r9
je     12b3 <iterate_lf+0x173>
lea    (%rsi,%rdx,4),%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm0
xorps  %xmm2,%xmm2
cmpltss %xmm0,%xmm2
movaps %xmm2,%xmm3
andps  %xmm0,%xmm3
andnps %xmm1,%xmm2
orps   %xmm3,%xmm2
cmpltss %xmm1,%xmm0
andps  %xmm0,%xmm2
andnps %xmm1,%xmm0
orps   %xmm2,%xmm0
add    $0x1,%rax
movaps %xmm0,%xmm1
cmp    %rax,%r9
jne    1280 <iterate_lf+0x140>
test   %r15d,%r15d
jle    1547 <iterate_lf+0x407>
cmp    $0x8,%r15d
jae    12c9 <iterate_lf+0x189>
xor    %edx,%edx
jmp    13c0 <iterate_lf+0x280>
mov    %r10d,%edx
and    $0xfffffff8,%edx
lea    0x0(,%r10,4),%r9
and    $0xffffffffffffffe0,%r9
xor    %eax,%eax
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
jmp    12fd <iterate_lf+0x1bd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x20,%rax
cmp    %rax,%r9
je     1392 <iterate_lf+0x252>
movups (%rsi,%rax,1),%xmm3
ucomiss %xmm3,%xmm1
jb     130b <iterate_lf+0x1cb>
movss  %xmm0,(%rsi,%rax,1)
cmpleps %xmm2,%xmm3
pextrw $0x2,%xmm3,%edi
test   $0x1,%dil
je     1320 <iterate_lf+0x1e0>
movss  %xmm0,0x4(%rsi,%rax,1)
pextrw $0x4,%xmm3,%edi
test   $0x1,%dil
je     1331 <iterate_lf+0x1f1>
movss  %xmm0,0x8(%rsi,%rax,1)
pextrw $0x6,%xmm3,%edi
test   $0x1,%dil
je     1342 <iterate_lf+0x202>
movss  %xmm0,0xc(%rsi,%rax,1)
movups 0x10(%rsi,%rax,1),%xmm3
ucomiss %xmm3,%xmm1
jb     1352 <iterate_lf+0x212>
movss  %xmm0,0x10(%rsi,%rax,1)
cmpleps %xmm2,%xmm3
pextrw $0x2,%xmm3,%edi
test   $0x1,%dil
je     1367 <iterate_lf+0x227>
movss  %xmm0,0x14(%rsi,%rax,1)
pextrw $0x4,%xmm3,%edi
test   $0x1,%dil
je     1378 <iterate_lf+0x238>
movss  %xmm0,0x18(%rsi,%rax,1)
pextrw $0x6,%xmm3,%edi
test   $0x1,%dil
je     12f0 <iterate_lf+0x1b0>
movss  %xmm0,0x1c(%rsi,%rax,1)
jmp    12f0 <iterate_lf+0x1b0>
cmp    %r10,%rdx
jne    13c0 <iterate_lf+0x280>
test   %r15d,%r15d
jle    1547 <iterate_lf+0x407>
mov    0x10(%rsp),%rax
movss  (%rax),%xmm1
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rbx
jae    13e6 <iterate_lf+0x2a6>
xorps  %xmm0,%xmm0
xor    %edi,%edi
jmp    1461 <iterate_lf+0x321>
xorps  %xmm1,%xmm1
jmp    13d9 <iterate_lf+0x299>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
cmp    %rdx,%r10
je     1397 <iterate_lf+0x257>
ucomiss (%rsi,%rdx,4),%xmm1
jb     13d0 <iterate_lf+0x290>
movss  %xmm0,(%rsi,%rdx,4)
jmp    13d0 <iterate_lf+0x290>
mov    %r10d,%eax
and    $0xfffffffc,%eax
xorps  %xmm0,%xmm0
xor    %edx,%edx
mov    0x10(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%rbx,%rdx,4),%xmm2
movss  0x8(%rbx,%rdx,4),%xmm3
movss  0xc(%rbx,%rdx,4),%xmm4
movaps %xmm4,%xmm5
subss  %xmm3,%xmm5
subss  %xmm2,%xmm3
subss  %xmm1,%xmm2
mulss  (%rsi,%rdx,4),%xmm2
mulss  0x4(%rsi,%rdx,4),%xmm3
addss  %xmm0,%xmm2
addss  %xmm2,%xmm3
mulss  0x8(%rsi,%rdx,4),%xmm5
addss  %xmm3,%xmm5
lea    0x4(%rdx),%rdi
movss  0x10(%rbx,%rdx,4),%xmm1
movaps %xmm1,%xmm0
subss  %xmm4,%xmm0
mulss  0xc(%rsi,%rdx,4),%xmm0
addss  %xmm5,%xmm0
mov    %rdi,%rdx
cmp    %rdi,%rax
jne    1400 <iterate_lf+0x2c0>
test   %r9,%r9
je     14a1 <iterate_lf+0x361>
mov    0x10(%rsp),%rax
lea    (%rax,%rdi,4),%rax
add    $0x4,%rax
lea    (%rsi,%rdi,4),%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movss  (%rax,%rdi,4),%xmm2
movaps %xmm2,%xmm3
subss  %xmm1,%xmm3
mulss  (%rdx,%rdi,4),%xmm3
addss  %xmm3,%xmm0
add    $0x1,%rdi
movaps %xmm2,%xmm1
cmp    %rdi,%r9
jne    1480 <iterate_lf+0x340>
test   %r15d,%r15d
jle    1547 <iterate_lf+0x407>
cmp    $0x4,%r15d
jae    14b4 <iterate_lf+0x374>
xor    %eax,%eax
jmp    1530 <iterate_lf+0x3f0>
mov    %r10d,%eax
and    $0xfffffffc,%eax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rax),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     1a64 <iterate_lf+0x924>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rdx,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rsi,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    14f0 <iterate_lf+0x3b0>
test   $0x1,%bl
je     1522 <iterate_lf+0x3e2>
movups (%rsi,%rdx,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rdx,4)
cmp    %r10,%rax
je     1547 <iterate_lf+0x407>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    1530 <iterate_lf+0x3f0>
mov    %r11,0x30(%rsp)
mov    %r10,0x40(%rsp)
mov    0xd0(%rsp),%rbx
test   %ecx,%ecx
mov    %rsi,0x8(%rsp)
jle    15d9 <iterate_lf+0x499>
xor    %r13d,%r13d
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%rbp
nop
mov    %rbp,%rdi
mov    %r13d,%edx
mov    %r15d,%r8d
call   1060 <sum_AB_lf@plt>
mov    0xd8(%rsp),%ecx
mov    0x8(%rsp),%rsi
movss  %xmm0,(%rbx,%r13,4)
add    $0x1,%r13
cmp    %r13,%rcx
jne    1570 <iterate_lf+0x430>
test   %ecx,%ecx
mov    0xd0(%rsp),%rbx
jle    15d9 <iterate_lf+0x499>
mov    %r14,%rbp
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %r13d,%edx
mov    %r15d,%r8d
call   1060 <sum_AB_lf@plt>
mov    0xd8(%rsp),%ecx
mov    0x8(%rsp),%rsi
movss  %xmm0,(%rbx,%r13,4)
add    $0x1,%r13
cmp    %r13,%rcx
jne    15b0 <iterate_lf+0x470>
mov    0x18(%rsp),%rdi
mov    %rbx,%rsi
mov    %ecx,%edx
mov    %rcx,%rbx
call   1040 <philike@plt>
movaps %xmm0,%xmm1
andps  0xa1b(%rip),%xmm1
ucomiss 0x24(%rsp),%xmm1
jbe    1a26 <iterate_lf+0x8e6>
movslq 0xe0(%rsp),%r13
mov    %ebx,%ebx
mov    0x40(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x68(%rsp)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x58(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
and    $0x3,%eax
mov    %rax,0x38(%rsp)
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x48(%rsp)
shl    $0x2,%r13
mov    0x10(%rsp),%rax
add    $0x4,%rax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %r14,0x70(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,0x78(%rsp)
lea    0x9a4(%rip),%rdi
movaps %xmm0,0x80(%rsp)
call   1030 <printf@plt>
mov    0x2950(%rip),%rax
mov    (%rax),%edi
call   1050 <fflush@plt>
mov    0xe0(%rsp),%r8d
test   %r8d,%r8d
mov    0x8(%rsp),%rsi
mov    0xd8(%rsp),%ecx
mov    0x40(%rsp),%r11
movss  0x945(%rip),%xmm4
xorps  %xmm5,%xmm5
movss  0x93a(%rip),%xmm6
jle    1940 <iterate_lf+0x800>
mov    0x30(%rsp),%r10
mov    %r14,%r15
xor    %edx,%edx
mov    0x18(%rsp),%r9
jmp    1701 <iterate_lf+0x5c1>
nopl   (%rax)
movaps %xmm4,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0x4,%r15
add    $0x4,%r10
cmp    %r11,%rdx
je     17c0 <iterate_lf+0x680>
xorps  %xmm0,%xmm0
test   %ecx,%ecx
jle    16e0 <iterate_lf+0x5a0>
mov    %r15,%rbp
xor    %edi,%edi
jmp    172a <iterate_lf+0x5ea>
nop
mulss  (%r12,%rdi,4),%xmm1
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdi
add    %r13,%rbp
cmp    %rdi,%rbx
je     1750 <iterate_lf+0x610>
movss  0x0(%rbp),%xmm1
ucomiss %xmm5,%xmm1
movaps %xmm4,%xmm2
jne    1739 <iterate_lf+0x5f9>
jnp    1710 <iterate_lf+0x5d0>
mov    0xd0(%rsp),%rax
movss  (%rax,%rdi,4),%xmm2
divss  (%rsi,%rdx,4),%xmm2
jmp    1710 <iterate_lf+0x5d0>
nopl   (%rax)
ucomiss %xmm5,%xmm0
movaps %xmm0,%xmm1
cmpeqss %xmm5,%xmm1
andps  %xmm6,%xmm1
jne    1762 <iterate_lf+0x622>
jnp    16e3 <iterate_lf+0x5a3>
test   %ecx,%ecx
jle    16e3 <iterate_lf+0x5a3>
xorps  %xmm1,%xmm1
mov    %r10,%rbp
xor    %edi,%edi
jmp    179e <iterate_lf+0x65e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mulss  (%r12,%rdi,4),%xmm2
divss  %xmm3,%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rdi
add    %r13,%rbp
cmp    %rdi,%rbx
je     16e3 <iterate_lf+0x5a3>
movss  0x0(%rbp),%xmm2
ucomiss %xmm5,%xmm2
movaps %xmm4,%xmm3
jne    17ad <iterate_lf+0x66d>
jnp    1780 <iterate_lf+0x640>
movss  (%r9,%rdi,4),%xmm3
jmp    1780 <iterate_lf+0x640>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r8d,%r8d
jle    1940 <iterate_lf+0x800>
mov    0x10(%rsp),%rdi
movss  (%rdi),%xmm1
cmpq   $0x3,0x68(%rsp)
jae    17e6 <iterate_lf+0x6a6>
xorps  %xmm0,%xmm0
xor    %edx,%edx
mov    0x38(%rsp),%r9
jmp    1861 <iterate_lf+0x721>
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    0x28(%rsp),%rbp
mov    0x38(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x4(%rdi,%rax,4),%xmm2
movss  0x8(%rdi,%rax,4),%xmm3
movss  0xc(%rdi,%rax,4),%xmm4
movaps %xmm4,%xmm5
subss  %xmm3,%xmm5
subss  %xmm2,%xmm3
subss  %xmm1,%xmm2
mulss  (%rsi,%rax,4),%xmm2
mulss  0x4(%rsi,%rax,4),%xmm3
addss  %xmm0,%xmm2
addss  %xmm2,%xmm3
mulss  0x8(%rsi,%rax,4),%xmm5
addss  %xmm3,%xmm5
lea    0x4(%rax),%rdx
movss  0x10(%rdi,%rax,4),%xmm1
movaps %xmm1,%xmm0
subss  %xmm4,%xmm0
mulss  0xc(%rsi,%rax,4),%xmm0
addss  %xmm5,%xmm0
mov    %rdx,%rax
cmp    %rdx,%rbp
jne    1800 <iterate_lf+0x6c0>
test   %r9,%r9
je     18a1 <iterate_lf+0x761>
mov    0x60(%rsp),%rax
lea    (%rax,%rdx,4),%rax
lea    (%rsi,%rdx,4),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%rdx,4),%xmm2
movaps %xmm2,%xmm3
subss  %xmm1,%xmm3
mulss  (%rdi,%rdx,4),%xmm3
addss  %xmm3,%xmm0
add    $0x1,%rdx
movaps %xmm2,%xmm1
cmp    %rdx,%r9
jne    1880 <iterate_lf+0x740>
test   %r8d,%r8d
jle    1940 <iterate_lf+0x800>
cmp    $0x4,%r8d
jae    18b4 <iterate_lf+0x774>
xor    %eax,%eax
jmp    1920 <iterate_lf+0x7e0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x58(%rsp)
je     1a0f <iterate_lf+0x8cf>
mov    0x48(%rsp),%rdx
xor    %eax,%eax
mov    0x28(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rax,4),%xmm2
movups 0x10(%rsi,%rax,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rax,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rsi,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    18e0 <iterate_lf+0x7a0>
testb  $0x1,0x50(%rsp)
je     1914 <iterate_lf+0x7d4>
movups (%rsi,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rax,4)
mov    %rdi,%rax
cmp    %r11,%rdi
je     1940 <iterate_lf+0x800>
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r11
jne    1920 <iterate_lf+0x7e0>
nopw   0x0(%rax,%rax,1)
test   %ecx,%ecx
mov    0xd0(%rsp),%r15
jle    19cd <iterate_lf+0x88d>
xor    %ebp,%ebp
mov    0x18(%rsp),%r15
mov    0x30(%rsp),%r14
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %ebp,%edx
call   1060 <sum_AB_lf@plt>
mov    0xd8(%rsp),%ecx
mov    0xe0(%rsp),%r8d
mov    0x8(%rsp),%rsi
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1960 <iterate_lf+0x820>
test   %ecx,%ecx
mov    0x70(%rsp),%r14
mov    0xd0(%rsp),%r15
jle    19cd <iterate_lf+0x88d>
xor    %ebp,%ebp
mov    %r14,%rdi
mov    %ebp,%edx
call   1060 <sum_AB_lf@plt>
mov    0xd8(%rsp),%ecx
mov    0xe0(%rsp),%r8d
mov    0x8(%rsp),%rsi
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    19a0 <iterate_lf+0x860>
mov    0x18(%rsp),%rdi
mov    %r15,%rsi
mov    %ecx,%edx
call   1040 <philike@plt>
movaps %xmm0,%xmm1
subss  0x80(%rsp),%xmm0
andps  0x621(%rip),%xmm0
ucomiss 0x24(%rsp),%xmm0
jbe    1a29 <iterate_lf+0x8e9>
mov    0x78(%rsp),%rcx
lea    0x1(%rcx),%eax
movaps %xmm1,%xmm0
cmp    $0x12b,%ecx
jb     1670 <iterate_lf+0x530>
jmp    1a29 <iterate_lf+0x8e9>
xor    %eax,%eax
mov    0x28(%rsp),%rdi
testb  $0x1,0x50(%rsp)
jne    1909 <iterate_lf+0x7c9>
jmp    1914 <iterate_lf+0x7d4>
movaps %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
lea    0x5ea(%rip),%rdi
movaps %xmm1,%xmm0
call   1030 <printf@plt>
mov    0x259b(%rip),%rax
mov    (%rax),%edi
call   1050 <fflush@plt>
movss  0x8(%rsp),%xmm0
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%bl
jne    1517 <iterate_lf+0x3d7>
jmp    1522 <iterate_lf+0x3e2>

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

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