#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*/ memcpy(float *, float *, int);
void syntFilter(float *Out, float *a, int len, float *mem) {
  int i, j;
  float *po, *pi, *pa, *pm;
  po = Out;
  for (i = 0; i < 10; i++) {
    pi = &Out[i - 1];
    pa = &a[1];
    pm = &mem[10 - 1];
    for (j = 1; j <= i; j++) {
      *po -= (*pa++) * (*pi--);
    }
    for (j = i + 1; j < 10 + 1; j++) {
      *po -= (*pa++) * (*pm--);
    }
    po++;
  }
  for (i = 10; i < len; i++) {
    pi = &Out[i - 1];
    pa = &a[1];
    for (j = 1; j < 10 + 1; j++) {
      *po -= (*pa++) * (*pi--);
    }
    po++;
  }
  memcpy(mem, &Out[len - 10], 10 * sizeof(float));
}


x86 assembly (clang, -O0):
<syntFilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    125c <syntFilter+0x14c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    $0x24,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11d9 <syntFilter+0xc9>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm2
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1177 <syntFilter+0x67>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xb,-0x28(%rbp)
jge    1242 <syntFilter+0x132>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm2
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e2 <syntFilter+0xd2>
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1136 <syntFilter+0x26>
movl   $0xa,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1314 <syntFilter+0x204>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x28(%rbp)
cmpl   $0xb,-0x28(%rbp)
jge    12fa <syntFilter+0x1ea>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm2
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129a <syntFilter+0x18a>
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1263 <syntFilter+0x153>
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x14(%rbp),%eax
sub    $0xa,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    $0x28,%edx
call   1030 <memcpy@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<syntFilter>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
lea    0x24(%rcx),%r8
lea    0x4(%rsi),%r9
lea    0x20(%rcx),%r10
xor    %r15d,%r15d
mov    %rdi,%r11
jmp    1141 <syntFilter+0x31>
nopl   0x0(%rax)
add    $0x4,%r11
mov    %r14,%r15
cmp    $0xa,%r14
je     1258 <syntFilter+0x148>
mov    %r9,%rax
test   %r15,%r15
je     11cc <syntFilter+0xbc>
lea    (%rdi,%r15,4),%rbx
add    $0xfffffffffffffffc,%rbx
movss  (%r11),%xmm0
cmp    $0x1,%r15d
jne    1170 <syntFilter+0x60>
mov    %r9,%rax
jmp    11b1 <syntFilter+0xa1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15d,%ebp
and    $0xfffffffe,%ebp
mov    %r9,%rax
nopl   0x0(%rax)
movss  (%rax),%xmm1
mulss  (%rbx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
movss  0x4(%rax),%xmm1
mulss  -0x4(%rbx),%xmm1
add    $0xfffffffffffffff8,%rbx
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
add    $0x8,%rax
add    $0xfffffffe,%ebp
jne    1180 <syntFilter+0x70>
test   $0x1,%r15b
je     11cc <syntFilter+0xbc>
movss  (%rax),%xmm1
mulss  (%rbx),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
add    $0x4,%rax
lea    0x1(%r15),%r14
movss  (%r11),%xmm0
test   $0x1,%r15b
jne    11f0 <syntFilter+0xe0>
mov    %r8,%rbx
mov    %r14d,%r12d
cmp    $0x9,%r15d
je     1130 <syntFilter+0x20>
jmp    1217 <syntFilter+0x107>
nopl   (%rax)
movss  (%rax),%xmm1
mulss  (%r8),%xmm1
add    $0x4,%rax
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
lea    0x1(%r14),%r12d
mov    %r10,%rbx
cmp    $0x9,%r15d
je     1130 <syntFilter+0x20>
add    $0xfffffff5,%r12d
xor    %ebp,%ebp
nopl   (%rax)
movss  (%rax),%xmm1
mulss  (%rbx,%rbp,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
movss  0x4(%rax),%xmm1
mulss  -0x4(%rbx,%rbp,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11)
add    $0xfffffffffffffffe,%rbp
add    $0x8,%rax
cmp    %ebp,%r12d
jne    1220 <syntFilter+0x110>
jmp    1130 <syntFilter+0x20>
cmp    $0xb,%edx
jl     1354 <syntFilter+0x244>
mov    %edx,%eax
add    $0xfffffffffffffff6,%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  0x4(%rsi),%xmm1
mulss  0x24(%rdi,%rbx,4),%xmm1
movss  (%r11,%rbx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x8(%rsi),%xmm1
mulss  0x20(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0xc(%rsi),%xmm1
mulss  0x1c(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x10(%rsi),%xmm1
mulss  0x18(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x14(%rsi),%xmm1
mulss  0x14(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x18(%rsi),%xmm1
mulss  0x10(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x1c(%rsi),%xmm1
mulss  0xc(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x20(%rsi),%xmm1
mulss  0x8(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x24(%rsi),%xmm1
mulss  0x4(%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  0x28(%rsi),%xmm1
mulss  (%rdi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r11,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1270 <syntFilter+0x160>
movslq %edx,%rax
lea    (%rdi,%rax,4),%rsi
add    $0xffffffffffffffd8,%rsi
mov    %rcx,%rdi
mov    $0x28,%edx
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <memcpy@plt>

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

LLVM IR (-O2):
define void @syntFilter(float* %0, float* nocapture %1, i32 %2, float* %3) {
%5 = getelementptr inbounds float, float* %3, i64 9
%6 = getelementptr inbounds float, float* %1, i64 1
%7 = getelementptr inbounds float, float* %3, i64 8
br label %21
8: ; preds = %106
%9 = icmp sgt i32 %2, 10
br i1 %9, label %10, label %167
10: ; preds = %8
%11 = zext i32 %2 to i64
%12 = getelementptr inbounds float, float* %1, i64 2
%13 = getelementptr inbounds float, float* %1, i64 3
%14 = getelementptr inbounds float, float* %1, i64 4
%15 = getelementptr inbounds float, float* %1, i64 5
%16 = getelementptr inbounds float, float* %1, i64 6
%17 = getelementptr inbounds float, float* %1, i64 7
%18 = getelementptr inbounds float, float* %1, i64 8
%19 = getelementptr inbounds float, float* %1, i64 9
%20 = getelementptr inbounds float, float* %1, i64 10
br label %109
21: ; preds = %4, %106
%22 = phi i64 [ 0, %4 ], [ %69, %106 ]
%23 = phi float* [ %0, %4 ], [ %107, %106 ]
%24 = trunc i64 %22 to i32
%25 = trunc i64 %22 to i32
%26 = icmp eq i64 %22, 0
br i1 %26, label %67, label %27
27: ; preds = %21
%28 = trunc i64 %22 to i32
%29 = add nsw i64 %22, -1
%30 = getelementptr inbounds float, float* %0, i64 %29
%31 = load float, float* %23
%32 = and i32 %25, 1
%33 = icmp eq i32 %28, 1
br i1 %33, label %55, label %34
34: ; preds = %27
%35 = and i32 %25, -2
br label %36
36: ; preds = %36, %34
%37 = phi float [ %31, %34 ], [ %51, %36 ]
%38 = phi float* [ %6, %34 ], [ %52, %36 ]
%39 = phi float* [ %30, %34 ], [ %48, %36 ]
%40 = phi i32 [ 0, %34 ], [ %53, %36 ]
%41 = load float, float* %38
%42 = getelementptr inbounds float, float* %39, i64 -1
%43 = load float, float* %39
%44 = fneg float %41
%45 = tail call float @llvm.fmuladd.f32(float %44, float %43, float %37)
store float %45, float* %23
%46 = getelementptr inbounds float, float* %38, i64 1
%47 = load float, float* %46
%48 = getelementptr inbounds float, float* %39, i64 -2
%49 = load float, float* %42
%50 = fneg float %47
%51 = tail call float @llvm.fmuladd.f32(float %50, float %49, float %45)
store float %51, float* %23
%52 = getelementptr inbounds float, float* %38, i64 2
%53 = add i32 %40, 2
%54 = icmp eq i32 %53, %35
br i1 %54, label %55, label %36
55: ; preds = %36, %27
%56 = phi float* [ undef, %27 ], [ %52, %36 ]
%57 = phi float [ %31, %27 ], [ %51, %36 ]
%58 = phi float* [ %6, %27 ], [ %52, %36 ]
%59 = phi float* [ %30, %27 ], [ %48, %36 ]
%60 = icmp eq i32 %32, 0
br i1 %60, label %67, label %61
61: ; preds = %55
%62 = load float, float* %58
%63 = load float, float* %59
%64 = fneg float %62
%65 = tail call float @llvm.fmuladd.f32(float %64, float %63, float %57)
store float %65, float* %23
%66 = getelementptr inbounds float, float* %58, i64 1
br label %67
67: ; preds = %61, %55, %21
%68 = phi float* [ %6, %21 ], [ %56, %55 ], [ %66, %61 ]
%69 = add nuw nsw i64 %22, 1
%70 = trunc i64 %69 to i32
%71 = load float, float* %23
%72 = and i64 %22, 1
%73 = icmp eq i64 %72, 0
br i1 %73, label %81, label %74
74: ; preds = %67
%75 = getelementptr inbounds float, float* %68, i64 1
%76 = load float, float* %68
%77 = load float, float* %5
%78 = fneg float %76
%79 = tail call float @llvm.fmuladd.f32(float %78, float %77, float %71)
store float %79, float* %23
%80 = add nuw nsw i32 %70, 1
br label %81
81: ; preds = %74, %67
%82 = phi float [ %71, %67 ], [ %79, %74 ]
%83 = phi float* [ %5, %67 ], [ %7, %74 ]
%84 = phi float* [ %68, %67 ], [ %75, %74 ]
%85 = phi i32 [ %70, %67 ], [ %80, %74 ]
%86 = icmp eq i32 %24, 9
br i1 %86, label %106, label %87
87: ; preds = %81, %87
%88 = phi float [ %103, %87 ], [ %82, %81 ]
%89 = phi float* [ %100, %87 ], [ %83, %81 ]
%90 = phi float* [ %98, %87 ], [ %84, %81 ]
%91 = phi i32 [ %104, %87 ], [ %85, %81 ]
%92 = getelementptr inbounds float, float* %90, i64 1
%93 = load float, float* %90
%94 = getelementptr inbounds float, float* %89, i64 -1
%95 = load float, float* %89
%96 = fneg float %93
%97 = tail call float @llvm.fmuladd.f32(float %96, float %95, float %88)
store float %97, float* %23
%98 = getelementptr inbounds float, float* %90, i64 2
%99 = load float, float* %92
%100 = getelementptr inbounds float, float* %89, i64 -2
%101 = load float, float* %94
%102 = fneg float %99
%103 = tail call float @llvm.fmuladd.f32(float %102, float %101, float %97)
store float %103, float* %23
%104 = add nuw nsw i32 %91, 2
%105 = icmp eq i32 %104, 11
br i1 %105, label %106, label %87
106: ; preds = %87, %81
%107 = getelementptr inbounds float, float* %23, i64 1
%108 = icmp eq i64 %69, 10
br i1 %108, label %8, label %21
109: ; preds = %10, %109
%110 = phi i64 [ 10, %10 ], [ %165, %109 ]
%111 = phi float* [ %107, %10 ], [ %164, %109 ]
%112 = add nsw i64 %110, -1
%113 = getelementptr inbounds float, float* %0, i64 %112
%114 = load float, float* %6
%115 = getelementptr inbounds float, float* %113, i64 -1
%116 = load float, float* %113
%117 = load float, float* %111
%118 = fneg float %114
%119 = tail call float @llvm.fmuladd.f32(float %118, float %116, float %117)
store float %119, float* %111
%120 = load float, float* %12
%121 = getelementptr inbounds float, float* %115, i64 -1
%122 = load float, float* %115
%123 = fneg float %120
%124 = tail call float @llvm.fmuladd.f32(float %123, float %122, float %119)
store float %124, float* %111
%125 = load float, float* %13
%126 = getelementptr inbounds float, float* %121, i64 -1
%127 = load float, float* %121
%128 = fneg float %125
%129 = tail call float @llvm.fmuladd.f32(float %128, float %127, float %124)
store float %129, float* %111
%130 = load float, float* %14
%131 = getelementptr inbounds float, float* %126, i64 -1
%132 = load float, float* %126
%133 = fneg float %130
%134 = tail call float @llvm.fmuladd.f32(float %133, float %132, float %129)
store float %134, float* %111
%135 = load float, float* %15
%136 = getelementptr inbounds float, float* %131, i64 -1
%137 = load float, float* %131
%138 = fneg float %135
%139 = tail call float @llvm.fmuladd.f32(float %138, float %137, float %134)
store float %139, float* %111
%140 = load float, float* %16
%141 = getelementptr inbounds float, float* %136, i64 -1
%142 = load float, float* %136
%143 = fneg float %140
%144 = tail call float @llvm.fmuladd.f32(float %143, float %142, float %139)
store float %144, float* %111
%145 = load float, float* %17
%146 = getelementptr inbounds float, float* %141, i64 -1
%147 = load float, float* %141
%148 = fneg float %145
%149 = tail call float @llvm.fmuladd.f32(float %148, float %147, float %144)
store float %149, float* %111
%150 = load float, float* %18
%151 = getelementptr inbounds float, float* %146, i64 -1
%152 = load float, float* %146
%153 = fneg float %150
%154 = tail call float @llvm.fmuladd.f32(float %153, float %152, float %149)
store float %154, float* %111
%155 = load float, float* %19
%156 = getelementptr inbounds float, float* %151, i64 -1
%157 = load float, float* %151
%158 = fneg float %155
%159 = tail call float @llvm.fmuladd.f32(float %158, float %157, float %154)
store float %159, float* %111
%160 = load float, float* %20
%161 = load float, float* %156
%162 = fneg float %160
%163 = tail call float @llvm.fmuladd.f32(float %162, float %161, float %159)
store float %163, float* %111
%164 = getelementptr inbounds float, float* %111, i64 1
%165 = add nuw nsw i64 %110, 1
%166 = icmp eq i64 %165, %11
br i1 %166, label %167, label %109
167: ; preds = %109, %8
%168 = add nsw i32 %2, -10
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %0, i64 %169
%171 = tail call i32 @memcpy(float* %3, float* %170, i32 40)
ret void
}