void PSB_update(double **B, double *f, double *d, int n) {
  int i, j;
  double dtd = 0.0, ftd = 0.0, dtd2 = 0.0;
  for (i = 1; i <= n; i++)
    dtd += d[i] * d[i];
  dtd2 = dtd * dtd;
  for (i = 1; i <= n; i++)
    ftd += f[i] * d[i];
  for (i = 1; i <= n; i++)
    for (j = i; j <= n; j++)
      B[i][j] -= ((f[i] * d[j] + f[j] * d[i]) / dtd - ftd * d[i] * d[j] / dtd2);
}


x86 assembly (clang, -O0):
<PSB_update>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1178 <PSB_update+0x78>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1132 <PSB_update+0x32>
movsd  -0x30(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11d4 <PSB_update+0xd4>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118e <PSB_update+0x8e>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12a1 <PSB_update+0x1a1>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     128e <PSB_update+0x18e>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
divsd  -0x30(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
subsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ed <PSB_update+0xed>
jmp    1293 <PSB_update+0x193>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11db <PSB_update+0xdb>
pop    %rbp
ret

x86 assembly (clang, -O2):
<PSB_update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,-0x8(%rsp)
mov    %rcx,-0x30(%rsp)
test   %ecx,%ecx
jle    1471 <PSB_update+0x371>
mov    -0x30(%rsp),%r12d
lea    -0x1(%r12),%rax
mov    %r12d,%ebp
and    $0x3,%ebp
cmp    $0x3,%rax
jae    1142 <PSB_update+0x42>
xorpd  %xmm0,%xmm0
mov    $0x1,%ebx
test   %rbp,%rbp
jne    119a <PSB_update+0x9a>
jmp    11b6 <PSB_update+0xb6>
mov    %r12d,%edi
and    $0xfffffffc,%edi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xchg   %ax,%ax
movsd  0x8(%rdx,%rbx,8),%xmm1
movsd  0x10(%rdx,%rbx,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rbx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x20(%rdx,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    1150 <PSB_update+0x50>
add    $0x1,%rbx
test   %rbp,%rbp
je     11b6 <PSB_update+0xb6>
lea    (%rdx,%rbx,8),%rcx
xor    %edi,%edi
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    11a0 <PSB_update+0xa0>
cmpl   $0x0,-0x30(%rsp)
jle    1471 <PSB_update+0x371>
mov    %r12d,%ebp
and    $0x3,%ebp
cmp    $0x3,%rax
jae    11e0 <PSB_update+0xe0>
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
test   %rbp,%rbp
jne    1242 <PSB_update+0x142>
jmp    1267 <PSB_update+0x167>
mov    %r12d,%edi
and    $0xfffffffc,%edi
xorpd  %xmm1,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movsd  0x8(%rsi,%rax,8),%xmm2
movsd  0x10(%rsi,%rax,8),%xmm3
mulsd  0x8(%rdx,%rax,8),%xmm2
mulsd  0x10(%rdx,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rsi,%rax,8),%xmm4
mulsd  0x18(%rdx,%rax,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x20(%rsi,%rax,8),%xmm1
mulsd  0x20(%rdx,%rax,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rax
cmp    %rax,%rdi
jne    11f0 <PSB_update+0xf0>
add    $0x1,%rax
test   %rbp,%rbp
je     1267 <PSB_update+0x167>
lea    (%rdx,%rax,8),%rcx
lea    (%rsi,%rax,8),%rax
xor    %edi,%edi
nopl   0x0(%rax)
movsd  (%rax,%rdi,8),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1250 <PSB_update+0x150>
cmpl   $0x0,-0x30(%rsp)
jle    1471 <PSB_update+0x371>
add    $0x1,%r12
movapd %xmm0,%xmm10
mulsd  %xmm0,%xmm10
mov    -0x30(%rsp),%rax
add    $0x1,%eax
mov    %rax,-0x30(%rsp)
lea    (%rsi,%r12,8),%rax
mov    %rax,-0x10(%rsp)
lea    (%rdx,%r12,8),%rax
mov    %rax,-0x18(%rsp)
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
movapd %xmm10,%xmm9
unpcklpd %xmm10,%xmm9
lea    -0x1(%r12),%r9
lea    0x8(%rdx),%r11
lea    0x8(%rsi),%r14
mov    $0x1,%ebx
xor    %r15d,%r15d
jmp    12ef <PSB_update+0x1ef>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r15
add    $0xffffffffffffffff,%r9
add    $0x8,%r11
add    $0x8,%r14
cmp    -0x30(%rsp),%rbx
je     1471 <PSB_update+0x371>
mov    %r15,%r13
not    %r13
add    %r12,%r13
mov    -0x8(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    %rbx,%rbp
cmp    $0x2,%r13
jb     1420 <PSB_update+0x320>
lea    (%rsi,%rbx,8),%rbp
lea    0x2(%r15),%rdi
lea    (%rdx,%rbx,8),%rcx
mov    %rcx,-0x20(%rsp)
lea    (%rdx,%rdi,8),%rcx
mov    %rcx,-0x28(%rsp)
lea    (%rsi,%rdi,8),%r10
lea    (%rax,%rbx,8),%r8
lea    (%rax,%r12,8),%rcx
cmp    -0x10(%rsp),%r8
setb   -0x31(%rsp)
cmp    %rcx,%rbp
setb   %dil
cmp    %r10,%r8
setb   %r10b
cmp    -0x28(%rsp),%r8
setb   -0x28(%rsp)
cmp    %rcx,-0x20(%rsp)
setb   %cl
cmp    -0x18(%rsp),%r8
setb   -0x20(%rsp)
mov    %rbx,%rbp
test   %dil,-0x31(%rsp)
jne    1420 <PSB_update+0x320>
mov    %rbx,%rbp
and    %dil,%r10b
jne    1420 <PSB_update+0x320>
mov    %rbx,%rbp
and    %cl,-0x28(%rsp)
jne    1420 <PSB_update+0x320>
mov    %rbx,%rbp
and    %cl,-0x20(%rsp)
jne    1420 <PSB_update+0x320>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rbx,%rcx,1),%rbp
movsd  (%rsi,%rbx,8),%xmm2
unpcklpd %xmm2,%xmm2
movsd  (%rdx,%rbx,8),%xmm6
movapd %xmm1,%xmm7
mulsd  %xmm6,%xmm7
unpcklpd %xmm6,%xmm6
unpcklpd %xmm7,%xmm7
xor    %edi,%edi
xchg   %ax,%ax
movupd (%r11,%rdi,8),%xmm3
movupd (%r14,%rdi,8),%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm2,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
divpd  %xmm8,%xmm5
mulpd  %xmm7,%xmm3
divpd  %xmm9,%xmm3
subpd  %xmm3,%xmm5
movupd (%r8,%rdi,8),%xmm3
subpd  %xmm5,%xmm3
movupd %xmm3,(%r8,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    13d0 <PSB_update+0x2d0>
cmp    %rcx,%r13
je     12d0 <PSB_update+0x1d0>
movsd  (%rdx,%rbp,8),%xmm2
movsd  (%rdx,%rbx,8),%xmm3
movsd  (%rsi,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  (%rsi,%rbx,8),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
divsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
divsd  %xmm10,%xmm3
subsd  %xmm3,%xmm5
movsd  (%rax,%rbp,8),%xmm2
subsd  %xmm5,%xmm2
movsd  %xmm2,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1420 <PSB_update+0x320>
jmp    12d0 <PSB_update+0x1d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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