void gaussianElimination(int n, double *matrix, double b[]) {
  int j, i, k;
  double aux;
  for (j = 0; j < (n - 1); j++) {
#pragma omp parallel for private(aux, i, k) schedule(static)
    for (i = (j + 1); i < n; i++) {
      aux = *(matrix + n * i + j) / *(matrix + n * j + j);
      for (k = j; k < n; k++) {
        *(matrix + n * i + k) -= (aux * (*(matrix + n * j + k)));
      }
      b[i] -= (aux * b[j]);
    }
  }
}


x86 assembly (clang, -O0):
<gaussianElimination>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1266 <gaussianElimination+0x166>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1253 <gaussianElimination+0x153>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1202 <gaussianElimination+0x102>
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1183 <gaussianElimination+0x83>
movsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1130 <gaussianElimination+0x30>
jmp    1258 <gaussianElimination+0x158>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1116 <gaussianElimination+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussianElimination>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
cmp    $0x2,%edi
jl     150c <gaussianElimination+0x40c>
mov    %rdx,%r14
mov    %rdi,%rax
mov    %eax,%r10d
add    $0xffffffff,%eax
mov    %rax,-0x28(%rsp)
lea    0x1(%r10),%rax
mov    %rax,0x10(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,-0x40(%rsp)
lea    0x8(,%r10,8),%rax
mov    %rax,-0x50(%rsp)
lea    (%r10,%r10,1),%rax
mov    %rax,-0x30(%rsp)
lea    0x8(%rsi),%r11
mov    %r10,%rax
neg    %rax
mov    %rax,0x38(%rsp)
lea    (%rsi,%r10,8),%rax
add    $0x38,%rax
mov    %rax,-0x58(%rsp)
lea    0x38(%rsi),%rbx
lea    -0x5(%r10),%rax
mov    %rax,-0x60(%rsp)
lea    (%rsi,%r10,8),%rax
mov    %rax,-0x68(%rsp)
mov    $0x1,%eax
mov    %rax,-0x70(%rsp)
xor    %eax,%eax
movapd 0xe66(%rip),%xmm0
mov    %r11,-0x38(%rsp)
jmp    11e6 <gaussianElimination+0xe6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,-0x70(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,-0x58(%rsp)
add    %rax,%rbx
addq   $0xffffffffffffffff,-0x60(%rsp)
mov    -0x40(%rsp),%rax
add    %rax,-0x68(%rsp)
add    %rax,%r11
mov    -0x18(%rsp),%rax
cmp    -0x28(%rsp),%rax
je     150c <gaussianElimination+0x40c>
mov    %rax,%rdi
add    $0x1,%rax
mov    %rax,-0x18(%rsp)
cmp    %r10,%rax
jae    11b0 <gaussianElimination+0xb0>
mov    -0x60(%rsp),%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x20(%rsp)
mov    %rdi,%rdx
not    %rdx
lea    (%rdx,%r10,1),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,(%rsp)
add    %r10,%rdx
mov    -0x50(%rsp),%rbp
imul   %rdi,%rbp
mov    %rdi,%rcx
imul   %r10,%rcx
mov    -0x30(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x28(%rsp)
mov    -0x38(%rsp),%rax
mov    %rbp,0x30(%rsp)
lea    (%rax,%rbp,1),%rax
mov    %rax,0x20(%rsp)
lea    (%rcx,%r10,1),%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,0x18(%rsp)
lea    (%rsi,%rcx,8),%rax
mov    %rax,-0x78(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,-0x80(%rsp)
mov    %rdx,-0x48(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x8(%rsp)
lea    (%rdi,%rdx,1),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rsp)
mov    -0x68(%rsp),%r13
mov    -0x58(%rsp),%r12
xor    %ebp,%ebp
mov    -0x70(%rsp),%r15
mov    %rdi,0x40(%rsp)
jmp    12f3 <gaussianElimination+0x1f3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdi
mulsd  (%r14,%rdi,8),%xmm1
addsd  (%r14,%r15,8),%xmm1
movsd  %xmm1,(%r14,%r15,8)
add    $0x1,%r15
add    $0x1,%rbp
mov    -0x40(%rsp),%rax
add    %rax,%r12
add    %rax,%r13
cmp    %r10,%r15
je     11b0 <gaussianElimination+0xb0>
mov    %r15,%rcx
imul   %r10,%rcx
lea    (%rsi,%rcx,8),%rdx
movsd  (%rdx,%rdi,8),%xmm2
mov    -0x78(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm3
movapd %xmm2,%xmm1
xorpd  %xmm0,%xmm1
divsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rdx,%rdi,8)
cmp    %r10,-0x80(%rsp)
je     12c0 <gaussianElimination+0x1c0>
mov    -0x80(%rsp),%r9
cmpq   $0x4,-0x48(%rsp)
jae    13c0 <gaussianElimination+0x2c0>
mov    %r10d,%eax
sub    %r9d,%eax
mov    %r9,%rcx
test   $0x1,%al
je     136a <gaussianElimination+0x26a>
mov    -0x78(%rsp),%rax
movsd  (%rax,%r9,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%r9,8),%xmm2
movsd  %xmm2,(%rdx,%r9,8)
lea    0x1(%r9),%rcx
not    %r9
cmp    0x38(%rsp),%r9
je     12c0 <gaussianElimination+0x1c0>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r11,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rcx,8)
movsd  (%r11,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r13,%rcx,8),%xmm2
movsd  %xmm2,0x8(%r13,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1380 <gaussianElimination+0x280>
jmp    12c0 <gaussianElimination+0x1c0>
nop
mov    %rbp,%rcx
imul   %r10,%rcx
mov    0x10(%rsp),%rax
add    %rcx,%rax
lea    (%rsi,%rax,8),%rax
add    0x30(%rsp),%rax
add    0x28(%rsp),%rcx
lea    (%rsi,%rcx,8),%r8
cmp    0x18(%rsp),%rax
setb   %dil
cmp    %r8,0x20(%rsp)
setb   %cl
mov    -0x80(%rsp),%r9
test   %cl,%dil
jne    133e <gaussianElimination+0x23e>
mov    -0x80(%rsp),%r9
cmp    %r8,%rax
jb     133e <gaussianElimination+0x23e>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x4,0x8(%rsp)
jae    1426 <gaussianElimination+0x326>
xor    %r8d,%r8d
jmp    14ab <gaussianElimination+0x3ab>
mov    -0x20(%rsp),%r9
xor    %r8d,%r8d
xchg   %ax,%ax
movupd -0x30(%rbx,%r8,8),%xmm3
movupd -0x20(%rbx,%r8,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%r12,%r8,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%r12,%r8,8),%xmm3
movupd -0x10(%r12,%r8,8),%xmm6
movupd (%r12,%r8,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%r12,%r8,8)
movupd %xmm4,-0x20(%r12,%r8,8)
movupd -0x10(%rbx,%r8,8),%xmm3
movupd (%rbx,%r8,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%r12,%r8,8)
movupd %xmm4,(%r12,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r9
jne    1430 <gaussianElimination+0x330>
testb  $0x1,(%rsp)
je     14f2 <gaussianElimination+0x3f2>
add    -0x80(%rsp),%r8
mov    -0x78(%rsp),%rax
movupd (%rax,%r8,8),%xmm3
movupd 0x10(%rax,%r8,8),%xmm4
movupd (%rdx,%r8,8),%xmm5
movupd 0x10(%rdx,%r8,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rdx,%r8,8)
movupd %xmm4,0x10(%rdx,%r8,8)
mov    -0x10(%rsp),%r9
mov    -0x8(%rsp),%rax
cmp    %rax,-0x48(%rsp)
je     12c0 <gaussianElimination+0x1c0>
jmp    133e <gaussianElimination+0x23e>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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