#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 */
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
float lpa(float x[], int N, float b[], int M) {
  int i, j;
  float s, at;
  float a0, *rx, *rc;
  rx = (float *)malloc((M + 2) * sizeof(float));
  rc = (float *)malloc((M + 2) * sizeof(float));
  for (i = 0; i <= M + 1; i++)
    for (rx[i] = j = 0; j < N - i; j++)
      rx[i] += x[j] * x[i + j];
  b[0] = 1.;
  b[1] = rc[0] = rx[0] != 0. ? -rx[1] / rx[0] : 0.;
  a0 = rx[0] + rx[1] * rc[0];
  for (i = 1; i < M; i++) {
    for (s = j = 0; j <= i; j++)
      s += rx[i - j + 1] * b[j];
    rc[i] = a0 != 0. ? -s / a0 : 0.;
    for (j = 1; j <= (i + 1) >> 1; j++) {
      at = b[j] + rc[i] * b[i - j + 1];
      b[i - j + 1] += rc[i] * b[j];
      b[j] = at;
    }
    b[i + 1] = rc[i];
    a0 += rc[i] * s;
  }
  free(rx);
  free(rc);
  return (a0);
}


x86 assembly (clang, -O0):
<lpa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     11fe <lpa+0xde>
movl   $0x0,-0x24(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    11eb <lpa+0xcb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1193 <lpa+0x73>
jmp    11f0 <lpa+0xd0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    116b <lpa+0x4b>
mov    -0x18(%rbp),%rax
movss  0xdf6(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1232 <lpa+0x112>
jp     1232 <lpa+0x112>
jmp    125e <lpa+0x13e>
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x38(%rbp),%rax
divss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    126b <lpa+0x14b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    126b <lpa+0x14b>
movsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1488 <lpa+0x368>
movl   $0x0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     131b <lpa+0x1fb>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12cd <lpa+0x1ad>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    133c <lpa+0x21c>
jp     133c <lpa+0x21c>
jmp    1361 <lpa+0x241>
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    136e <lpa+0x24e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    136e <lpa+0x24e>
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jg     1437 <lpa+0x317>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    138b <lpa+0x26b>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12b2 <lpa+0x192>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movss  -0x30(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lpa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %esi,%r12d
mov    %rdi,%r13
lea    0x8(,%rbp,4),%ebx
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %r13,%r10
mov    %rbp,%r9
mov    %rax,%r13
cmp    $0xffffffff,%r9d
jge    1414 <lpa+0x2f4>
movl   $0x3f800000,(%r14)
movss  (%r15),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    117a <lpa+0x5a>
jnp    118b <lpa+0x6b>
movss  0x4(%r15),%xmm0
xorps  0xe79(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x0(%r13)
movss  %xmm0,0x4(%r14)
movss  0x4(%r15),%xmm7
mulss  0x0(%r13),%xmm7
addss  (%r15),%xmm7
cmp    $0x2,%r9d
jl     13ed <lpa+0x2cd>
mov    %r9d,%r9d
mov    %r15,%rdi
add    $0x8,%rdi
lea    0xc(%r14),%r8
lea    0x4(%r14),%rsi
mov    $0x2,%r11d
mov    $0x1,%edx
xorps  %xmm0,%xmm0
movaps 0xe27(%rip),%xmm1
mov    %rsi,%r10
jmp    1209 <lpa+0xe9>
xchg   %ax,%ax
movss  %xmm3,(%r14,%rax,4)
mulss  0x0(%r13,%rdx,4),%xmm2
addss  %xmm2,%xmm7
add    $0x1,%r11
add    $0x4,%rdi
add    $0x4,%r10
mov    %rax,%rdx
cmp    %r9,%rax
je     13ed <lpa+0x2cd>
mov    %r11,%r12
shr    $0x2,%r12
cmp    $0x3,%rdx
jae    1230 <lpa+0x110>
xor    %ebp,%ebp
xorps  %xmm2,%xmm2
test   $0x3,%r11b
jne    12a0 <lpa+0x180>
jmp    12da <lpa+0x1ba>
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%r12,4),%rax
neg    %rax
xorps  %xmm2,%xmm2
mov    %r8,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdi,%rbp,4),%xmm3
mulss  -0xc(%rbx),%xmm3
addss  %xmm2,%xmm3
movss  -0x4(%rdi,%rbp,4),%xmm4
mulss  -0x8(%rbx),%xmm4
addss  %xmm3,%xmm4
movss  -0x8(%rdi,%rbp,4),%xmm3
mulss  -0x4(%rbx),%xmm3
movss  -0xc(%rdi,%rbp,4),%xmm2
addss  %xmm4,%xmm3
mulss  (%rbx),%xmm2
addss  %xmm3,%xmm2
add    $0xfffffffffffffffc,%rbp
add    $0x10,%rbx
cmp    %rbp,%rax
jne    1250 <lpa+0x130>
neg    %rbp
test   $0x3,%r11b
je     12da <lpa+0x1ba>
mov    %r11d,%eax
and    $0x3,%eax
lea    (%r14,%rbp,4),%rbx
shl    $0x2,%rbp
mov    %rdi,%rcx
sub    %rbp,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx),%xmm3
mulss  (%rbx,%rbp,4),%xmm3
addss  %xmm3,%xmm2
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rcx
cmp    %rbp,%rax
jne    12c0 <lpa+0x1a0>
mov    %r11,%rax
shr    %rax
ucomiss %xmm0,%xmm7
jne    12e7 <lpa+0x1c7>
jnp    1300 <lpa+0x1e0>
movaps %xmm2,%xmm3
xorps  %xmm1,%xmm3
divss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
jmp    1303 <lpa+0x1e3>
nopw   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,0x0(%r13,%rdx,4)
mov    $0x1,%ebp
cmp    $0x1,%rax
je     13a2 <lpa+0x282>
add    %r12,%r12
neg    %r12
mov    $0x1,%ebp
mov    %r10,%rax
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rbp,4),%xmm4
movss  (%rax),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,(%rax)
movss  %xmm6,-0x4(%rsi,%rbp,4)
movss  0x0(%r13,%rdx,4),%xmm3
movss  (%rsi,%rbp,4),%xmm4
movss  -0x4(%rax),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,-0x4(%rax)
movss  %xmm6,(%rsi,%rbp,4)
movss  0x0(%r13,%rdx,4),%xmm3
add    $0xfffffffffffffff8,%rax
lea    (%r12,%rbp,1),%rcx
add    $0x2,%rcx
add    $0x2,%rbp
cmp    $0x1,%rcx
jne    1330 <lpa+0x210>
lea    0x1(%rdx),%rax
test   $0x2,%r11b
je     11e0 <lpa+0xc0>
movss  (%r14,%rbp,4),%xmm4
mov    %rax,%rcx
sub    %rbp,%rcx
movss  (%r14,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,(%r14,%rcx,4)
movss  %xmm6,(%r14,%rbp,4)
movss  0x0(%r13,%rdx,4),%xmm3
jmp    11e0 <lpa+0xc0>
movaps %xmm7,(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
movaps (%rsp),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x2(%r9),%r8d
lea    0x4(%r10),%rcx
xor    %edx,%edx
xor    %esi,%esi
mov    %r12d,%ebx
jmp    1444 <lpa+0x324>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0xffffffff,%ebx
add    $0x4,%rdx
cmp    %r8,%rsi
je     1164 <lpa+0x44>
mov    %ebx,%ebx
movl   $0x0,(%r15,%rsi,4)
cmp    %r12d,%esi
jge    1430 <lpa+0x310>
cmp    $0x1,%ebx
jne    1460 <lpa+0x340>
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    14a3 <lpa+0x383>
nop
mov    %ebx,%edi
and    $0xfffffffe,%edi
lea    (%rcx,%rdx,1),%rax
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
xchg   %ax,%ax
movss  -0x4(%rcx,%rbp,4),%xmm1
mulss  -0x4(%rax,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rsi,4)
movss  (%rcx,%rbp,4),%xmm0
mulss  (%rax,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r15,%rsi,4)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    1470 <lpa+0x350>
test   $0x1,%bl
je     1430 <lpa+0x310>
movss  (%r10,%rbp,4),%xmm1
add    %rsi,%rbp
mulss  (%r10,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r15,%rsi,4)
jmp    1430 <lpa+0x310>

LLVM IR (-O0):
define float @lpa(float* %0, i32 %1, float* %2, i32 %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float*
%15 = alloca float*
store float* %0, float** %5
store i32 %1, i32* %6
store float* %2, float** %7
store i32 %3, i32* %8
%16 = load i32, i32* %8
%17 = add nsw i32 %16, 2
%18 = sext i32 %17 to i64
%19 = mul i64 %18, 4
%20 = trunc i64 %19 to i32
%21 = call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to float*
store float* %22, float** %14
%23 = load i32, i32* %8
%24 = add nsw i32 %23, 2
%25 = sext i32 %24 to i64
%26 = mul i64 %25, 4
%27 = trunc i64 %26 to i32
%28 = call i64 @malloc(i32 %27)
%29 = inttoptr i64 %28 to float*
store float* %29, float** %15
store i32 0, i32* %9
br label %30
30: ; preds = %69, %4
%31 = load i32, i32* %9
%32 = load i32, i32* %8
%33 = add nsw i32 %32, 1
%34 = icmp sle i32 %31, %33
br i1 %34, label %35, label %72
35: ; preds = %30
store i32 0, i32* %10
%36 = load float*, float** %14
%37 = load i32, i32* %9
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %36, i64 %38
store float 0.000000e+00, float* %39
br label %40
40: ; preds = %65, %35
%41 = load i32, i32* %10
%42 = load i32, i32* %6
%43 = load i32, i32* %9
%44 = sub nsw i32 %42, %43
%45 = icmp slt i32 %41, %44
br i1 %45, label %46, label %68
46: ; preds = %40
%47 = load float*, float** %5
%48 = load i32, i32* %10
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %47, i64 %49
%51 = load float, float* %50
%52 = load float*, float** %5
%53 = load i32, i32* %9
%54 = load i32, i32* %10
%55 = add nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %52, i64 %56
%58 = load float, float* %57
%59 = load float*, float** %14
%60 = load i32, i32* %9
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = call float @llvm.fmuladd.f32(float %51, float %58, float %63)
store float %64, float* %62
br label %65
65: ; preds = %46
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
store i32 %67, i32* %10
br label %40
68: ; preds = %40
br label %69
69: ; preds = %68
%70 = load i32, i32* %9
%71 = add nsw i32 %70, 1
store i32 %71, i32* %9
br label %30
72: ; preds = %30
%73 = load float*, float** %7
%74 = getelementptr inbounds float, float* %73, i64 0
store float 1.000000e+00, float* %74
%75 = load float*, float** %14
%76 = getelementptr inbounds float, float* %75, i64 0
%77 = load float, float* %76
%78 = fpext float %77 to double
%79 = fcmp une double %78, 0.000000e+00
br i1 %79, label %80, label %90
80: ; preds = %72
%81 = load float*, float** %14
%82 = getelementptr inbounds float, float* %81, i64 1
%83 = load float, float* %82
%84 = fneg float %83
%85 = load float*, float** %14
%86 = getelementptr inbounds float, float* %85, i64 0
%87 = load float, float* %86
%88 = fdiv float %84, %87
%89 = fpext float %88 to double
br label %91
90: ; preds = %72
br label %91
91: ; preds = %90, %80
%92 = phi double [ %89, %80 ], [ 0.000000e+00, %90 ]
%93 = fptrunc double %92 to float
%94 = load float*, float** %15
%95 = getelementptr inbounds float, float* %94, i64 0
store float %93, float* %95
%96 = load float*, float** %7
%97 = getelementptr inbounds float, float* %96, i64 1
store float %93, float* %97
%98 = load float*, float** %14
%99 = getelementptr inbounds float, float* %98, i64 0
%100 = load float, float* %99
%101 = load float*, float** %14
%102 = getelementptr inbounds float, float* %101, i64 1
%103 = load float, float* %102
%104 = load float*, float** %15
%105 = getelementptr inbounds float, float* %104, i64 0
%106 = load float, float* %105
%107 = call float @llvm.fmuladd.f32(float %103, float %106, float %100)
store float %107, float* %13
store i32 1, i32* %9
br label %108
108: ; preds = %226, %91
%109 = load i32, i32* %9
%110 = load i32, i32* %8
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %229
112: ; preds = %108
store i32 0, i32* %10
store float 0.000000e+00, float* %11
br label %113
113: ; preds = %133, %112
%114 = load i32, i32* %10
%115 = load i32, i32* %9
%116 = icmp sle i32 %114, %115
br i1 %116, label %117, label %136
117: ; preds = %113
%118 = load float*, float** %14
%119 = load i32, i32* %9
%120 = load i32, i32* %10
%121 = sub nsw i32 %119, %120
%122 = add nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %118, i64 %123
%125 = load float, float* %124
%126 = load float*, float** %7
%127 = load i32, i32* %10
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float, float* %129
%131 = load float, float* %11
%132 = call float @llvm.fmuladd.f32(float %125, float %130, float %131)
store float %132, float* %11
br label %133
133: ; preds = %117
%134 = load i32, i32* %10
%135 = add nsw i32 %134, 1
store i32 %135, i32* %10
br label %113
136: ; preds = %113
%137 = load float, float* %13
%138 = fpext float %137 to double
%139 = fcmp une double %138, 0.000000e+00
br i1 %139, label %140, label %146
140: ; preds = %136
%141 = load float, float* %11
%142 = fneg float %141
%143 = load float, float* %13
%144 = fdiv float %142, %143
%145 = fpext float %144 to double
br label %147
146: ; preds = %136
br label %147
147: ; preds = %146, %140
%148 = phi double [ %145, %140 ], [ 0.000000e+00, %146 ]
%149 = fptrunc double %148 to float
%150 = load float*, float** %15
%151 = load i32, i32* %9
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %150, i64 %152
store float %149, float* %153
store i32 1, i32* %10
br label %154
154: ; preds = %204, %147
%155 = load i32, i32* %10
%156 = load i32, i32* %9
%157 = add nsw i32 %156, 1
%158 = ashr i32 %157, 1
%159 = icmp sle i32 %155, %158
br i1 %159, label %160, label %207
160: ; preds = %154
%161 = load float*, float** %7
%162 = load i32, i32* %10
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %161, i64 %163
%165 = load float, float* %164
%166 = load float*, float** %15
%167 = load i32, i32* %9
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %166, i64 %168
%170 = load float, float* %169
%171 = load float*, float** %7
%172 = load i32, i32* %9
%173 = load i32, i32* %10
%174 = sub nsw i32 %172, %173
%175 = add nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %171, i64 %176
%178 = load float, float* %177
%179 = call float @llvm.fmuladd.f32(float %170, float %178, float %165)
store float %179, float* %12
%180 = load float*, float** %15
%181 = load i32, i32* %9
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = load float*, float** %7
%186 = load i32, i32* %10
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %185, i64 %187
%189 = load float, float* %188
%190 = load float*, float** %7
%191 = load i32, i32* %9
%192 = load i32, i32* %10
%193 = sub nsw i32 %191, %192
%194 = add nsw i32 %193, 1
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %190, i64 %195
%197 = load float, float* %196
%198 = call float @llvm.fmuladd.f32(float %184, float %189, float %197)
store float %198, float* %196
%199 = load float, float* %12
%200 = load float*, float** %7
%201 = load i32, i32* %10
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %200, i64 %202
store float %199, float* %203
br label %204
204: ; preds = %160
%205 = load i32, i32* %10
%206 = add nsw i32 %205, 1
store i32 %206, i32* %10
br label %154
207: ; preds = %154
%208 = load float*, float** %15
%209 = load i32, i32* %9
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %208, i64 %210
%212 = load float, float* %211
%213 = load float*, float** %7
%214 = load i32, i32* %9
%215 = add nsw i32 %214, 1
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %213, i64 %216
store float %212, float* %217
%218 = load float*, float** %15
%219 = load i32, i32* %9
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %218, i64 %220
%222 = load float, float* %221
%223 = load float, float* %11
%224 = load float, float* %13
%225 = call float @llvm.fmuladd.f32(float %222, float %223, float %224)
store float %225, float* %13
br label %226
226: ; preds = %207
%227 = load i32, i32* %9
%228 = add nsw i32 %227, 1
store i32 %228, i32* %9
br label %108
229: ; preds = %108
%230 = load float*, float** %14
%231 = call i32 @free(float* %230)
%232 = load float*, float** %15
%233 = call i32 @free(float* %232)
%234 = load float, float* %13
ret float %234
}

LLVM IR (-O2):
define float @lpa(float* nocapture %0, i32 %1, float* nocapture %2, i32 %3) {
%5 = shl i32 %3, 2
%6 = add i32 %5, 8
%7 = tail call i64 @malloc(i32 %6)
%8 = inttoptr i64 %7 to float*
%9 = tail call i64 @malloc(i32 %6)
%10 = inttoptr i64 %9 to float*
%11 = icmp slt i32 %3, -1
br i1 %11, label %62, label %12
12: ; preds = %4
%13 = add i32 %3, 2
%14 = zext i32 %13 to i64
br label %15
15: ; preds = %12, %58
%16 = phi i64 [ 0, %12 ], [ %59, %58 ]
%17 = phi i32 [ %1, %12 ], [ %60, %58 ]
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds float, float* %8, i64 %16
store float 0.000000e+00, float* %19
%20 = trunc i64 %16 to i32
%21 = icmp slt i32 %20, %1
br i1 %21, label %22, label %58
22: ; preds = %15
%23 = and i64 %18, 1
%24 = icmp eq i32 %17, 1
br i1 %24, label %47, label %25
25: ; preds = %22
%26 = and i64 %18, 4294967294
br label %27
27: ; preds = %27, %25
%28 = phi float [ 0.000000e+00, %25 ], [ %43, %27 ]
%29 = phi i64 [ 0, %25 ], [ %44, %27 ]
%30 = phi i64 [ 0, %25 ], [ %45, %27 ]
%31 = getelementptr inbounds float, float* %0, i64 %29
%32 = load float, float* %31
%33 = add nuw nsw i64 %29, %16
%34 = getelementptr inbounds float, float* %0, i64 %33
%35 = load float, float* %34
%36 = tail call float @llvm.fmuladd.f32(float %32, float %35, float %28)
store float %36, float* %19
%37 = or i64 %29, 1
%38 = getelementptr inbounds float, float* %0, i64 %37
%39 = load float, float* %38
%40 = add nuw nsw i64 %37, %16
%41 = getelementptr inbounds float, float* %0, i64 %40
%42 = load float, float* %41
%43 = tail call float @llvm.fmuladd.f32(float %39, float %42, float %36)
store float %43, float* %19
%44 = add nuw nsw i64 %29, 2
%45 = add i64 %30, 2
%46 = icmp eq i64 %45, %26
br i1 %46, label %47, label %27
47: ; preds = %27, %22
%48 = phi float [ 0.000000e+00, %22 ], [ %43, %27 ]
%49 = phi i64 [ 0, %22 ], [ %44, %27 ]
%50 = icmp eq i64 %23, 0
br i1 %50, label %58, label %51
51: ; preds = %47
%52 = getelementptr inbounds float, float* %0, i64 %49
%53 = load float, float* %52
%54 = add nuw nsw i64 %49, %16
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = tail call float @llvm.fmuladd.f32(float %53, float %56, float %48)
store float %57, float* %19
br label %58
58: ; preds = %51, %47, %15
%59 = add nuw nsw i64 %16, 1
%60 = add i32 %17, -1
%61 = icmp eq i64 %59, %14
br i1 %61, label %62, label %15
62: ; preds = %58, %4
store float 1.000000e+00, float* %2
%63 = load float, float* %8
%64 = fcmp une float %63, 0.000000e+00
br i1 %64, label %65, label %70
65: ; preds = %62
%66 = getelementptr inbounds float, float* %8, i64 1
%67 = load float, float* %66
%68 = fneg float %67
%69 = fdiv float %68, %63
br label %70
70: ; preds = %62, %65
%71 = phi float [ %69, %65 ], [ 0.000000e+00, %62 ]
store float %71, float* %10
%72 = getelementptr inbounds float, float* %2, i64 1
store float %71, float* %72
%73 = load float, float* %8
%74 = getelementptr inbounds float, float* %8, i64 1
%75 = load float, float* %74
%76 = load float, float* %10
%77 = tail call float @llvm.fmuladd.f32(float %75, float %76, float %73)
%78 = icmp sgt i32 %3, 1
br i1 %78, label %79, label %203
79: ; preds = %70
%80 = zext i32 %3 to i64
br label %81
81: ; preds = %79, %196
%82 = phi i64 [ 1, %79 ], [ %86, %196 ]
%83 = phi i64 [ 2, %79 ], [ %201, %196 ]
%84 = phi float [ %77, %79 ], [ %200, %196 ]
%85 = lshr i64 %83, 1
%86 = add nuw nsw i64 %82, 1
%87 = and i64 %83, 3
%88 = icmp ult i64 %82, 3
br i1 %88, label %125, label %89
89: ; preds = %81
%90 = and i64 %83, 9223372036854775804
br label %91
91: ; preds = %91, %89
%92 = phi i64 [ 0, %89 ], [ %122, %91 ]
%93 = phi float [ 0.000000e+00, %89 ], [ %121, %91 ]
%94 = phi i64 [ 0, %89 ], [ %123, %91 ]
%95 = sub nsw i64 %86, %92
%96 = getelementptr inbounds float, float* %8, i64 %95
%97 = load float, float* %96
%98 = getelementptr inbounds float, float* %2, i64 %92
%99 = load float, float* %98
%100 = tail call float @llvm.fmuladd.f32(float %97, float %99, float %93)
%101 = or i64 %92, 1
%102 = sub nsw i64 %86, %101
%103 = getelementptr inbounds float, float* %8, i64 %102
%104 = load float, float* %103
%105 = getelementptr inbounds float, float* %2, i64 %101
%106 = load float, float* %105
%107 = tail call float @llvm.fmuladd.f32(float %104, float %106, float %100)
%108 = or i64 %92, 2
%109 = sub nsw i64 %86, %108
%110 = getelementptr inbounds float, float* %8, i64 %109
%111 = load float, float* %110
%112 = getelementptr inbounds float, float* %2, i64 %108
%113 = load float, float* %112
%114 = tail call float @llvm.fmuladd.f32(float %111, float %113, float %107)
%115 = or i64 %92, 3
%116 = sub nsw i64 %86, %115
%117 = getelementptr inbounds float, float* %8, i64 %116
%118 = load float, float* %117
%119 = getelementptr inbounds float, float* %2, i64 %115
%120 = load float, float* %119
%121 = tail call float @llvm.fmuladd.f32(float %118, float %120, float %114)
%122 = add nuw nsw i64 %92, 4
%123 = add i64 %94, 4
%124 = icmp eq i64 %123, %90
br i1 %124, label %125, label %91
125: ; preds = %91, %81
%126 = phi float [ undef, %81 ], [ %121, %91 ]
%127 = phi i64 [ 0, %81 ], [ %122, %91 ]
%128 = phi float [ 0.000000e+00, %81 ], [ %121, %91 ]
%129 = icmp eq i64 %87, 0
br i1 %129, label %143, label %130
130: ; preds = %125, %130
%131 = phi i64 [ %140, %130 ], [ %127, %125 ]
%132 = phi float [ %139, %130 ], [ %128, %125 ]
%133 = phi i64 [ %141, %130 ], [ 0, %125 ]
%134 = sub nsw i64 %86, %131
%135 = getelementptr inbounds float, float* %8, i64 %134
%136 = load float, float* %135
%137 = getelementptr inbounds float, float* %2, i64 %131
%138 = load float, float* %137
%139 = tail call float @llvm.fmuladd.f32(float %136, float %138, float %132)
%140 = add nuw nsw i64 %131, 1
%141 = add i64 %133, 1
%142 = icmp eq i64 %141, %87
br i1 %142, label %143, label %130
143: ; preds = %130, %125
%144 = phi float [ %126, %125 ], [ %139, %130 ]
%145 = fcmp une float %84, 0.000000e+00
br i1 %145, label %146, label %150
146: ; preds = %143
%147 = fneg float %144
%148 = fdiv float %147, %84
%149 = fpext float %148 to double
br label %150
150: ; preds = %146, %143
%151 = phi double [ %149, %146 ], [ 0.000000e+00, %143 ]
%152 = fptrunc double %151 to float
%153 = getelementptr inbounds float, float* %10, i64 %82
store float %152, float* %153
%154 = icmp eq i64 %85, 1
br i1 %154, label %181, label %155
155: ; preds = %150
%156 = and i64 %85, 4611686018427387902
br label %157
157: ; preds = %157, %155
%158 = phi float [ %152, %155 ], [ %178, %157 ]
%159 = phi i64 [ 1, %155 ], [ %177, %157 ]
%160 = phi i64 [ 0, %155 ], [ %179, %157 ]
%161 = getelementptr inbounds float, float* %2, i64 %159
%162 = load float, float* %161
%163 = sub nsw i64 %86, %159
%164 = getelementptr inbounds float, float* %2, i64 %163
%165 = load float, float* %164
%166 = tail call float @llvm.fmuladd.f32(float %158, float %165, float %162)
%167 = tail call float @llvm.fmuladd.f32(float %158, float %162, float %165)
store float %167, float* %164
store float %166, float* %161
%168 = add nuw nsw i64 %159, 1
%169 = load float, float* %153
%170 = getelementptr inbounds float, float* %2, i64 %168
%171 = load float, float* %170
%172 = sub nsw i64 %86, %168
%173 = getelementptr inbounds float, float* %2, i64 %172
%174 = load float, float* %173
%175 = tail call float @llvm.fmuladd.f32(float %169, float %174, float %171)
%176 = tail call float @llvm.fmuladd.f32(float %169, float %171, float %174)
store float %176, float* %173
store float %175, float* %170
%177 = add nuw nsw i64 %159, 2
%178 = load float, float* %153
%179 = add i64 %160, 2
%180 = icmp eq i64 %179, %156
br i1 %180, label %181, label %157
181: ; preds = %157, %150
%182 = phi float [ undef, %150 ], [ %178, %157 ]
%183 = phi float [ %152, %150 ], [ %178, %157 ]
%184 = phi i64 [ 1, %150 ], [ %177, %157 ]
%185 = and i64 %83, 2
%186 = icmp eq i64 %185, 0
br i1 %186, label %196, label %187
187: ; preds = %181
%188 = getelementptr inbounds float, float* %2, i64 %184
%189 = load float, float* %188
%190 = sub nsw i64 %86, %184
%191 = getelementptr inbounds float, float* %2, i64 %190
%192 = load float, float* %191
%193 = tail call float @llvm.fmuladd.f32(float %183, float %192, float %189)
%194 = tail call float @llvm.fmuladd.f32(float %183, float %189, float %192)
store float %194, float* %191
store float %193, float* %188
%195 = load float, float* %153
br label %196
196: ; preds = %181, %187
%197 = phi float [ %182, %181 ], [ %195, %187 ]
%198 = getelementptr inbounds float, float* %2, i64 %86
store float %197, float* %198
%199 = load float, float* %153
%200 = tail call float @llvm.fmuladd.f32(float %199, float %144, float %84)
%201 = add nuw nsw i64 %83, 1
%202 = icmp eq i64 %86, %80
br i1 %202, label %203, label %81
203: ; preds = %196, %70
%204 = phi float [ %77, %70 ], [ %200, %196 ]
%205 = tail call i32 @free(float* %8)
%206 = tail call i32 @free(float* %10)
ret float %204
}