void periodicBoundary(double *u, double *laplace, int height, int width) {
  int i;
  int n = width;
  if (height > n)
    n = height;
  for (i = 0; i < height; i++) {
    laplace[width * i] =
        laplace[width * i] + u[width * (i + 1) - 1] * (double)(n * n);
    laplace[width * (i + 1) - 1] =
        laplace[width * (i + 1) - 1] + u[width * i] * (double)(n * n);
  }
  for (i = 0; i < width; i++) {
    laplace[i] = laplace[i] + u[(height - 1) * width + i] * (double)(n * n);
    laplace[(height - 1) * width + i] =
        laplace[(height - 1) * width + i] + u[i] * (double)(n * n);
  }
}


x86 assembly (clang, -O0):
<periodicBoundary>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    112a <periodicBoundary+0x2a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11fb <periodicBoundary+0xfb>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1131 <periodicBoundary+0x31>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12b4 <periodicBoundary+0x1b4>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1202 <periodicBoundary+0x102>
pop    %rbp
ret

x86 assembly (clang, -O2):
<periodicBoundary>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    %ecx,%edx
mov    %ecx,%r8d
cmovg  %edx,%r8d
test   %edx,%edx
jle    1175 <periodicBoundary+0x75>
mov    %r8d,%eax
imul   %r8d,%eax
cvtsi2sd %eax,%xmm0
movslq %ecx,%r9
mov    %edx,%r10d
shl    $0x3,%r9
mov    %rdi,%rbx
mov    %rsi,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbx,%r9,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
movsd  (%rbx),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rax,%r9,1),%xmm1
add    %r9,%rbx
movsd  %xmm1,-0x8(%rax,%r9,1)
add    %r9,%rax
add    $0xffffffffffffffff,%r10
jne    1140 <periodicBoundary+0x40>
test   %ecx,%ecx
jle    11cf <periodicBoundary+0xcf>
add    $0xffffffff,%edx
imul   %r8d,%r8d
xorps  %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
imul   %ecx,%edx
movslq %edx,%r10
mov    %ecx,%r8d
cmp    $0x1,%ecx
jne    11da <periodicBoundary+0xda>
xor    %ecx,%ecx
lea    (%rdi,%r10,8),%rax
lea    (%rsi,%r10,8),%rdx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    11a0 <periodicBoundary+0xa0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rsi,%r8,8),%rcx
lea    (%rsi,%r10,8),%rbp
lea    (%r10,%r8,1),%rax
lea    (%rsi,%rax,8),%rbx
lea    (%rdi,%r10,8),%rdx
lea    (%rdi,%rax,8),%rax
lea    (%rdi,%r8,8),%r9
cmp    %rsi,%rbx
seta   -0x1(%rsp)
cmp    %rcx,%rbp
setb   %r12b
cmp    %rsi,%rax
seta   %r14b
cmp    %rcx,%rdx
setb   %r11b
cmp    %rsi,%r9
seta   %r15b
cmp    %rdi,%rcx
seta   -0x2(%rsp)
cmp    %rax,%rbp
setb   %r13b
cmp    %rbx,%rdx
setb   %al
cmp    %r9,%rbp
setb   %r9b
cmp    %rdi,%rbx
seta   %dl
xor    %ecx,%ecx
test   %r12b,-0x1(%rsp)
jne    1198 <periodicBoundary+0x98>
and    %r11b,%r14b
jne    1198 <periodicBoundary+0x98>
and    -0x2(%rsp),%r15b
jne    1198 <periodicBoundary+0x98>
and    %al,%r13b
jne    1198 <periodicBoundary+0x98>
and    %dl,%r9b
jne    1198 <periodicBoundary+0x98>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rax
mov    %rax,%r9
shr    %r9
add    $0x1,%r9
test   %rax,%rax
je     136d <periodicBoundary+0x26d>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x10(%rsi),%rax
lea    0x10(%rdi),%rbx
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rax),%xmm2
movupd -0x10(%rbx,%r10,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,-0x10(%rax)
movupd -0x10(%rax,%r10,8),%xmm2
movupd -0x10(%rbx),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,-0x10(%rax,%r10,8)
movupd (%rax),%xmm2
movupd (%rbx,%r10,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rax)
movupd (%rax,%r10,8),%xmm2
movupd (%rbx),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rax,%r10,8)
add    $0x4,%r11
add    $0x20,%rax
add    $0x20,%rbx
add    $0xfffffffffffffffe,%rdx
jne    12b0 <periodicBoundary+0x1b0>
test   $0x1,%r9b
je     135f <periodicBoundary+0x25f>
movupd (%rsi,%r11,8),%xmm2
lea    (%r11,%r10,1),%rax
movupd (%rdi,%rax,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rsi,%r11,8)
movupd (%rsi,%rax,8),%xmm2
movupd (%rdi,%r11,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rsi,%rax,8)
cmp    %r8,%rcx
jne    1198 <periodicBoundary+0x98>
jmp    11cf <periodicBoundary+0xcf>
xor    %r11d,%r11d
test   $0x1,%r9b
jne    132a <periodicBoundary+0x22a>
jmp    135f <periodicBoundary+0x25f>

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

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