void vector_down(double elim_eqn[], int ivar, int idim, double old_vec[],
                 double new_vec[]) {
  int i;
  double fac, ve, ee;
  ve = 0.0;
  ee = 0.0;
  for (i = 0; i <= idim; i++) {
    ve += old_vec[i] * elim_eqn[i];
    ee += elim_eqn[i] * elim_eqn[i];
  }
  fac = ve / ee;
  for (i = 0; i < ivar; i++) {
    new_vec[i] = old_vec[i] - elim_eqn[i] * fac;
  }
  for (i = ivar + 1; i <= idim; i++) {
    new_vec[i - 1] = old_vec[i] - elim_eqn[i] * fac;
  }
}


x86 assembly (clang, -O0):
<vector_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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     119f <vector_down+0x9f>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <vector_down+0x2d>
movsd  -0x38(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    121a <vector_down+0x11a>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%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 -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b5 <vector_down+0xb5>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     128d <vector_down+0x18d>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%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    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1223 <vector_down+0x123>
pop    %rbp
ret

x86 assembly (clang, -O2):
<vector_down>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %edx,%edx
js     11a8 <vector_down+0xa8>
lea    0x1(%rdx),%r9d
test   %edx,%edx
je     14da <vector_down+0x3da>
mov    %r9d,%ebx
and    $0xfffffffe,%ebx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm2
movsd  0x8(%rdi,%rax,8),%xmm1
movapd %xmm2,%xmm3
movhpd (%rcx,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm1,%xmm0
movhpd 0x8(%rcx,%rax,8),%xmm0
unpcklpd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm2,%xmm1
add    $0x2,%rax
movapd %xmm1,%xmm0
cmp    %rax,%rbx
jne    1130 <vector_down+0x30>
test   $0x1,%r9b
je     1193 <vector_down+0x93>
movsd  (%rdi,%rax,8),%xmm0
movapd %xmm0,%xmm2
movhpd (%rcx,%rax,8),%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
divsd  %xmm1,%xmm0
test   %esi,%esi
jg     11b8 <vector_down+0xb8>
jmp    1371 <vector_down+0x271>
movsd  0xe50(%rip),%xmm0
test   %esi,%esi
jle    1371 <vector_down+0x271>
mov    %esi,%r9d
cmp    $0x4,%esi
jae    1241 <vector_down+0x141>
xor    %eax,%eax
mov    %rax,%rbx
not    %rbx
test   $0x1,%r9b
je     11ee <vector_down+0xee>
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    %r9,%rbx
je     1371 <vector_down+0x271>
nopw   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,%r9
jne    1200 <vector_down+0x100>
jmp    1371 <vector_down+0x271>
lea    (%r8,%r9,8),%rax
lea    (%rcx,%r9,8),%rbx
cmp    %r8,%rbx
seta   %r11b
lea    (%rdi,%r9,8),%rbx
cmp    %rcx,%rax
seta   %bpl
cmp    %r8,%rbx
seta   %bl
cmp    %rdi,%rax
seta   %r10b
xor    %eax,%eax
test   %bpl,%r11b
jne    11c6 <vector_down+0xc6>
and    %r10b,%bl
jne    11c6 <vector_down+0xc6>
mov    %r9d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rbp
mov    %rbp,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rbp,%rbp
je     14ef <vector_down+0x3ef>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %r10d,%r10d
nopl   0x0(%rax)
movupd (%rcx,%r10,8),%xmm2
movupd 0x10(%rcx,%r10,8),%xmm3
movupd (%rdi,%r10,8),%xmm4
movupd 0x10(%rdi,%r10,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%r10,8)
movupd %xmm3,0x10(%r8,%r10,8)
movupd 0x20(%rcx,%r10,8),%xmm2
movupd 0x30(%rcx,%r10,8),%xmm3
movupd 0x20(%rdi,%r10,8),%xmm4
movupd 0x30(%rdi,%r10,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,0x20(%r8,%r10,8)
movupd %xmm3,0x30(%r8,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%rbx
jne    12b0 <vector_down+0x1b0>
test   $0x1,%r11b
je     1368 <vector_down+0x268>
movupd (%rcx,%r10,8),%xmm2
movupd 0x10(%rcx,%r10,8),%xmm3
movupd (%rdi,%r10,8),%xmm4
movupd 0x10(%rdi,%r10,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%r10,8)
movupd %xmm3,0x10(%r8,%r10,8)
cmp    %r9,%rax
jne    11c6 <vector_down+0xc6>
cmp    %edx,%esi
jge    14d1 <vector_down+0x3d1>
movslq %esi,%r10
movslq %edx,%r11
mov    %r11,%r9
sub    %r10,%r9
cmp    $0x4,%r9
jb     1455 <vector_down+0x355>
lea    (%r8,%r10,8),%rax
lea    (%r8,%r11,8),%rsi
lea    (%rcx,%r10,8),%r15
add    $0x8,%r15
lea    (%rcx,%r11,8),%rbp
add    $0x8,%rbp
lea    (%rdi,%r10,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    1455 <vector_down+0x355>
and    %bl,%al
jne    1455 <vector_down+0x355>
mov    %r9,%r14
and    $0xfffffffffffffffc,%r14
lea    (%r14,%r10,1),%rsi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%rdi,%r10,8),%r15
add    $0x18,%r15
lea    (%rcx,%r10,8),%r12
add    $0x18,%r12
lea    (%r8,%r10,8),%rax
add    $0x10,%rax
xor    %ebx,%ebx
nopw   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    1410 <vector_down+0x310>
cmp    %r14,%r9
jne    1458 <vector_down+0x358>
jmp    14d1 <vector_down+0x3d1>
mov    %r10,%rsi
sub    %esi,%edx
mov    %rsi,%rax
not    %rax
test   $0x1,%dl
je     1483 <vector_down+0x383>
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     14d1 <vector_down+0x3d1>
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    1490 <vector_down+0x390>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xorpd  %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%r9b
jne    1179 <vector_down+0x79>
jmp    1193 <vector_down+0x93>
xor    %r10d,%r10d
test   $0x1,%r11b
jne    1331 <vector_down+0x231>
jmp    1368 <vector_down+0x268>

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

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