double *lu_solve(double **lum, int n, double *vb, double *vx) {
  int i, j, k;
  double x;
  vx[1 - 1] = vb[1 - 1];
  for (i = 2; i <= n; i++) {
    vx[i - 1] = vb[i - 1];
    for (j = 1; j < i; j++)
      vx[i - 1] -= lum[i - 1][j - 1] * vx[j - 1];
  }
  vx[n - 1] /= lum[n - 1][n - 1];
  for (i = n - 1; i >= 1; i--) {
    x = vx[i - 1];
    for (j = i + 1; j <= n; j++)
      x -= lum[i - 1][j - 1] * vx[j - 1];
    x /= lum[i - 1][i - 1];
    vx[i - 1] = x;
  }
  return vx;
}


x86 assembly (clang, -O0):
<lu_solve>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11f5 <lu_solve+0xf5>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11e2 <lu_solve+0xe2>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%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    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1161 <lu_solve+0x61>
jmp    11e7 <lu_solve+0xe7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112a <lu_solve+0x2a>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jl     1328 <lu_solve+0x228>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12d6 <lu_solve+0x1d6>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1262 <lu_solve+0x162>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%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    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1238 <lu_solve+0x138>
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu_solve>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rcx,%rax
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rcx)
cmp    $0x2,%esi
jge    1257 <lu_solve+0x157>
movslq %esi,%rcx
mov    -0x8(%rdi,%rcx,8),%rdx
movsd  -0x8(%rax,%rcx,8),%xmm0
divsd  -0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
cmp    $0x2,%esi
jl     124f <lu_solve+0x14f>
mov    %esi,%r15d
add    $0xffffffff,%esi
lea    -0x1(%r15),%r9
mov    %esi,%r8d
lea    (%rax,%r15,8),%r12
add    $0xfffffffffffffff8,%r12
mov    $0x1,%r10d
sub    %r15,%r10
mov    $0x1,%sil
xor    %r11d,%r11d
jmp    119d <lu_solve+0x9d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
divsd  (%rcx,%r14,8),%xmm0
movsd  %xmm0,(%rax,%r14,8)
lea    -0x1(%r8),%rcx
add    $0x1,%r11
add    $0xfffffffffffffff8,%r12
add    $0x1,%r10
add    $0x1,%sil
cmp    $0x1,%r8
mov    %rcx,%r8
jle    124f <lu_solve+0x14f>
mov    %r9,%rbx
add    $0xffffffffffffffff,%r9
movzbl %sil,%esi
and    $0x3,%esi
mov    %r9d,%r14d
movsd  (%rax,%r14,8),%xmm0
mov    (%rdi,%r14,8),%rcx
cmp    %r15,%r8
jge    1170 <lu_solve+0x70>
lea    0x1(%r11),%edx
test   $0x3,%dl
je     11eb <lu_solve+0xeb>
lea    (%rcx,%rbx,8),%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdx,%rbx,8),%xmm1
mulsd  (%r12,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    11d0 <lu_solve+0xd0>
sub    %r10,%rbx
cmp    $0x3,%r11
jb     1170 <lu_solve+0x70>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rbx,8),%xmm1
movsd  0x8(%rcx,%rbx,8),%xmm2
mulsd  (%rax,%rbx,8),%xmm1
mulsd  0x8(%rax,%rbx,8),%xmm2
subsd  %xmm1,%xmm0
movsd  0x10(%rcx,%rbx,8),%xmm1
mulsd  0x10(%rax,%rbx,8),%xmm1
subsd  %xmm2,%xmm0
movsd  0x18(%rcx,%rbx,8),%xmm2
mulsd  0x18(%rax,%rbx,8),%xmm2
subsd  %xmm1,%xmm0
lea    0x4(%rbx),%rdx
subsd  %xmm2,%xmm0
mov    %rdx,%rbx
cmp    %rdx,%r15
jne    1200 <lu_solve+0x100>
jmp    1170 <lu_solve+0x70>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
lea    0x1(%rsi),%r8d
mov    $0x2,%r11d
mov    $0x1,%r10d
xor    %r9d,%r9d
jmp    1281 <lu_solve+0x181>
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x1,%r10
cmp    %r8,%r11
je     111b <lu_solve+0x1b>
mov    %r9,%rbx
add    $0x1,%r9
movsd  -0x8(%rdx,%r11,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r11,8)
mov    -0x8(%rdi,%r11,8),%r15
test   %rbx,%rbx
je     1300 <lu_solve+0x200>
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
neg    %r14
mov    $0x1,%ebx
nop
movsd  -0x8(%r15,%rbx,8),%xmm1
mulsd  -0x8(%rax,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%r11,8)
movsd  (%r15,%rbx,8),%xmm1
mulsd  (%rax,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%r11,8)
lea    (%r14,%rbx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rbx
cmp    $0x1,%rcx
jne    12b0 <lu_solve+0x1b0>
test   $0x1,%r9b
je     1270 <lu_solve+0x170>
jmp    130f <lu_solve+0x20f>
nopl   0x0(%rax)
mov    $0x1,%ebx
test   $0x1,%r9b
je     1270 <lu_solve+0x170>
movsd  -0x8(%r15,%rbx,8),%xmm1
mulsd  -0x8(%rax,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rax,%r11,8)
jmp    1270 <lu_solve+0x170>

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

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