#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_vector(float *, int, unsigned long);
int /*<<< orphan*/ nrerror(char *);
float *vector(int, unsigned long);
void cyclic(float a[], float b[], float c[], float alpha, float beta, float r[],
            float x[], unsigned long n) {
  void tridag(float a[], float b[], float c[], float r[], float u[],
              unsigned long n);
  unsigned long i;
  float fact, gamma, *bb, *u, *z;
  if (n <= 2)
    nrerror("n too small in cyclic");
  bb = vector(1, n);
  u = vector(1, n);
  z = vector(1, n);
  gamma = -b[1];
  bb[1] = b[1] - gamma;
  bb[n] = b[n] - alpha * beta / gamma;
  for (i = 2; i < n; i++)
    bb[i] = b[i];
  tridag(a, bb, c, r, x, n);
  u[1] = gamma;
  u[n] = alpha;
  for (i = 2; i < n; i++)
    u[i] = 0.0;
  tridag(a, bb, c, u, z, n);
  fact = (x[1] + beta * x[n] / gamma) / (1.0 + z[1] + beta * z[n] / gamma);
  for (i = 1; i <= n; i++)
    x[i] -= fact * z[i];
  free_vector(z, 1, n);
  free_vector(u, 1, n);
  free_vector(bb, 1, n);
}


x86 assembly (clang, -O0):
<cyclic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
cmpq   $0x2,-0x38(%rbp)
ja     1181 <cyclic+0x41>
lea    0xe8c(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x38(%rbp),%rsi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rsi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rsi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x1c(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
divss  -0x48(%rbp),%xmm1
subss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    1257 <cyclic+0x117>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    121e <cyclic+0xde>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
call   1060 <tridag@plt>
movss  -0x48(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    12cb <cyclic+0x18b>
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    129c <cyclic+0x15c>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x38(%rbp),%r9
call   1060 <tridag@plt>
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
divss  -0x48(%rbp),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xcdb(%rip),%xmm1
addsd  %xmm2,%xmm1
movss  -0x20(%rbp),%xmm2
mov    -0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
divss  -0x48(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
ja     13b6 <cyclic+0x276>
movss  -0x44(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    135d <cyclic+0x21d>
mov    -0x60(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_vector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cyclic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,0x10(%rsp)
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,%rbp
mov    %rdi,(%rsp)
cmp    $0x2,%r9
ja     1193 <cyclic+0x43>
lea    0xe8a(%rip),%rdi
call   1030 <nrerror@plt>
mov    $0x1,%edi
mov    %r14,%rsi
call   1060 <vector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r14,%rsi
call   1060 <vector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %r14,%rsi
call   1060 <vector@plt>
mov    %rax,%r13
movss  0x4(%rbp),%xmm2
movaps 0xe31(%rip),%xmm1
xorps  %xmm2,%xmm1
movaps %xmm2,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rbx)
movss  0x8(%rsp),%xmm0
movss  0xc(%rsp),%xmm3
mulss  %xmm3,%xmm0
movaps %xmm2,0x30(%rsp)
divss  %xmm2,%xmm0
addss  0x0(%rbp,%r14,4),%xmm0
movss  %xmm0,(%rbx,%r14,4)
cmp    $0x3,%r14
movaps %xmm1,0x20(%rsp)
jb     1273 <cyclic+0x123>
lea    -0x2(%r14),%r8
mov    $0x2,%eax
cmp    $0x8,%r8
jb     1352 <cyclic+0x202>
lea    0x8(%rbx),%rdx
lea    0x0(,%r14,4),%rsi
add    %rbp,%rsi
cmp    %rsi,%rdx
jae    1247 <cyclic+0xf7>
lea    (%rbx,%r14,4),%rdx
lea    0x8(%rbp),%rsi
cmp    %rdx,%rsi
jb     1352 <cyclic+0x202>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    12af <cyclic+0x15f>
xor    %esi,%esi
mov    (%rsp),%rdi
jmp    131a <cyclic+0x1ca>
mov    (%rsp),%rdi
mov    %rbx,%rsi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdx
mov    0x10(%rsp),%rcx
mov    %r15,%r8
mov    %r14,%r9
call   1070 <tridag@plt>
movaps 0x20(%rsp),%xmm0
movss  %xmm0,0x4(%r12)
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%r12,%r14,4)
jmp    1431 <cyclic+0x2e1>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
mov    (%rsp),%rdi
nopl   0x0(%rax)
movups 0x8(%rbp,%rsi,4),%xmm0
movups 0x18(%rbp,%rsi,4),%xmm1
movups %xmm0,0x8(%rbx,%rsi,4)
movups %xmm1,0x18(%rbx,%rsi,4)
movups 0x28(%rbp,%rsi,4),%xmm0
movups 0x38(%rbp,%rsi,4),%xmm1
movups %xmm0,0x28(%rbx,%rsi,4)
movups %xmm1,0x38(%rbx,%rsi,4)
movups 0x48(%rbp,%rsi,4),%xmm0
movups 0x58(%rbp,%rsi,4),%xmm1
movups %xmm0,0x48(%rbx,%rsi,4)
movups %xmm1,0x58(%rbx,%rsi,4)
movups 0x68(%rbp,%rsi,4),%xmm0
movups 0x78(%rbp,%rsi,4),%xmm1
movups %xmm0,0x68(%rbx,%rsi,4)
movups %xmm1,0x78(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    12c0 <cyclic+0x170>
test   %rcx,%rcx
je     1349 <cyclic+0x1f9>
nop
lea    0x0(,%rsi,4),%rdx
or     $0x8,%rdx
movups 0x0(%rbp,%rdx,1),%xmm0
movups 0x10(%rbp,%rdx,1),%xmm1
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rcx
jne    1320 <cyclic+0x1d0>
cmp    %rax,%r8
je     13c8 <cyclic+0x278>
or     $0x2,%rax
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
and    $0x3,%rdx
je     16a7 <cyclic+0x557>
mov    (%rsp),%rdi
xchg   %ax,%ax
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1370 <cyclic+0x220>
cmp    $0x3,%rcx
jb     13c8 <cyclic+0x278>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
movss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    1390 <cyclic+0x240>
mov    %rbx,%rsi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdx
mov    0x10(%rsp),%rcx
mov    %r15,%r8
mov    %r14,%r9
call   1070 <tridag@plt>
movaps 0x20(%rsp),%xmm0
movss  %xmm0,0x4(%r12)
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%r12,%r14,4)
cmp    $0x3,%r14
jb     1431 <cyclic+0x2e1>
mov    %r12,%rdi
add    $0x8,%rdi
lea    -0x8(,%r14,4),%rdx
ff
xor    %esi,%esi
call   1050 <memset@plt>
mov    (%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r12,%rcx
mov    %r13,%r8
mov    %r14,%r9
call   1070 <tridag@plt>
jmp    1452 <cyclic+0x302>
mov    (%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r12,%rcx
mov    %r13,%r8
mov    %r14,%r9
call   1070 <tridag@plt>
test   %r14,%r14
je     1669 <cyclic+0x519>
movss  0x4(%r15),%xmm1
movss  (%r15,%r14,4),%xmm0
movss  0xc(%rsp),%xmm4
mulss  %xmm4,%xmm0
divss  0x30(%rsp),%xmm0
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movss  0x4(%r13),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
addsd  0xb7f(%rip),%xmm3
mulss  0x0(%r13,%r14,4),%xmm4
divss  0x20(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
divsd  %xmm4,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x4(%r15)
cmp    $0x1,%r14
je     1669 <cyclic+0x519>
xorps  0xb33(%rip),%xmm0
lea    -0x1(%r14),%rcx
mov    $0x2,%eax
cmp    $0x8,%rcx
jb     15f5 <cyclic+0x4a5>
lea    0x8(%r15),%rdx
lea    0x4(,%r14,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rdx
jae    150c <cyclic+0x3bc>
lea    (%r15,%r14,4),%rdx
add    $0x4,%rdx
mov    %r13,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     15f5 <cyclic+0x4a5>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     16ba <cyclic+0x56a>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rsi,%rdi
mov    $0x2,%edx
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rdx,4),%xmm2
movups 0x10(%r13,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
movups (%r15,%rdx,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%r15,%rdx,4),%xmm2
movups 0x20(%r15,%rdx,4),%xmm5
movups 0x30(%r15,%rdx,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,(%r15,%rdx,4)
movups %xmm3,0x10(%r15,%rdx,4)
movups 0x20(%r13,%rdx,4),%xmm2
movups 0x30(%r13,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,0x20(%r15,%rdx,4)
movups %xmm3,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1550 <cyclic+0x400>
test   $0x1,%sil
je     15ec <cyclic+0x49c>
movups 0x0(%r13,%rdx,4),%xmm2
movups 0x10(%r13,%rdx,4),%xmm3
movups (%r15,%rdx,4),%xmm4
movups 0x10(%r15,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%r15,%rdx,4)
movups %xmm3,0x10(%r15,%rdx,4)
cmp    %rax,%rcx
je     1669 <cyclic+0x519>
or     $0x2,%rax
lea    0x1(%r14),%rcx
mov    %ecx,%esi
sub    %eax,%esi
mov    %rax,%rdx
test   $0x1,%sil
je     1621 <cyclic+0x4d1>
movss  0x0(%r13,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%rax,4),%xmm1
movss  %xmm1,(%r15,%rax,4)
lea    0x1(%rax),%rdx
cmp    %r14,%rax
je     1669 <cyclic+0x519>
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%r15,%rdx,4),%xmm1
movss  %xmm1,0x4(%r15,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1630 <cyclic+0x4e0>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1040 <free_vector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1040 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>
mov    (%rsp),%rdi
cmp    $0x3,%rcx
jae    1390 <cyclic+0x240>
jmp    13c8 <cyclic+0x278>
mov    $0x2,%edx
test   $0x1,%sil
jne    15be <cyclic+0x46e>
jmp    15ec <cyclic+0x49c>

LLVM IR (-O0):
@.str = [22 x i8] c"n too small in cyclic\00"
define void @cyclic(float* %0, float* %1, float* %2, float %3, float %4, float* %5, float* %6, i64 %7) {
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float
%13 = alloca float
%14 = alloca float*
%15 = alloca float*
%16 = alloca i64
%17 = alloca i64
%18 = alloca float
%19 = alloca float
%20 = alloca float*
%21 = alloca float*
%22 = alloca float*
store float* %0, float** %9
store float* %1, float** %10
store float* %2, float** %11
store float %3, float* %12
store float %4, float* %13
store float* %5, float** %14
store float* %6, float** %15
store i64 %7, i64* %16
%23 = load i64, i64* %16
%24 = icmp ule i64 %23, 2
br i1 %24, label %25, label %27
25: ; preds = %8
%26 = call i32 @nrerror(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
br label %27
27: ; preds = %25, %8
%28 = load i64, i64* %16
%29 = call float* @vector(i32 1, i64 %28)
store float* %29, float** %20
%30 = load i64, i64* %16
%31 = call float* @vector(i32 1, i64 %30)
store float* %31, float** %21
%32 = load i64, i64* %16
%33 = call float* @vector(i32 1, i64 %32)
store float* %33, float** %22
%34 = load float*, float** %10
%35 = getelementptr inbounds float, float* %34, i64 1
%36 = load float, float* %35
%37 = fneg float %36
store float %37, float* %19
%38 = load float*, float** %10
%39 = getelementptr inbounds float, float* %38, i64 1
%40 = load float, float* %39
%41 = load float, float* %19
%42 = fsub float %40, %41
%43 = load float*, float** %20
%44 = getelementptr inbounds float, float* %43, i64 1
store float %42, float* %44
%45 = load float*, float** %10
%46 = load i64, i64* %16
%47 = getelementptr inbounds float, float* %45, i64 %46
%48 = load float, float* %47
%49 = load float, float* %12
%50 = load float, float* %13
%51 = fmul float %49, %50
%52 = load float, float* %19
%53 = fdiv float %51, %52
%54 = fsub float %48, %53
%55 = load float*, float** %20
%56 = load i64, i64* %16
%57 = getelementptr inbounds float, float* %55, i64 %56
store float %54, float* %57
store i64 2, i64* %17
br label %58
58: ; preds = %70, %27
%59 = load i64, i64* %17
%60 = load i64, i64* %16
%61 = icmp ult i64 %59, %60
br i1 %61, label %62, label %73
62: ; preds = %58
%63 = load float*, float** %10
%64 = load i64, i64* %17
%65 = getelementptr inbounds float, float* %63, i64 %64
%66 = load float, float* %65
%67 = load float*, float** %20
%68 = load i64, i64* %17
%69 = getelementptr inbounds float, float* %67, i64 %68
store float %66, float* %69
br label %70
70: ; preds = %62
%71 = load i64, i64* %17
%72 = add i64 %71, 1
store i64 %72, i64* %17
br label %58
73: ; preds = %58
%74 = load float*, float** %9
%75 = load float*, float** %20
%76 = load float*, float** %11
%77 = load float*, float** %14
%78 = load float*, float** %15
%79 = load i64, i64* %16
%80 = load float, float* %19
%81 = load float*, float** %21
%82 = getelementptr inbounds float, float* %81, i64 1
store float %80, float* %82
%83 = load float, float* %12
%84 = load float*, float** %21
%85 = load i64, i64* %16
%86 = getelementptr inbounds float, float* %84, i64 %85
store float %83, float* %86
store i64 2, i64* %17
br label %87
87: ; preds = %95, %73
%88 = load i64, i64* %17
%89 = load i64, i64* %16
%90 = icmp ult i64 %88, %89
br i1 %90, label %91, label %98
91: ; preds = %87
%92 = load float*, float** %21
%93 = load i64, i64* %17
%94 = getelementptr inbounds float, float* %92, i64 %93
store float 0.000000e+00, float* %94
br label %95
95: ; preds = %91
%96 = load i64, i64* %17
%97 = add i64 %96, 1
store i64 %97, i64* %17
br label %87
98: ; preds = %87
%99 = load float*, float** %9
%100 = load float*, float** %20
%101 = load float*, float** %11
%102 = load float*, float** %21
%103 = load float*, float** %22
%104 = load i64, i64* %16
%105 = load float*, float** %15
%106 = getelementptr inbounds float, float* %105, i64 1
%107 = load float, float* %106
%108 = load float, float* %13
%109 = load float*, float** %15
%110 = load i64, i64* %16
%111 = getelementptr inbounds float, float* %109, i64 %110
%112 = load float, float* %111
%113 = fmul float %108, %112
%114 = load float, float* %19
%115 = fdiv float %113, %114
%116 = fadd float %107, %115
%117 = fpext float %116 to double
%118 = load float*, float** %22
%119 = getelementptr inbounds float, float* %118, i64 1
%120 = load float, float* %119
%121 = fpext float %120 to double
%122 = fadd double 1.000000e+00, %121
%123 = load float, float* %13
%124 = load float*, float** %22
%125 = load i64, i64* %16
%126 = getelementptr inbounds float, float* %124, i64 %125
%127 = load float, float* %126
%128 = fmul float %123, %127
%129 = load float, float* %19
%130 = fdiv float %128, %129
%131 = fpext float %130 to double
%132 = fadd double %122, %131
%133 = fdiv double %117, %132
%134 = fptrunc double %133 to float
store float %134, float* %18
store i64 1, i64* %17
br label %135
135: ; preds = %151, %98
%136 = load i64, i64* %17
%137 = load i64, i64* %16
%138 = icmp ule i64 %136, %137
br i1 %138, label %139, label %154
139: ; preds = %135
%140 = load float, float* %18
%141 = load float*, float** %22
%142 = load i64, i64* %17
%143 = getelementptr inbounds float, float* %141, i64 %142
%144 = load float, float* %143
%145 = load float*, float** %15
%146 = load i64, i64* %17
%147 = getelementptr inbounds float, float* %145, i64 %146
%148 = load float, float* %147
%149 = fneg float %140
%150 = call float @llvm.fmuladd.f32(float %149, float %144, float %148)
store float %150, float* %147
br label %151
151: ; preds = %139
%152 = load i64, i64* %17
%153 = add i64 %152, 1
store i64 %153, i64* %17
br label %135
154: ; preds = %135
%155 = load float*, float** %22
%156 = load i64, i64* %16
%157 = call i32 @free_vector(float* %155, i32 1, i64 %156)
%158 = load float*, float** %21
%159 = load i64, i64* %16
%160 = call i32 @free_vector(float* %158, i32 1, i64 %159)
%161 = load float*, float** %20
%162 = load i64, i64* %16
%163 = call i32 @free_vector(float* %161, i32 1, i64 %162)
ret void
}

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