#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, int);
float *vector(int, int);
void predic(float data[], int ndata, float d[], int m, float future[],
            int nfut) {
  int k, j;
  float sum, discrp, *reg;
  reg = vector(1, m);
  for (j = 1; j <= m; j++)
    reg[j] = data[ndata + 1 - j];
  for (j = 1; j <= nfut; j++) {
    discrp = 0.0;
    sum = discrp;
    for (k = 1; k <= m; k++)
      sum += d[k] * reg[k];
    for (k = m; k >= 2; k--)
      reg[k] = reg[k - 1];
    future[j] = reg[1] = sum;
  }
  free_vector(reg, 1, m);
}


x86 assembly (clang, -O0):
<predic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1192 <predic+0x72>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1156 <predic+0x36>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     126a <predic+0x14a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1204 <predic+0xe4>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11be <predic+0x9e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jl     1241 <predic+0x121>
mov    -0x48(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    120a <predic+0xea>
movss  -0x38(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1199 <predic+0x79>
mov    -0x48(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<predic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,0x50(%rsp)
mov    %ecx,%r12d
mov    %rdx,%rbx
mov    %esi,%r13d
mov    %rdi,%rbp
mov    $0x1,%edi
mov    %ecx,%esi
call   1040 <vector@plt>
mov    %rax,%rdi
mov    %r12d,%eax
mov    %rax,0x8(%rsp)
test   %r12d,%r12d
jle    1230 <predic+0x110>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r9
mov    $0x1,%eax
cmp    $0x8,%r12d
jae    1578 <predic+0x458>
mov    %r9d,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
add    %r9,%rdx
and    $0x3,%rsi
je     11bb <predic+0x9b>
mov    %r13d,%ecx
sub    %eax,%ecx
add    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rsi
jne    11a0 <predic+0x80>
cmp    $0x3,%rdx
jb     1230 <predic+0x110>
mov    %rax,%r8
sub    %r9,%r8
lea    (%rdi,%rax,4),%rcx
add    $0xc,%rcx
sub    %eax,%r13d
lea    -0x2(%r13),%r9d
lea    -0x1(%r13),%r10d
xor    %edx,%edx
nopl   0x0(%rax)
lea    (%rdx,%r13,1),%rax
lea    0x1(%rax),%esi
movslq %esi,%rsi
movss  0x0(%rbp,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rcx)
cltq
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x8(%rcx)
lea    (%r10,%rdx,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x4(%rcx)
lea    (%r9,%rdx,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx)
add    $0xfffffffffffffffc,%rdx
add    $0x10,%rcx
cmp    %rdx,%r8
jne    11e0 <predic+0xc0>
cmpl   $0x0,0x18(%rsp)
jle    155d <predic+0x43d>
lea    0x1(%r12),%ecx
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
mov    0x8(%rsp),%r9
lea    -0x2(%r9),%rax
lea    -0x1(%r12),%r13d
lea    (%rdi,%r9,4),%r14
lea    (%rdi,%r13,4),%rbp
mov    %r13,%rdx
sub    %r9,%rdx
mov    %rdx,0x10(%rsp)
lea    -0x1(%rcx),%r8
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x48(%rsp)
lea    -0x9(%r9),%r10
mov    %r10,0x40(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r8d,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%r8
cmp    %eax,%r13d
setb   %r11b
mov    %rax,%rdx
shr    $0x20,%rdx
setne  %r15b
or     %r11b,%r15b
mov    $0x4,%edx
mul    %rdx
mov    %rax,%r11
seto   0x20(%rsp)
mov    %r14,%rsi
sub    %rax,%rsi
cmp    %r14,%rsi
seta   %sil
lea    0x8(%rdi),%rax
mov    %rax,0x30(%rsp)
mov    %rbp,%rax
sub    %r11,%rbp
lea    (%rdi,%r9,4),%rdx
add    $0x4,%rdx
mov    %rdx,0x28(%rsp)
lea    0x4(%rdi,%r13,4),%r11
mov    0x10(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0x10(%rsp)
mov    0x20(%rsp),%dl
or     %dl,%sil
cmp    %rax,%rbp
lea    -0x1(%r9),%r13
seta   %bpl
or     %dl,%bpl
or     %r15b,%sil
or     %bpl,%sil
cmp    %r11,0x30(%rsp)
setb   %al
mov    0x10(%rsp),%rdx
cmp    0x28(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
mov    %r9,%rdx
mov    %rax,0x28(%rsp)
sub    %rax,%rdx
mov    %rdx,0x20(%rsp)
mov    %r10,%rax
mov    %r10,0x30(%rsp)
and    $0xfffffffffffffffe,%r10
mov    %r10,0x38(%rsp)
mov    $0xffffffff,%eax
lea    (%r9,%rax,1),%r11
add    $0xfffffffffffffff8,%r11
lea    (%r9,%rax,1),%r10
mov    $0x1,%r9d
jmp    139f <predic+0x27f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm0,0x4(%rdi)
mov    0x50(%rsp),%rax
movss  %xmm0,(%rax,%r9,4)
add    $0x1,%r9
cmp    0x18(%rsp),%r9
je     155d <predic+0x43d>
test   %r12d,%r12d
jle    13d0 <predic+0x2b0>
cmpq   $0x3,0x48(%rsp)
jae    13e0 <predic+0x2c0>
xorps  %xmm0,%xmm0
mov    $0x1,%r15d
test   %rcx,%rcx
jne    144a <predic+0x32a>
jmp    1477 <predic+0x357>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
jmp    1477 <predic+0x357>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%rbx,%r15,4),%xmm1
movss  0x8(%rbx,%r15,4),%xmm2
mulss  0x4(%rdi,%r15,4),%xmm1
mulss  0x8(%rdi,%r15,4),%xmm2
addss  %xmm0,%xmm1
movss  0xc(%rbx,%r15,4),%xmm3
mulss  0xc(%rdi,%r15,4),%xmm3
addss  %xmm1,%xmm2
movss  0x10(%rbx,%r15,4),%xmm0
mulss  0x10(%rdi,%r15,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%r15
cmp    %r15,%r8
jne    13f0 <predic+0x2d0>
add    $0x1,%r15
test   %rcx,%rcx
je     1477 <predic+0x357>
lea    (%rdi,%r15,4),%rax
lea    (%rbx,%r15,4),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rbp,4),%xmm1
mulss  (%rax,%rbp,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1460 <predic+0x340>
cmp    $0x2,%r12d
jl     1380 <predic+0x260>
cmp    $0x8,%r13
setb   %al
or     %sil,%al
or     0x10(%rsp),%al
mov    0x8(%rsp),%rax
jne    153b <predic+0x41b>
cmpq   $0x8,0x40(%rsp)
jae    14ad <predic+0x38d>
xor    %edx,%edx
testb  $0x1,0x30(%rsp)
jne    1508 <predic+0x3e8>
jmp    152b <predic+0x40b>
mov    0x38(%rsp),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r10,%rdx,1),%ebp
movups -0x1c(%rdi,%rbp,4),%xmm1
movups -0xc(%rdi,%rbp,4),%xmm2
movups %xmm2,-0xc(%r14,%rdx,4)
movups %xmm1,-0x1c(%r14,%rdx,4)
lea    (%r11,%rdx,1),%ebp
movups -0x1c(%rdi,%rbp,4),%xmm1
movups -0xc(%rdi,%rbp,4),%xmm2
movups %xmm2,-0x2c(%r14,%rdx,4)
movups %xmm1,-0x3c(%r14,%rdx,4)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rax
jne    14c0 <predic+0x3a0>
neg    %rdx
testb  $0x1,0x30(%rsp)
je     152b <predic+0x40b>
mov    0x8(%rsp),%rax
sub    %rdx,%rax
mov    $0xffffffff,%edx
add    %eax,%edx
movups -0x1c(%rdi,%rdx,4),%xmm1
movups -0xc(%rdi,%rdx,4),%xmm2
movups %xmm2,-0xc(%rdi,%rax,4)
movups %xmm1,-0x1c(%rdi,%rax,4)
mov    0x20(%rsp),%rax
cmp    0x28(%rsp),%r13
je     1380 <predic+0x260>
add    $0x1,%rax
nop
lea    -0x2(%rax),%edx
movss  (%rdi,%rdx,4),%xmm1
movss  %xmm1,-0x4(%rdi,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    $0x2,%rax
jg     1540 <predic+0x420>
jmp    1380 <predic+0x260>
mov    $0x1,%esi
mov    %r12d,%edx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>
lea    -0x2(%r9),%rcx
mov    %r13d,%edx
sub    %ecx,%edx
cmp    %r13d,%edx
jg     117c <predic+0x5c>
shr    $0x20,%rcx
jne    117c <predic+0x5c>
lea    0x4(%rdi),%rdx
movslq %r13d,%rcx
lea    0x4(,%rcx,4),%rsi
add    %rbp,%rsi
cmp    %rsi,%rdx
jae    15c6 <predic+0x4a6>
lea    (%rdi,%r9,4),%rdx
sub    %r9,%rcx
lea    0x8(,%rcx,4),%rcx
add    %rbp,%rcx
cmp    %rdx,%rcx
jb     117c <predic+0x5c>
mov    0x8(%rsp),%rax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1697 <predic+0x577>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %esi,%esi
mov    %r13d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rcx
movups -0x1c(%rbp,%rcx,4),%xmm0
movups -0xc(%rbp,%rcx,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm1,0x4(%rdi,%rsi,4)
movups %xmm0,0x14(%rdi,%rsi,4)
lea    -0x8(%rcx),%edx
movslq %edx,%rdx
movups -0x1c(%rbp,%rdx,4),%xmm0
movups -0xc(%rbp,%rdx,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
movups %xmm1,0x24(%rdi,%rsi,4)
movups %xmm0,0x34(%rdi,%rsi,4)
add    $0x10,%rsi
add    $0xfffffff0,%ecx
add    $0xfffffffffffffffe,%r10
jne    1600 <predic+0x4e0>
test   $0x1,%r8b
je     1683 <predic+0x563>
lea    0x0(,%rsi,4),%rcx
mov    %r13d,%edx
sub    %esi,%edx
movslq %edx,%rdx
movups -0x1c(%rbp,%rdx,4),%xmm0
movups -0xc(%rbp,%rdx,4),%xmm1
shufps $0x1b,%xmm1,%xmm1
shufps $0x1b,%xmm0,%xmm0
or     $0x4,%rcx
movups %xmm1,(%rdi,%rcx,1)
movups %xmm0,0x10(%rdi,%rcx,1)
cmp    %rax,0x8(%rsp)
je     1230 <predic+0x110>
or     $0x1,%rax
jmp    117c <predic+0x5c>
xor    %esi,%esi
test   $0x1,%r8b
jne    1654 <predic+0x534>
jmp    1683 <predic+0x563>

LLVM IR (-O0):
define void @predic(float* %0, i32 %1, float* %2, i32 %3, float* %4, i32 %5) {
%7 = alloca float*
%8 = alloca i32
%9 = alloca float*
%10 = alloca i32
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float*
store float* %0, float** %7
store i32 %1, i32* %8
store float* %2, float** %9
store i32 %3, i32* %10
store float* %4, float** %11
store i32 %5, i32* %12
%18 = load i32, i32* %10
%19 = call float* @vector(i32 1, i32 %18)
store float* %19, float** %17
store i32 1, i32* %14
br label %20
20: ; preds = %37, %6
%21 = load i32, i32* %14
%22 = load i32, i32* %10
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %40
24: ; preds = %20
%25 = load float*, float** %7
%26 = load i32, i32* %8
%27 = add nsw i32 %26, 1
%28 = load i32, i32* %14
%29 = sub nsw i32 %27, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %25, i64 %30
%32 = load float, float* %31
%33 = load float*, float** %17
%34 = load i32, i32* %14
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
store float %32, float* %36
br label %37
37: ; preds = %24
%38 = load i32, i32* %14
%39 = add nsw i32 %38, 1
store i32 %39, i32* %14
br label %20
40: ; preds = %20
store i32 1, i32* %14
br label %41
41: ; preds = %94, %40
%42 = load i32, i32* %14
%43 = load i32, i32* %12
%44 = icmp sle i32 %42, %43
br i1 %44, label %45, label %97
45: ; preds = %41
store float 0.000000e+00, float* %16
%46 = load float, float* %16
store float %46, float* %15
store i32 1, i32* %13
br label %47
47: ; preds = %64, %45
%48 = load i32, i32* %13
%49 = load i32, i32* %10
%50 = icmp sle i32 %48, %49
br i1 %50, label %51, label %67
51: ; preds = %47
%52 = load float*, float** %9
%53 = load i32, i32* %13
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = load float*, float** %17
%58 = load i32, i32* %13
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
%62 = load float, float* %15
%63 = call float @llvm.fmuladd.f32(float %56, float %61, float %62)
store float %63, float* %15
br label %64
64: ; preds = %51
%65 = load i32, i32* %13
%66 = add nsw i32 %65, 1
store i32 %66, i32* %13
br label %47
67: ; preds = %47
%68 = load i32, i32* %10
store i32 %68, i32* %13
br label %69
69: ; preds = %83, %67
%70 = load i32, i32* %13
%71 = icmp sge i32 %70, 2
br i1 %71, label %72, label %86
72: ; preds = %69
%73 = load float*, float** %17
%74 = load i32, i32* %13
%75 = sub nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %73, i64 %76
%78 = load float, float* %77
%79 = load float*, float** %17
%80 = load i32, i32* %13
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %79, i64 %81
store float %78, float* %82
br label %83
83: ; preds = %72
%84 = load i32, i32* %13
%85 = add nsw i32 %84, -1
store i32 %85, i32* %13
br label %69
86: ; preds = %69
%87 = load float, float* %15
%88 = load float*, float** %17
%89 = getelementptr inbounds float, float* %88, i64 1
store float %87, float* %89
%90 = load float*, float** %11
%91 = load i32, i32* %14
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %90, i64 %92
store float %87, float* %93
br label %94
94: ; preds = %86
%95 = load i32, i32* %14
%96 = add nsw i32 %95, 1
store i32 %96, i32* %14
br label %41
97: ; preds = %41
%98 = load float*, float** %17
%99 = load i32, i32* %10
%100 = call i32 @free_vector(float* %98, i32 1, i32 %99)
ret void
}

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