void calc(double *a, double *b, unsigned int n, unsigned int r, unsigned int k,
          unsigned int j) {
  unsigned int i;
  double t = a[j * n + k] / a[k * n + k];
  a[j * n + k] = 0.0;
  for (i = k + 1; i < n; i++) {
    a[j * n + i] -= a[k * n + i] * t;
  }
  for (i = 0; i < r; i++) {
    b[j * r + i] -= b[k * r + i] * t;
  }
  return;
}


x86 assembly (clang, -O0):
<calc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11d7 <calc+0xd7>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
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    116a <calc+0x6a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    124b <calc+0x14b>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
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    11de <calc+0xde>
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9d,%r10d
imul   %edx,%r10d
lea    (%r10,%r8,1),%ebx
movsd  (%rdi,%rbx,8),%xmm0
mov    %r8d,%r11d
imul   %edx,%r11d
lea    (%r11,%r8,1),%eax
divsd  (%rdi,%rax,8),%xmm0
movq   $0x0,(%rdi,%rbx,8)
lea    0x1(%r8),%eax
cmp    %edx,%eax
jae    1256 <calc+0x156>
mov    %eax,%eax
mov    %edx,%r14d
sub    %r8d,%r14d
add    $0xfffffffe,%r14d
cmp    $0x3,%r14d
jb     1230 <calc+0x130>
mov    $0xfffffffe,%ebp
sub    %ebx,%ebp
cmp    %r14d,%ebp
jb     1230 <calc+0x130>
mov    %edx,%ebx
not    %ebx
imul   %r8d,%ebx
add    $0xfffffffe,%ebx
cmp    %r14d,%ebx
jb     1230 <calc+0x130>
lea    (%r10,%r8,1),%ebx
add    $0x1,%ebx
lea    (%rdi,%rbx,8),%r15
lea    0x1(%rdx),%r12d
imul   %r8d,%r12d
add    $0x1,%r12d
lea    (%r14,%r12,1),%rbp
lea    (%rdi,%rbp,8),%rbp
add    $0x8,%rbp
cmp    %rbp,%r15
jae    11b4 <calc+0xb4>
add    %r14,%rbx
lea    (%rdi,%rbx,8),%rbx
add    $0x8,%rbx
lea    (%rdi,%r12,8),%rbp
cmp    %rbx,%rbp
jb     1230 <calc+0x130>
add    $0x1,%r14
mov    %r14,%r15
and    $0xfffffffffffffffc,%r15
add    %r15,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    (%r8,%r10,1),%ebp
add    $0x1,%ebp
mov    %r15,%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%ebx
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
mov    %ebp,%ebx
movupd (%rdi,%rbx,8),%xmm4
movupd 0x10(%rdi,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,(%rdi,%rbx,8)
movupd %xmm5,0x10(%rdi,%rbx,8)
add    $0x4,%r12d
add    $0x4,%ebp
add    $0xfffffffffffffffc,%r13
jne    11e0 <calc+0xe0>
cmp    %r15,%r14
je     1256 <calc+0x156>
nopl   0x0(%rax,%rax,1)
lea    (%r11,%rax,1),%ebx
lea    (%r10,%rax,1),%ebp
movsd  (%rdi,%rbp,8),%xmm1
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
add    $0x1,%eax
cmp    %edx,%eax
jb     1230 <calc+0x130>
test   %ecx,%ecx
je     12fa <calc+0x1fa>
imul   %ecx,%r8d
imul   %ecx,%r9d
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1305 <calc+0x205>
xor    %ebp,%ebp
mov    %rbp,%rcx
not    %rcx
test   $0x1,%al
je     12a0 <calc+0x1a0>
lea    (%r8,%rbp,1),%edx
lea    (%r9,%rbp,1),%edi
movsd  (%rsi,%rdi,8),%xmm1
movsd  (%rsi,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
or     $0x1,%rbp
add    %rax,%rcx
je     12fa <calc+0x1fa>
add    %ebp,%r8d
add    %ebp,%r9d
sub    %rbp,%rax
xchg   %ax,%ax
mov    %r8d,%ecx
mov    %r9d,%edx
movsd  (%rsi,%rdx,8),%xmm1
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
lea    0x1(%r8),%ecx
lea    0x1(%r9),%edx
movsd  (%rsi,%rdx,8),%xmm1
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x2,%r8d
add    $0x2,%r9d
add    $0xfffffffffffffffe,%rax
jne    12b0 <calc+0x1b0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rax),%rcx
mov    %r8d,%edx
add    %ecx,%edx
setb   %dl
xor    %ebp,%ebp
mov    %r9d,%edi
add    %ecx,%edi
jb     1273 <calc+0x173>
shr    $0x20,%rcx
jne    1273 <calc+0x173>
test   %dl,%dl
jne    1273 <calc+0x173>
test   %rcx,%rcx
jne    1273 <calc+0x173>
mov    %r9d,%ecx
lea    (%rsi,%rcx,8),%rdi
mov    %r8d,%edx
lea    (%rax,%rdx,1),%rbp
lea    (%rsi,%rbp,8),%rbp
cmp    %rbp,%rdi
jae    1364 <calc+0x264>
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%rdx,8),%rdx
cmp    %rcx,%rdx
jb     1271 <calc+0x171>
mov    %eax,%ebp
and    $0xfffffffc,%ebp
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r9d,%edx
mov    %r8d,%edi
mov    %rbp,%rcx
nopw   0x0(%rax,%rax,1)
mov    %edi,%ebx
movupd (%rsi,%rbx,8),%xmm2
movupd 0x10(%rsi,%rbx,8),%xmm3
mov    %edx,%ebx
movupd (%rsi,%rbx,8),%xmm4
movupd 0x10(%rsi,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,(%rsi,%rbx,8)
movupd %xmm5,0x10(%rsi,%rbx,8)
add    $0x4,%edi
add    $0x4,%edx
add    $0xfffffffffffffffc,%rcx
jne    1380 <calc+0x280>
cmp    %rax,%rbp
jne    1273 <calc+0x173>
jmp    12fa <calc+0x1fa>

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

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