void vm(float **a, float *b, float *s, int n) {
  int t4;
  int t2;
  int i;
  int j;
  for (t2 = 1; t2 <= n - 2; t2 += 1)
    if (t2 <= 1) {
      s[2] = 0.0f;
      b[2] = (b[2] - s[2]);
      for (t4 = 3; t4 <= n - 1; t4 += 1) {
        s[t4] = 0.0f;
        s[t4] = (s[t4] + (b[t2] * a[t2][t4]));
      }
    } else {
      b[t2 + 1] = (b[t2 + 1] - s[t2 + 1]);
      for (t4 = t2 + 2; t4 <= n - 1; t4 += 1)
        s[t4] = (s[t4] + (b[t2] * a[t2][t4]));
    }
}


x86 assembly (clang, -O0):
<vm>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1295 <vm+0x195>
cmpl   $0x1,-0x24(%rbp)
jg     11db <vm+0xdb>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movl   $0x3,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     11d6 <vm+0xd6>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1163 <vm+0x63>
jmp    1282 <vm+0x182>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     127d <vm+0x17d>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    121a <vm+0x11a>
jmp    1282 <vm+0x182>
jmp    1287 <vm+0x187>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111a <vm+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<vm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,-0x38(%rsp)
mov    %rcx,-0x50(%rsp)
cmp    $0x3,%ecx
jge    1124 <vm+0x24>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x50(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    %rax,-0x8(%rsp)
mov    %ecx,%r15d
lea    0xc(%rdx),%rax
mov    %rax,-0x10(%rsp)
lea    (%rdx,%r15,4),%rax
mov    %rax,-0x48(%rsp)
lea    -0x3(%r15),%rax
mov    %r15,%rdi
neg    %rdi
mov    %rdi,-0x40(%rsp)
mov    %rax,%rdi
and    $0xfffffffffffffff8,%rdi
mov    %rdi,-0x18(%rsp)
add    $0x3,%rdi
mov    %rdi,-0x20(%rsp)
lea    0x1c(%rdx),%r10
mov    $0x3,%r11d
mov    $0x1,%ebp
mov    $0x7,%edi
mov    %rdi,-0x28(%rsp)
xor    %r9d,%r9d
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
mov    %r10,%rbx
mov    %rax,-0x58(%rsp)
mov    %rax,-0x30(%rsp)
jmp    11c7 <vm+0xc7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%r11
add    $0x1,%r9
addq   $0xffffffffffffffff,-0x30(%rsp)
add    $0x4,%rbx
addq   $0x1,-0x28(%rsp)
cmp    -0x8(%rsp),%rbp
je     1119 <vm+0x19>
lea    (%rsi,%rbp,4),%rcx
lea    (%rsi,%r9,4),%r12
add    $0x8,%r12
cmp    $0x1,%rbp
ja     1290 <vm+0x190>
movl   $0x0,0x8(%rdx)
cmpl   $0x3,-0x50(%rsp)
je     11a0 <vm+0xa0>
mov    -0x38(%rsp),%rdi
mov    (%rdi,%rbp,8),%rdi
mov    $0x3,%r8d
cmpq   $0x8,-0x58(%rsp)
jae    134b <vm+0x24b>
mov    %r8,%rax
test   $0x1,%r15b
jne    1230 <vm+0x130>
movl   $0x0,(%rdx,%r8,4)
movss  (%rsi,%rbp,4),%xmm2
mulss  (%rdi,%r8,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rdx,%r8,4)
lea    0x1(%r8),%rax
not    %r8
cmp    -0x40(%rsp),%r8
je     11a0 <vm+0xa0>
xchg   %ax,%ax
movl   $0x0,(%rdx,%rax,4)
movss  (%rsi,%rbp,4),%xmm2
mulss  (%rdi,%rax,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rdx,%rax,4)
movl   $0x0,0x4(%rdx,%rax,4)
movss  (%rsi,%rbp,4),%xmm2
mulss  0x4(%rdi,%rax,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1240 <vm+0x140>
jmp    11a0 <vm+0xa0>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x4(%rsi,%rbp,4),%xmm2
subss  0x4(%rdx,%rbp,4),%xmm2
movss  %xmm2,0x4(%rsi,%rbp,4)
lea    0x2(%rbp),%edi
cmp    -0x50(%rsp),%edi
jge    11a0 <vm+0xa0>
mov    -0x58(%rsp),%rax
sub    %r9,%rax
mov    -0x38(%rsp),%rdi
mov    (%rdi,%rbp,8),%r14
mov    %r11,%r13
mov    %rax,-0x60(%rsp)
cmp    $0x8,%rax
jae    13fa <vm+0x2fa>
mov    %r15d,%eax
sub    %r13d,%eax
mov    %r13,%rdi
test   $0x1,%al
je     12fa <vm+0x1fa>
movss  (%rsi,%rbp,4),%xmm2
mulss  (%r14,%r13,4),%xmm2
addss  (%rdx,%r13,4),%xmm2
movss  %xmm2,(%rdx,%r13,4)
lea    0x1(%r13),%rdi
not    %r13
cmp    -0x40(%rsp),%r13
je     11a0 <vm+0xa0>
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbp,4),%xmm2
mulss  (%r14,%rdi,4),%xmm2
addss  (%rdx,%rdi,4),%xmm2
movss  %xmm2,(%rdx,%rdi,4)
movss  (%rsi,%rbp,4),%xmm2
mulss  0x4(%r14,%rdi,4),%xmm2
addss  0x4(%rdx,%rdi,4),%xmm2
movss  %xmm2,0x4(%rdx,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    1310 <vm+0x210>
jmp    11a0 <vm+0xa0>
lea    0xc(%rdi),%rax
mov    %rax,-0x60(%rsp)
lea    (%rdi,%r15,4),%r14
mov    -0x10(%rsp),%r13
cmp    %r12,%r13
setb   -0x61(%rsp)
mov    -0x48(%rsp),%rax
cmp    %rax,%rcx
setb   %r12b
cmp    %r14,%r13
setb   %r13b
cmp    %rax,-0x60(%rsp)
setb   %r14b
test   %r12b,-0x61(%rsp)
jne    1206 <vm+0x106>
and    %r14b,%r13b
jne    1206 <vm+0x106>
movss  (%rsi,%rbp,4),%xmm2
shufps $0x0,%xmm2,%xmm2
xor    %eax,%eax
mov    -0x18(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm1,-0x10(%r10,%rax,4)
movups %xmm1,(%r10,%rax,4)
movups 0xc(%rdi,%rax,4),%xmm3
movups 0x1c(%rdi,%rax,4),%xmm4
mulps  %xmm2,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm1,%xmm4
movups %xmm3,-0x10(%r10,%rax,4)
movups %xmm4,(%r10,%rax,4)
add    $0x8,%rax
cmp    %rax,%r14
jne    13b0 <vm+0x2b0>
mov    -0x20(%rsp),%r8
cmp    %r14,-0x58(%rsp)
je     11a0 <vm+0xa0>
jmp    1206 <vm+0x106>
lea    (%rdx,%r11,4),%rdi
lea    (%r14,%r11,4),%r13
lea    (%r14,%r15,4),%r8
cmp    %r12,%rdi
setb   -0x61(%rsp)
mov    -0x48(%rsp),%rax
cmp    %rax,%rcx
setb   %r12b
cmp    %r8,%rdi
setb   %dil
cmp    %rax,%r13
setb   %r8b
mov    %r11,%r13
test   %r12b,-0x61(%rsp)
jne    12d2 <vm+0x1d2>
mov    %r11,%r13
and    %r8b,%dil
jne    12d2 <vm+0x1d2>
mov    -0x30(%rsp),%rax
and    $0xfffffffffffffff8,%rax
mov    -0x60(%rsp),%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%r11,%rcx,1),%r13
movss  (%rsi,%rbp,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mov    -0x28(%rsp),%rdi
lea    (%r14,%rdi,4),%r12
xor    %r8d,%r8d
nopl   (%rax)
movups -0x10(%rbx,%r8,4),%xmm3
movups (%rbx,%r8,4),%xmm4
movups -0x10(%r12,%r8,4),%xmm5
movups (%r12,%r8,4),%xmm6
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm2,%xmm6
addps  %xmm4,%xmm6
movups %xmm5,-0x10(%rbx,%r8,4)
movups %xmm6,(%rbx,%r8,4)
add    $0x8,%r8
cmp    %r8,%rax
jne    1470 <vm+0x370>
cmp    %rcx,-0x60(%rsp)
je     11a0 <vm+0xa0>
jmp    12d2 <vm+0x1d2>

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

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