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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(float);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
int fa_atlvs(float *r, int n, float *b, float *x, float *kcof, float *err) {
  int i, j, k;
  float a, beta, q, c, h;
  float s[64];
  float y[64];
  memset(s, 0, sizeof(float) * 64);
  memset(y, 0, sizeof(float) * 64);
  a = r[0];
  if (fabs(a) + 1.0 == 1.0)
    return -1;
  y[0] = 1.0;
  x[0] = b[0] / a;
  for (k = 1; k <= n - 1; k++) {
    beta = 0.0;
    q = 0.0;
    for (j = 0; j <= k - 1; j++) {
      beta = beta + y[j] * r[j + 1];
      q = q + x[j] * r[k - j];
    }
    if (fabs(a) + 1.0 == 1.0)
      return -1;
    c = -beta / a;
    kcof[k - 1] = c;
    s[0] = c * y[k - 1];
    y[k] = y[k - 1];
    if (k != 1)
      for (i = 1; i <= k - 1; i++)
        s[i] = y[i - 1] + c * y[k - i - 1];
    a = a + c * beta;
    if (fabs(a) + 1.0 == 1.0)
      return -1;
    h = (b[k] - q) / a;
    for (i = 0; i <= k - 1; i++) {
      x[i] = x[i] + h * s[i];
      y[i] = s[i];
    }
    x[k] = h * y[k];
  }
  *err = a;
  return 0;
}


x86 assembly (clang, -O0):
<fa_atlvs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
lea    -0x160(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
lea    -0x260(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
call   1040 <fabs@plt>
movsd  0xe79(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0xe6d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    11af <fa_atlvs+0x8f>
jp     11af <fa_atlvs+0x8f>
movl   $0xffffffff,-0x4(%rbp)
jmp    14c8 <fa_atlvs+0x3a8>
movss  0xe51(%rip),%xmm0
movss  %xmm0,-0x260(%rbp)
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14b4 <fa_atlvs+0x394>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1284 <fa_atlvs+0x164>
movss  -0x4c(%rbp),%xmm1
movslq -0x40(%rbp),%rax
movss  -0x260(%rbp,%rax,4),%xmm0
ff ff
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1203 <fa_atlvs+0xe3>
movss  -0x48(%rbp),%xmm0
call   1040 <fabs@plt>
movsd  0xd6a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0xd5e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12be <fa_atlvs+0x19e>
jp     12be <fa_atlvs+0x19e>
movl   $0xffffffff,-0x4(%rbp)
jmp    14c8 <fa_atlvs+0x3a8>
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cltq
mulss  -0x260(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x160(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x260(%rbp,%rax,4),%xmm0
ff ff
movslq -0x44(%rbp),%rax
movss  %xmm0,-0x260(%rbp,%rax,4)
ff ff
cmpl   $0x1,-0x44(%rbp)
je     13a1 <fa_atlvs+0x281>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     139c <fa_atlvs+0x27c>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x260(%rbp,%rax,4),%xmm1
ff ff
movss  -0x54(%rbp),%xmm0
mov    -0x44(%rbp),%eax
sub    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x260(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x3c(%rbp),%rax
movss  %xmm0,-0x160(%rbp,%rax,4)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    133e <fa_atlvs+0x21e>
jmp    13a1 <fa_atlvs+0x281>
movss  -0x48(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
call   1040 <fabs@plt>
movsd  0xc31(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0xc25(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13f7 <fa_atlvs+0x2d7>
jp     13f7 <fa_atlvs+0x2d7>
movl   $0xffffffff,-0x4(%rbp)
jmp    14c8 <fa_atlvs+0x3a8>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1487 <fa_atlvs+0x367>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
movslq -0x3c(%rbp),%rax
movss  -0x160(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x3c(%rbp),%rax
movss  -0x160(%rbp,%rax,4),%xmm0
ff ff
movslq -0x3c(%rbp),%rax
movss  %xmm0,-0x260(%rbp,%rax,4)
ff ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    141a <fa_atlvs+0x2fa>
movss  -0x58(%rbp),%xmm0
movslq -0x44(%rbp),%rax
mulss  -0x260(%rbp,%rax,4),%xmm0
ff ff
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11db <fa_atlvs+0xbb>
movss  -0x48(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fa_atlvs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x248,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %esi,%r13d
mov    %rdi,%rbp
lea    0x140(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
movss  0x0(%rbp),%xmm0
movapd %xmm0,(%rsp)
call   1040 <fabs@plt>
movsd  0xe71(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    $0xffffffff,%eax
ucomisd %xmm1,%xmm0
jne    11a4 <fa_atlvs+0x74>
jnp    15b7 <fa_atlvs+0x487>
mov    %r14,0x28(%rsp)
movl   $0x3f800000,0x40(%rsp)
3f
movss  (%r12),%xmm0
movaps (%rsp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%rbx)
cmp    $0x2,%r13d
movaps %xmm1,%xmm0
jl     15a5 <fa_atlvs+0x475>
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
add    $0xffffffff,%r13d
mov    $0x1,%r14d
xor    %r15d,%r15d
movabs $0x3ffffffffffffffe,%r12
ff ff 3f
jmp    121e <fa_atlvs+0xee>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulss  0x40(%rsp,%r14,4),%xmm7
movss  %xmm7,(%rbx,%r14,4)
add    $0x1,%r14
add    $0x1,%r15
cmp    %r13,%r15
je     15a5 <fa_atlvs+0x475>
test   %r15,%r15
je     1530 <fa_atlvs+0x400>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
xorps  %xmm5,%xmm5
mov    %r15,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm1
movss  0x4(%rbx,%rax,4),%xmm2
movss  0x40(%rsp,%rax,4),%xmm3
unpcklps %xmm3,%xmm1
movss  0x44(%rsp,%rax,4),%xmm3
unpcklps %xmm3,%xmm2
movss  0x0(%rbp,%rdx,4),%xmm6
movss  0x4(%rbp,%rdx,4),%xmm3
movss  0x4(%rbp,%rax,4),%xmm4
unpcklps %xmm4,%xmm3
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movss  0x8(%rbp,%rax,4),%xmm1
unpcklps %xmm1,%xmm6
mulps  %xmm2,%xmm6
addps  %xmm3,%xmm6
add    $0x2,%rax
add    $0xfffffffffffffffe,%rdx
movaps %xmm6,%xmm5
cmp    %rax,%rcx
jne    1240 <fa_atlvs+0x110>
test   $0x1,%r14b
je     12c6 <fa_atlvs+0x196>
mov    %r14,%rcx
sub    %rax,%rcx
movss  (%rbx,%rax,4),%xmm3
movss  0x40(%rsp,%rax,4),%xmm1
unpcklps %xmm1,%xmm3
movss  0x4(%rbp,%rax,4),%xmm1
movss  0x0(%rbp,%rcx,4),%xmm2
unpcklps %xmm1,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm2,%xmm6
movaps %xmm6,0x10(%rsp)
movaps %xmm0,(%rsp)
call   1040 <fabs@plt>
movsd  0xd24(%rip),%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
jne    12ec <fa_atlvs+0x1bc>
jnp    15b2 <fa_atlvs+0x482>
movaps 0x10(%rsp),%xmm5
shufps $0x55,%xmm5,%xmm5
movaps %xmm5,%xmm1
xorps  0xd11(%rip),%xmm1
movaps (%rsp),%xmm0
divss  %xmm0,%xmm1
mov    0x38(%rsp),%rax
movss  %xmm1,-0x4(%rax,%r14,4)
movss  0x3c(%rsp,%r14,4),%xmm2
movaps %xmm1,%xmm3
mulss  %xmm2,%xmm3
movss  %xmm3,0x140(%rsp)
movss  %xmm2,0x40(%rsp,%r14,4)
cmp    $0x2,%r14
jb     13e6 <fa_atlvs+0x2b6>
mov    $0x1,%eax
cmp    $0x8,%r15
jb     13b9 <fa_atlvs+0x289>
mov    %r15,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %r15,%rdx
movabs $0x7ffffffffffffff8,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,%rax
or     $0x1,%rax
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %esi,%esi
nopl   (%rax)
mov    %rsi,%rdi
xor    %r12,%rdi
add    %r14,%rdi
movups 0x24(%rsp,%rdi,4),%xmm3
movups 0x34(%rsp,%rdi,4),%xmm4
shufps $0x1b,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  0x40(%rsp,%rsi,4),%xmm4
shufps $0x1b,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  0x50(%rsp,%rsi,4),%xmm3
movups %xmm4,0x144(%rsp,%rsi,4)
movups %xmm3,0x154(%rsp,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1370 <fa_atlvs+0x240>
cmp    %rdx,%r15
je     13e6 <fa_atlvs+0x2b6>
mov    %r15,%rcx
sub    %rax,%rcx
nop
movss  0x40(%rsp,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
addss  0x3c(%rsp,%rax,4),%xmm2
movss  %xmm2,0x140(%rsp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
cmp    %rax,%r14
jne    13c0 <fa_atlvs+0x290>
mulss  %xmm5,%xmm1
addss  %xmm1,%xmm0
movaps %xmm0,(%rsp)
call   1040 <fabs@plt>
movsd  0xc01(%rip),%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm1,%xmm0
jne    140f <fa_atlvs+0x2df>
jnp    15b2 <fa_atlvs+0x482>
lea    0x4(,%r15,4),%rdx
mov    0x30(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
subss  0x10(%rsp),%xmm0
divss  (%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x40(%rsp),%rdi
lea    0x140(%rsp),%rsi
call   1050 <memcpy@plt>
cmp    $0x8,%r14
jae    1460 <fa_atlvs+0x330>
xor    %eax,%eax
movaps (%rsp),%xmm0
movaps 0x10(%rsp),%xmm7
jmp    1580 <fa_atlvs+0x450>
nopw   0x0(%rax,%rax,1)
mov    %r14,%rax
movabs $0x7ffffffffffffff8,%rcx
ff ff 7f
and    %rcx,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
movaps 0x10(%rsp),%xmm7
movaps %xmm7,%xmm6
shufps $0x0,%xmm7,%xmm6
test   %rdx,%rdx
je     1544 <fa_atlvs+0x414>
mov    %r14,%rsi
and    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffff8,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
movaps (%rsp),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps 0x140(%rsp,%rdx,4),%xmm1
mulps  %xmm6,%xmm1
movups (%rbx,%rdx,4),%xmm2
addps  %xmm1,%xmm2
movups 0x10(%rbx,%rdx,4),%xmm1
movups 0x20(%rbx,%rdx,4),%xmm3
movups 0x30(%rbx,%rdx,4),%xmm4
movaps 0x150(%rsp,%rdx,4),%xmm5
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
movups %xmm2,(%rbx,%rdx,4)
movups %xmm5,0x10(%rbx,%rdx,4)
movaps 0x160(%rsp,%rdx,4),%xmm1
mulps  %xmm6,%xmm1
addps  %xmm3,%xmm1
movaps 0x170(%rsp,%rdx,4),%xmm2
mulps  %xmm6,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,0x20(%rbx,%rdx,4)
movups %xmm2,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    14c0 <fa_atlvs+0x390>
test   $0x1,%cl
jne    154f <fa_atlvs+0x41f>
jmp    159b <fa_atlvs+0x46b>
nop
xorps  %xmm6,%xmm6
xor    %eax,%eax
test   $0x1,%r14b
jne    129d <fa_atlvs+0x16d>
jmp    12c6 <fa_atlvs+0x196>
xor    %edx,%edx
movaps (%rsp),%xmm0
test   $0x1,%cl
je     159b <fa_atlvs+0x46b>
movups (%rbx,%rdx,4),%xmm1
movups 0x10(%rbx,%rdx,4),%xmm2
movaps %xmm6,%xmm3
mulps  0x140(%rsp,%rdx,4),%xmm3
addps  %xmm1,%xmm3
movaps 0x150(%rsp,%rdx,4),%xmm1
mulps  %xmm6,%xmm1
addps  %xmm2,%xmm1
movups %xmm3,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
jmp    159b <fa_atlvs+0x46b>
nop
movss  0x140(%rsp,%rax,4),%xmm1
mulss  %xmm7,%xmm1
addss  (%rbx,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1580 <fa_atlvs+0x450>
jmp    1200 <fa_atlvs+0xd0>
mov    0x28(%rsp),%rax
movss  %xmm0,(%rax)
xor    %eax,%eax
jmp    15b7 <fa_atlvs+0x487>
mov    $0xffffffff,%eax
add    $0x248,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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