void plane_down(double elim_eqn[], int ivar, int idim, double old_plane[],
                double new_plane[]) {
  register double crit;
  register int i;
  crit = old_plane[ivar] / elim_eqn[ivar];
  for (i = 0; i < ivar; i++) {
    new_plane[i] = old_plane[i] - elim_eqn[i] * crit;
  }
  for (i = ivar + 1; i <= idim; i++) {
    new_plane[i - 1] = old_plane[i] - elim_eqn[i] * crit;
  }
}


x86 assembly (clang, -O0):
<plane_down>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11a1 <plane_down+0xa1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    113c <plane_down+0x3c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1214 <plane_down+0x114>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11aa <plane_down+0xaa>
pop    %rbp
ret

x86 assembly (clang, -O2):
<plane_down>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
movslq %esi,%r9
movsd  (%rcx,%r9,8),%xmm0
divsd  (%rdi,%r9,8),%xmm0
test   %r9d,%r9d
jle    12d1 <plane_down+0x1d1>
mov    %esi,%r10d
cmp    $0x4,%esi
jae    11a1 <plane_down+0xa1>
xor    %eax,%eax
mov    %rax,%rbx
not    %rbx
test   $0x1,%r10b
je     1152 <plane_down+0x52>
movsd  (%rcx,%rax,8),%xmm1
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rax,8)
or     $0x1,%rax
add    %r10,%rbx
je     12d1 <plane_down+0x1d1>
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
movsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm1
movsd  0x8(%rdi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1160 <plane_down+0x60>
jmp    12d1 <plane_down+0x1d1>
lea    (%r8,%r10,8),%rax
lea    (%rcx,%r10,8),%rbx
cmp    %r8,%rbx
seta   %bpl
lea    (%rdi,%r10,8),%rbx
cmp    %rcx,%rax
seta   %r14b
cmp    %r8,%rbx
seta   %bl
cmp    %rdi,%rax
seta   %r11b
xor    %eax,%eax
test   %r14b,%bpl
jne    112a <plane_down+0x2a>
and    %r11b,%bl
jne    112a <plane_down+0x2a>
mov    %r10d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rbp
mov    %rbp,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rbp,%rbp
je     143a <plane_down+0x33a>
mov    %r14,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %r11d,%r11d
nopl   0x0(%rax)
movupd (%rcx,%r11,8),%xmm2
movupd 0x10(%rcx,%r11,8),%xmm3
movupd (%rdi,%r11,8),%xmm4
movupd 0x10(%rdi,%r11,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%r11,8)
movupd %xmm3,0x10(%r8,%r11,8)
movupd 0x20(%rcx,%r11,8),%xmm2
movupd 0x30(%rcx,%r11,8),%xmm3
movupd 0x20(%rdi,%r11,8),%xmm4
movupd 0x30(%rdi,%r11,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,0x20(%r8,%r11,8)
movupd %xmm3,0x30(%r8,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rbx
jne    1210 <plane_down+0x110>
test   $0x1,%r14b
je     12c8 <plane_down+0x1c8>
movupd (%rcx,%r11,8),%xmm2
movupd 0x10(%rcx,%r11,8),%xmm3
movupd (%rdi,%r11,8),%xmm4
movupd 0x10(%rdi,%r11,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%r11,8)
movupd %xmm3,0x10(%r8,%r11,8)
cmp    %r10,%rax
jne    112a <plane_down+0x2a>
cmp    %edx,%esi
jge    1431 <plane_down+0x331>
movslq %edx,%r11
mov    %r11,%r10
sub    %r9,%r10
cmp    $0x4,%r10
jb     13b5 <plane_down+0x2b5>
lea    (%r8,%r9,8),%rax
lea    (%r8,%r11,8),%rsi
lea    (%rcx,%r9,8),%r15
add    $0x8,%r15
lea    (%rcx,%r11,8),%rbp
add    $0x8,%rbp
lea    (%rdi,%r9,8),%r14
add    $0x8,%r14
lea    (%rdi,%r11,8),%rbx
add    $0x8,%rbx
cmp    %rbp,%rax
setb   %bpl
cmp    %rsi,%r15
setb   %r15b
cmp    %rbx,%rax
setb   %al
cmp    %rsi,%r14
setb   %bl
test   %r15b,%bpl
jne    13b5 <plane_down+0x2b5>
and    %bl,%al
jne    13b5 <plane_down+0x2b5>
mov    %r10,%r14
and    $0xfffffffffffffffc,%r14
lea    (%r14,%r9,1),%rsi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%rdi,%r9,8),%r15
add    $0x18,%r15
lea    (%rcx,%r9,8),%r12
add    $0x18,%r12
lea    (%r8,%r9,8),%rax
add    $0x10,%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r12,%rbx,8),%xmm2
movupd (%r12,%rbx,8),%xmm3
movupd -0x10(%r15,%rbx,8),%xmm4
movupd (%r15,%rbx,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rax,%rbx,8)
movupd %xmm3,(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r14
jne    1370 <plane_down+0x270>
cmp    %r14,%r10
jne    13b8 <plane_down+0x2b8>
jmp    1431 <plane_down+0x331>
mov    %r9,%rsi
sub    %esi,%edx
mov    %rsi,%rax
not    %rax
test   $0x1,%dl
je     13e3 <plane_down+0x2e3>
movsd  0x8(%rcx,%rsi,8),%xmm1
movsd  0x8(%rdi,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rsi,8)
add    $0x1,%rsi
add    %r11,%rax
je     1431 <plane_down+0x331>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rcx,%rsi,8),%xmm1
movsd  0x8(%rdi,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rsi,8)
movsd  0x10(%rcx,%rsi,8),%xmm1
movsd  0x10(%rdi,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r8,%rsi,8)
lea    0x2(%rsi),%rax
mov    %rax,%rsi
cmp    %rax,%r11
jne    13f0 <plane_down+0x2f0>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r11d,%r11d
test   $0x1,%r14b
jne    1291 <plane_down+0x191>
jmp    12c8 <plane_down+0x1c8>

LLVM IR (-O0):
define void @plane_down(double* %0, i32 %1, i32 %2, double* %3, double* %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca double
%12 = alloca i32
store double* %0, double** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store double* %3, double** %9
store double* %4, double** %10
%13 = load double*, double** %9
%14 = load i32, i32* %7
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds double, double* %13, i64 %15
%17 = load double, double* %16
%18 = load double*, double** %6
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds double, double* %18, i64 %20
%22 = load double, double* %21
%23 = fdiv double %17, %22
store double %23, double* %11
store i32 0, i32* %12
br label %24
24: ; preds = %46, %5
%25 = load i32, i32* %12
%26 = load i32, i32* %7
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %49
28: ; preds = %24
%29 = load double*, double** %9
%30 = load i32, i32* %12
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = load double*, double** %6
%35 = load i32, i32* %12
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = load double, double* %11
%40 = fneg double %38
%41 = call double @llvm.fmuladd.f64(double %40, double %39, double %33)
%42 = load double*, double** %10
%43 = load i32, i32* %12
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %42, i64 %44
store double %41, double* %45
br label %46
46: ; preds = %28
%47 = load i32, i32* %12
%48 = add nsw i32 %47, 1
store i32 %48, i32* %12
br label %24
49: ; preds = %24
%50 = load i32, i32* %7
%51 = add nsw i32 %50, 1
store i32 %51, i32* %12
br label %52
52: ; preds = %75, %49
%53 = load i32, i32* %12
%54 = load i32, i32* %8
%55 = icmp sle i32 %53, %54
br i1 %55, label %56, label %78
56: ; preds = %52
%57 = load double*, double** %9
%58 = load i32, i32* %12
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load double*, double** %6
%63 = load i32, i32* %12
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
%66 = load double, double* %65
%67 = load double, double* %11
%68 = fneg double %66
%69 = call double @llvm.fmuladd.f64(double %68, double %67, double %61)
%70 = load double*, double** %10
%71 = load i32, i32* %12
%72 = sub nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %70, i64 %73
store double %69, double* %74
br label %75
75: ; preds = %56
%76 = load i32, i32* %12
%77 = add nsw i32 %76, 1
store i32 %77, i32* %12
br label %52
78: ; preds = %52
ret void
}

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