#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*/ cst_free(float *);
scalar_t__ cst_safe_alloc(int);
void lpc2ref(const float *lpc, float *rfc, int order) {
  int i, j;
  float f, ai;
  float *vo, *vx;
  float *vn = ((float *)cst_safe_alloc(sizeof(float) * (order)));
  i = order - 1;
  rfc[i] = ai = lpc[i];
  f = 1 - ai * ai;
  i--;
  for (j = 0; j <= i; j++)
    rfc[j] = (lpc[j] + ((ai * lpc[i - j]))) / f;
  vo = rfc;
  for (; i > 0;) {
    ai = vo[i];
    f = 1 - ai * ai;
    i--;
    for (j = 0; j <= i; j++)
      vn[j] = (vo[j] + ((ai * vo[i - j]))) / f;
    rfc[i] = vn[i];
    vx = vn;
    vn = vo;
    vo = vx;
  }
  cst_free(vn);
}


x86 assembly (clang, -O0):
<lpc2ref>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <cst_safe_alloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xe6f(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1202 <lpc2ref+0xe2>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11aa <lpc2ref+0x8a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    12f1 <lpc2ref+0x1d1>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xdb7(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12ba <lpc2ref+0x19a>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x24(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1262 <lpc2ref+0x142>
mov    -0x40(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    120a <lpc2ref+0xea>
mov    -0x40(%rbp),%rdi
call   1040 <cst_free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lpc2ref>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r14d
mov    %rsi,%r15
mov    %rdi,%rbx
lea    0x0(,%r14,4),%edi
call   1030 <cst_safe_alloc@plt>
mov    %rax,%rsi
lea    -0x1(%r14),%ecx
movslq %ecx,%rax
movss  (%rbx,%rax,4),%xmm1
movss  %xmm1,(%r15,%rax,4)
cmp    $0x2,%r14d
jl     156e <lpc2ref+0x44e>
movaps %xmm1,%xmm3
mulss  %xmm1,%xmm3
movss  0xe91(%rip),%xmm0
movaps %xmm0,%xmm2
subss  %xmm3,%xmm2
lea    -0x2(%r14),%eax
mov    %eax,%r8d
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1221 <lpc2ref+0x101>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     11b6 <lpc2ref+0x96>
mov    %r8,%rdi
sub    %rcx,%rdi
movss  (%rbx,%rdi,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%rbx,%rcx,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%r15,%rcx,4)
or     $0x1,%rcx
add    %rax,%rdx
je     1325 <lpc2ref+0x205>
sub    %rcx,%rax
mov    %r8,%rdx
sub    %rcx,%rdx
lea    (%rbx,%rdx,4),%rdx
lea    (%r15,%rcx,4),%rdi
add    $0x4,%rdi
lea    (%rbx,%rcx,4),%rcx
add    $0x4,%rcx
xor    %ebp,%ebp
xchg   %ax,%ax
movss  (%rdx),%xmm3
mulss  %xmm1,%xmm3
addss  -0x4(%rcx,%rbp,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,-0x4(%rdi,%rbp,4)
movss  -0x4(%rdx),%xmm3
mulss  %xmm1,%xmm3
addss  (%rcx,%rbp,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rdi,%rbp,4)
add    $0x2,%rbp
add    $0xfffffffffffffff8,%rdx
cmp    %rbp,%rax
jne    11e0 <lpc2ref+0xc0>
jmp    1325 <lpc2ref+0x205>
lea    (%r15,%rax,4),%rcx
lea    0x1(%r8),%rdx
sub    %rax,%rdx
lea    (%rbx,%rdx,4),%rdx
lea    (%rbx,%r8,4),%rdi
add    $0x4,%rdi
lea    (%rbx,%rax,4),%rbp
cmp    %r15,%rdi
seta   %r9b
cmp    %rcx,%rdx
setb   %r10b
cmp    %r15,%rbp
seta   %dl
cmp    %rbx,%rcx
seta   %dil
xor    %ecx,%ecx
test   %r10b,%r9b
jne    118a <lpc2ref+0x6a>
and    %dil,%dl
jne    118a <lpc2ref+0x6a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
lea    -0x4(%rcx),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1584 <lpc2ref+0x464>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x7(%r8),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rdx,4),%xmm5
movups 0x10(%rbx,%rbp,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
divps  %xmm4,%xmm6
movups %xmm6,(%r15,%rdx,4)
movups 0x10(%rbx,%rdx,4),%xmm5
movups (%rbx,%rbp,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
divps  %xmm4,%xmm6
movups %xmm6,0x10(%r15,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    12b0 <lpc2ref+0x190>
test   $0x1,%r9b
je     131c <lpc2ref+0x1fc>
movups (%rbx,%rdx,4),%xmm5
mov    %r8,%rdi
sub    %rdx,%rdi
movups -0xc(%rbx,%rdi,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm6,%xmm3
addps  %xmm5,%xmm3
divps  %xmm4,%xmm3
movups %xmm3,(%r15,%rdx,4)
cmp    %rax,%rcx
jne    118a <lpc2ref+0x6a>
cmp    $0x3,%r14d
jl     156e <lpc2ref+0x44e>
lea    -0x4(%r8),%r9
lea    -0x2(%r8),%r11
xor    %r12d,%r12d
mov    %r8,%rbp
mov    %rsi,%rax
mov    %r15,%rdi
jmp    1374 <lpc2ref+0x254>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,(%r15,%rbp,4)
add    $0x1,%r12
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%r11
mov    %rsi,%rax
cmp    $0x1,%rbx
jle    156e <lpc2ref+0x44e>
mov    %rdi,%rsi
mov    %rax,%rdi
mov    %rbp,%rbx
mov    %r12,%r13
not    %r13
lea    -0x4(%rbp),%r14
add    $0xffffffffffffffff,%rbp
mov    %rbx,%r10
movss  (%rsi,%rbx,4),%xmm1
movaps %xmm1,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm2
subss  %xmm3,%xmm2
sub    $0x4,%r10
jae    1440 <lpc2ref+0x320>
xor    %edx,%edx
add    %r8,%r13
mov    %rdx,%rax
test   $0x1,%bl
je     13dc <lpc2ref+0x2bc>
mov    %rbp,%rax
sub    %rdx,%rax
movss  (%rsi,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%rsi,%rdx,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rdi,%rdx,4)
mov    %rdx,%rax
or     $0x1,%rax
cmp    %rdx,%r13
je     1350 <lpc2ref+0x230>
mov    %r11,%rcx
sub    %rax,%rcx
lea    (%rsi,%rcx,4),%rcx
nop
movss  0x4(%rcx),%xmm3
mulss  %xmm1,%xmm3
addss  (%rsi,%rax,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rdi,%rax,4)
movss  (%rcx),%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%rsi,%rax,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,0x4(%rdi,%rax,4)
add    $0x2,%rax
add    $0xfffffffffffffff8,%rcx
cmp    %rax,%rbx
jne    13f0 <lpc2ref+0x2d0>
jmp    1350 <lpc2ref+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9,(%rsp)
mov    %r15,%r9
mov    %r8,%r15
lea    (%r8,%r13,1),%rcx
mov    %rcx,%rax
mov    $0x4,%edx
mul    %rdx
lea    (%rsi,%rcx,4),%r8
seto   %cl
mov    %r8,%rdx
sub    %rax,%rdx
cmp    %r8,%rdx
ja     14da <lpc2ref+0x3ba>
mov    $0x0,%edx
test   %cl,%cl
mov    %r15,%r8
mov    %r9,%r15
mov    (%rsp),%r9
jne    13ad <lpc2ref+0x28d>
mov    %r9,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
shr    $0x2,%r14
add    $0x1,%r14
lea    (%rdi,%rbx,4),%rcx
lea    (%rsi,%rbx,4),%rdx
cmp    %rdx,%rdi
setb   %dl
cmp    %rcx,%rsi
setb   %cl
and    %dl,%cl
test   %cl,%cl
jne    13ab <lpc2ref+0x28b>
mov    $0x0,%edx
jne    13ad <lpc2ref+0x28d>
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
cmp    $0x4,%r10
jae    14eb <lpc2ref+0x3cb>
xor    %ecx,%ecx
jmp    1533 <lpc2ref+0x413>
xor    %edx,%edx
mov    %r15,%r8
mov    %r9,%r15
mov    (%rsp),%r9
jmp    13ad <lpc2ref+0x28d>
mov    %r9,%rdx
xor    %ecx,%ecx
movups (%rsi,%rcx,4),%xmm5
movups (%rsi,%rdx,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
divps  %xmm4,%xmm6
movups %xmm6,(%rdi,%rcx,4)
movups 0x10(%rsi,%rcx,4),%xmm5
movups -0x10(%rsi,%rdx,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
divps  %xmm4,%xmm6
movups %xmm6,0x10(%rdi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffffe,%rax
jne    14f0 <lpc2ref+0x3d0>
mov    %rbx,%rdx
and    $0xfffffffffffffffc,%rdx
test   $0x1,%r14b
je     1560 <lpc2ref+0x440>
movups (%rsi,%rcx,4),%xmm5
mov    %rbp,%rax
sub    %rcx,%rax
movups -0xc(%rsi,%rax,4),%xmm6
shufps $0x1b,%xmm6,%xmm6
mulps  %xmm6,%xmm3
addps  %xmm5,%xmm3
divps  %xmm4,%xmm3
movups %xmm3,(%rdi,%rcx,4)
cmp    %rdx,%rbx
je     1350 <lpc2ref+0x230>
jmp    13ad <lpc2ref+0x28d>
mov    %rsi,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <cst_free@plt>
xor    %edx,%edx
test   $0x1,%r9b
jne    12fb <lpc2ref+0x1db>
jmp    131c <lpc2ref+0x1fc>

LLVM IR (-O0):
define void @lpc2ref(float* %0, float* %1, i32 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
%10 = alloca float
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = mul i64 4, %15
%17 = trunc i64 %16 to i32
%18 = call i64 @cst_safe_alloc(i32 %17)
%19 = inttoptr i64 %18 to float*
store float* %19, float** %13
%20 = load i32, i32* %6
%21 = sub nsw i32 %20, 1
store i32 %21, i32* %7
%22 = load float*, float** %4
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
%26 = load float, float* %25
store float %26, float* %10
%27 = load float*, float** %5
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %27, i64 %29
store float %26, float* %30
%31 = load float, float* %10
%32 = load float, float* %10
%33 = fneg float %31
%34 = call float @llvm.fmuladd.f32(float %33, float %32, float 1.000000e+00)
store float %34, float* %9
%35 = load i32, i32* %7
%36 = add nsw i32 %35, -1
store i32 %36, i32* %7
store i32 0, i32* %8
br label %37
37: ; preds = %62, %3
%38 = load i32, i32* %8
%39 = load i32, i32* %7
%40 = icmp sle i32 %38, %39
br i1 %40, label %41, label %65
41: ; preds = %37
%42 = load float*, float** %4
%43 = load i32, i32* %8
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds float, float* %42, i64 %44
%46 = load float, float* %45
%47 = load float, float* %10
%48 = load float*, float** %4
%49 = load i32, i32* %7
%50 = load i32, i32* %8
%51 = sub nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %48, i64 %52
%54 = load float, float* %53
%55 = call float @llvm.fmuladd.f32(float %47, float %54, float %46)
%56 = load float, float* %9
%57 = fdiv float %55, %56
%58 = load float*, float** %5
%59 = load i32, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %58, i64 %60
store float %57, float* %61
br label %62
62: ; preds = %41
%63 = load i32, i32* %8
%64 = add nsw i32 %63, 1
store i32 %64, i32* %8
br label %37
65: ; preds = %37
%66 = load float*, float** %5
store float* %66, float** %11
br label %67
67: ; preds = %110, %65
%68 = load i32, i32* %7
%69 = icmp sgt i32 %68, 0
br i1 %69, label %70, label %123
70: ; preds = %67
%71 = load float*, float** %11
%72 = load i32, i32* %7
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
store float %75, float* %10
%76 = load float, float* %10
%77 = load float, float* %10
%78 = fneg float %76
%79 = call float @llvm.fmuladd.f32(float %78, float %77, float 1.000000e+00)
store float %79, float* %9
%80 = load i32, i32* %7
%81 = add nsw i32 %80, -1
store i32 %81, i32* %7
store i32 0, i32* %8
br label %82
82: ; preds = %107, %70
%83 = load i32, i32* %8
%84 = load i32, i32* %7
%85 = icmp sle i32 %83, %84
br i1 %85, label %86, label %110
86: ; preds = %82
%87 = load float*, float** %11
%88 = load i32, i32* %8
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %87, i64 %89
%91 = load float, float* %90
%92 = load float, float* %10
%93 = load float*, float** %11
%94 = load i32, i32* %7
%95 = load i32, i32* %8
%96 = sub nsw i32 %94, %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %93, i64 %97
%99 = load float, float* %98
%100 = call float @llvm.fmuladd.f32(float %92, float %99, float %91)
%101 = load float, float* %9
%102 = fdiv float %100, %101
%103 = load float*, float** %13
%104 = load i32, i32* %8
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %103, i64 %105
store float %102, float* %106
br label %107
107: ; preds = %86
%108 = load i32, i32* %8
%109 = add nsw i32 %108, 1
store i32 %109, i32* %8
br label %82
110: ; preds = %82
%111 = load float*, float** %13
%112 = load i32, i32* %7
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = load float*, float** %5
%117 = load i32, i32* %7
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %116, i64 %118
store float %115, float* %119
%120 = load float*, float** %13
store float* %120, float** %12
%121 = load float*, float** %11
store float* %121, float** %13
%122 = load float*, float** %12
store float* %122, float** %11
br label %67
123: ; preds = %67
%124 = load float*, float** %13
%125 = call i32 @cst_free(float* %124)
ret void
}

LLVM IR (-O2):
define void @lpc2ref(float* nocapture %0, float* %1, i32 %2) {
%4 = shl i32 %2, 2
%5 = tail call i64 @cst_safe_alloc(i32 %4)
%6 = inttoptr i64 %5 to float*
%7 = add i32 %2, -1
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds float, float* %0, i64 %8
%10 = load float, float* %9
%11 = getelementptr inbounds float, float* %1, i64 %8
store float %10, float* %11
%12 = fneg float %10
%13 = tail call float @llvm.fmuladd.f32(float %12, float %10, float 1.000000e+00)
%14 = add i32 %2, -2
%15 = icmp slt i32 %2, 2
br i1 %15, label %288, label %16
16: ; preds = %3
%17 = zext i32 %14 to i64
%18 = zext i32 %7 to i64
%19 = icmp ult i32 %7, 4
br i1 %19, label %100, label %20
20: ; preds = %16
%21 = getelementptr float, float* %1, i64 %18
%22 = add nuw nsw i64 %17, 1
%23 = sub nsw i64 %22, %18
%24 = getelementptr float, float* %0, i64 %23
%25 = add nuw nsw i64 %17, 1
%26 = getelementptr float, float* %0, i64 %25
%27 = getelementptr float, float* %0, i64 %18
%28 = icmp ugt float* %26, %1
%29 = icmp ult float* %24, %21
%30 = and i1 %28, %29
%31 = icmp ugt float* %27, %1
%32 = icmp ugt float* %21, %0
%33 = and i1 %31, %32
%34 = or i1 %30, %33
br i1 %34, label %100, label %35
35: ; preds = %20
%36 = and i64 %18, 4294967292
%37 = insertelement <4 x float> poison, float %10, i64 0
%38 = shufflevector <4 x float> %37, <4 x float> poison, <4 x i32> zeroinitializer
%39 = insertelement <4 x float> poison, float %13, i64 0
%40 = shufflevector <4 x float> %39, <4 x float> poison, <4 x i32> zeroinitializer
%41 = add nsw i64 %36, -4
%42 = lshr exact i64 %41, 2
%43 = add nuw nsw i64 %42, 1
%44 = and i64 %43, 1
%45 = icmp eq i64 %41, 0
br i1 %45, label %81, label %46
46: ; preds = %35
%47 = and i64 %43, 9223372036854775806
%48 = getelementptr inbounds float, float* %0, i64 -3
%49 = getelementptr inbounds float, float* %0, i64 -3
br label %50
50: ; preds = %50, %46
%51 = phi i64 [ 0, %46 ], [ %78, %50 ]
%52 = phi i64 [ 0, %46 ], [ %79, %50 ]
%53 = getelementptr inbounds float, float* %0, i64 %51
%54 = bitcast float* %53 to <4 x float>*
%55 = load <4 x float>, <4 x float>* %54
%56 = sub nsw i64 %17, %51
%57 = getelementptr inbounds float, float* %48, i64 %56
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = shufflevector <4 x float> %59, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%61 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %38, <4 x float> %60, <4 x float> %55)
%62 = fdiv <4 x float> %61, %40
%63 = getelementptr inbounds float, float* %1, i64 %51
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %62, <4 x float>* %64
%65 = or i64 %51, 4
%66 = getelementptr inbounds float, float* %0, i64 %65
%67 = bitcast float* %66 to <4 x float>*
%68 = load <4 x float>, <4 x float>* %67
%69 = sub nsw i64 %17, %65
%70 = getelementptr inbounds float, float* %49, i64 %69
%71 = bitcast float* %70 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%74 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %38, <4 x float> %73, <4 x float> %68)
%75 = fdiv <4 x float> %74, %40
%76 = getelementptr inbounds float, float* %1, i64 %65
%77 = bitcast float* %76 to <4 x float>*
store <4 x float> %75, <4 x float>* %77
%78 = add nuw i64 %51, 8
%79 = add i64 %52, 2
%80 = icmp eq i64 %79, %47
br i1 %80, label %81, label %50
81: ; preds = %50, %35
%82 = phi i64 [ 0, %35 ], [ %78, %50 ]
%83 = icmp eq i64 %44, 0
br i1 %83, label %98, label %84
84: ; preds = %81
%85 = getelementptr inbounds float, float* %0, i64 %82
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = sub nsw i64 %17, %82
%89 = getelementptr inbounds float, float* %0, i64 -3
%90 = getelementptr inbounds float, float* %89, i64 %88
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = shufflevector <4 x float> %92, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%94 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %38, <4 x float> %93, <4 x float> %87)
%95 = fdiv <4 x float> %94, %40
%96 = getelementptr inbounds float, float* %1, i64 %82
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %95, <4 x float>* %97
br label %98
98: ; preds = %81, %84
%99 = icmp eq i64 %36, %18
br i1 %99, label %119, label %100
100: ; preds = %20, %16, %98
%101 = phi i64 [ 0, %20 ], [ 0, %16 ], [ %36, %98 ]
%102 = xor i64 %101, -1
%103 = and i64 %18, 1
%104 = icmp eq i64 %103, 0
br i1 %104, label %115, label %105
105: ; preds = %100
%106 = getelementptr inbounds float, float* %0, i64 %101
%107 = load float, float* %106
%108 = sub nsw i64 %17, %101
%109 = getelementptr inbounds float, float* %0, i64 %108
%110 = load float, float* %109
%111 = tail call float @llvm.fmuladd.f32(float %10, float %110, float %107)
%112 = fdiv float %111, %13
%113 = getelementptr inbounds float, float* %1, i64 %101
store float %112, float* %113
%114 = or i64 %101, 1
br label %115
115: ; preds = %105, %100
%116 = phi i64 [ %101, %100 ], [ %114, %105 ]
%117 = sub nsw i64 0, %18
%118 = icmp eq i64 %102, %117
br i1 %118, label %119, label %123
119: ; preds = %115, %123, %98
%120 = icmp sgt i32 %2, 2
br i1 %120, label %121, label %288
121: ; preds = %119
%122 = zext i32 %14 to i64
br label %144
123: ; preds = %115, %123
%124 = phi i64 [ %142, %123 ], [ %116, %115 ]
%125 = getelementptr inbounds float, float* %0, i64 %124
%126 = load float, float* %125
%127 = sub nsw i64 %17, %124
%128 = getelementptr inbounds float, float* %0, i64 %127
%129 = load float, float* %128
%130 = tail call float @llvm.fmuladd.f32(float %10, float %129, float %126)
%131 = fdiv float %130, %13
%132 = getelementptr inbounds float, float* %1, i64 %124
store float %131, float* %132
%133 = add nuw nsw i64 %124, 1
%134 = getelementptr inbounds float, float* %0, i64 %133
%135 = load float, float* %134
%136 = sub nsw i64 %17, %133
%137 = getelementptr inbounds float, float* %0, i64 %136
%138 = load float, float* %137
%139 = tail call float @llvm.fmuladd.f32(float %10, float %138, float %135)
%140 = fdiv float %139, %13
%141 = getelementptr inbounds float, float* %1, i64 %133
store float %140, float* %141
%142 = add nuw nsw i64 %124, 2
%143 = icmp eq i64 %142, %18
br i1 %143, label %119, label %123
144: ; preds = %282, %121
%145 = phi i64 [ %287, %282 ], [ 0, %121 ]
%146 = phi i64 [ %160, %282 ], [ %122, %121 ]
%147 = phi float* [ %148, %282 ], [ %6, %121 ]
%148 = phi float* [ %147, %282 ], [ %1, %121 ]
%149 = xor i64 %145, -1
%150 = add i64 %149, %17
%151 = add i64 %146, -4
%152 = lshr i64 %151, 2
%153 = add nuw nsw i64 %152, 1
%154 = xor i64 %145, -1
%155 = add i64 %154, %122
%156 = getelementptr inbounds float, float* %148, i64 %146
%157 = load float, float* %156
%158 = fneg float %157
%159 = tail call float @llvm.fmuladd.f32(float %158, float %157, float 1.000000e+00)
%160 = add nsw i64 %146, -1
%161 = icmp ult i64 %146, 4
br i1 %161, label %244, label %162
162: ; preds = %144
%163 = getelementptr float, float* %148, i64 %155
%164 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %155, i64 4)
%165 = extractvalue { i64, i1 } %164, 0
%166 = extractvalue { i64, i1 } %164, 1
%167 = bitcast float* %163 to i8*
%168 = sub i64 0, %165
%169 = getelementptr i8, i8* %167, i64 %168
%170 = icmp ugt i8* %169, %167
%171 = or i1 %170, %166
br i1 %171, label %244, label %172
172: ; preds = %162
%173 = getelementptr float, float* %147, i64 %146
%174 = getelementptr float, float* %148, i64 %146
%175 = icmp ult float* %147, %174
%176 = icmp ult float* %148, %173
%177 = and i1 %175, %176
%178 = icmp ult float* %147, %174
%179 = icmp ult float* %148, %173
%180 = and i1 %178, %179
%181 = or i1 %177, %180
br i1 %181, label %244, label %182
182: ; preds = %172
%183 = and i64 %146, -4
%184 = insertelement <4 x float> poison, float %157, i64 0
%185 = shufflevector <4 x float> %184, <4 x float> poison, <4 x i32> zeroinitializer
%186 = insertelement <4 x float> poison, float %159, i64 0
%187 = shufflevector <4 x float> %186, <4 x float> poison, <4 x i32> zeroinitializer
%188 = and i64 %153, 1
%189 = icmp ult i64 %151, 4
br i1 %189, label %225, label %190
190: ; preds = %182
%191 = and i64 %153, 9223372036854775806
%192 = getelementptr inbounds float, float* %148, i64 -3
%193 = getelementptr inbounds float, float* %148, i64 -3
br label %194
194: ; preds = %194, %190
%195 = phi i64 [ 0, %190 ], [ %222, %194 ]
%196 = phi i64 [ 0, %190 ], [ %223, %194 ]
%197 = getelementptr inbounds float, float* %148, i64 %195
%198 = bitcast float* %197 to <4 x float>*
%199 = load <4 x float>, <4 x float>* %198
%200 = sub nsw i64 %160, %195
%201 = getelementptr inbounds float, float* %192, i64 %200
%202 = bitcast float* %201 to <4 x float>*
%203 = load <4 x float>, <4 x float>* %202
%204 = shufflevector <4 x float> %203, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%205 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %185, <4 x float> %204, <4 x float> %199)
%206 = fdiv <4 x float> %205, %187
%207 = getelementptr inbounds float, float* %147, i64 %195
%208 = bitcast float* %207 to <4 x float>*
store <4 x float> %206, <4 x float>* %208
%209 = or i64 %195, 4
%210 = getelementptr inbounds float, float* %148, i64 %209
%211 = bitcast float* %210 to <4 x float>*
%212 = load <4 x float>, <4 x float>* %211
%213 = sub nsw i64 %160, %209
%214 = getelementptr inbounds float, float* %193, i64 %213
%215 = bitcast float* %214 to <4 x float>*
%216 = load <4 x float>, <4 x float>* %215
%217 = shufflevector <4 x float> %216, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%218 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %185, <4 x float> %217, <4 x float> %212)
%219 = fdiv <4 x float> %218, %187
%220 = getelementptr inbounds float, float* %147, i64 %209
%221 = bitcast float* %220 to <4 x float>*
store <4 x float> %219, <4 x float>* %221
%222 = add nuw i64 %195, 8
%223 = add i64 %196, 2
%224 = icmp eq i64 %223, %191
br i1 %224, label %225, label %194
225: ; preds = %194, %182
%226 = phi i64 [ 0, %182 ], [ %222, %194 ]
%227 = icmp eq i64 %188, 0
br i1 %227, label %242, label %228
228: ; preds = %225
%229 = getelementptr inbounds float, float* %148, i64 %226
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = sub nsw i64 %160, %226
%233 = getelementptr inbounds float, float* %148, i64 -3
%234 = getelementptr inbounds float, float* %233, i64 %232
%235 = bitcast float* %234 to <4 x float>*
%236 = load <4 x float>, <4 x float>* %235
%237 = shufflevector <4 x float> %236, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%238 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %185, <4 x float> %237, <4 x float> %231)
%239 = fdiv <4 x float> %238, %187
%240 = getelementptr inbounds float, float* %147, i64 %226
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> %239, <4 x float>* %241
br label %242
242: ; preds = %225, %228
%243 = icmp eq i64 %146, %183
br i1 %243, label %282, label %244
244: ; preds = %172, %162, %144, %242
%245 = phi i64 [ 0, %172 ], [ 0, %162 ], [ 0, %144 ], [ %183, %242 ]
%246 = and i64 %146, 1
%247 = icmp eq i64 %246, 0
br i1 %247, label %258, label %248
248: ; preds = %244
%249 = getelementptr inbounds float, float* %148, i64 %245
%250 = load float, float* %249
%251 = sub nsw i64 %160, %245
%252 = getelementptr inbounds float, float* %148, i64 %251
%253 = load float, float* %252
%254 = tail call float @llvm.fmuladd.f32(float %157, float %253, float %250)
%255 = fdiv float %254, %159
%256 = getelementptr inbounds float, float* %147, i64 %245
store float %255, float* %256
%257 = or i64 %245, 1
br label %258
258: ; preds = %248, %244
%259 = phi i64 [ %245, %244 ], [ %257, %248 ]
%260 = icmp eq i64 %150, %245
br i1 %260, label %282, label %261
261: ; preds = %258, %261
%262 = phi i64 [ %280, %261 ], [ %259, %258 ]
%263 = getelementptr inbounds float, float* %148, i64 %262
%264 = load float, float* %263
%265 = sub nsw i64 %160, %262
%266 = getelementptr inbounds float, float* %148, i64 %265
%267 = load float, float* %266
%268 = tail call float @llvm.fmuladd.f32(float %157, float %267, float %264)
%269 = fdiv float %268, %159
%270 = getelementptr inbounds float, float* %147, i64 %262
store float %269, float* %270
%271 = add nuw nsw i64 %262, 1
%272 = getelementptr inbounds float, float* %148, i64 %271
%273 = load float, float* %272
%274 = sub nsw i64 %160, %271
%275 = getelementptr inbounds float, float* %148, i64 %274
%276 = load float, float* %275
%277 = tail call float @llvm.fmuladd.f32(float %157, float %276, float %273)
%278 = fdiv float %277, %159
%279 = getelementptr inbounds float, float* %147, i64 %271
store float %278, float* %279
%280 = add nuw nsw i64 %262, 2
%281 = icmp eq i64 %280, %146
br i1 %281, label %282, label %261
282: ; preds = %258, %261, %242
%283 = getelementptr inbounds float, float* %147, i64 %160
%284 = load float, float* %283
%285 = getelementptr inbounds float, float* %1, i64 %160
store float %284, float* %285
%286 = icmp sgt i64 %146, 1
%287 = add i64 %145, 1
br i1 %286, label %144, label %288
288: ; preds = %282, %3, %119
%289 = phi float* [ %6, %119 ], [ %6, %3 ], [ %148, %282 ]
%290 = tail call i32 @cst_free(float* %289)
ret void
}