void projectfrommatrix(double *vector, double **hmwc, int m) {
  int i, j, k;
  double p[1 + m][1 + m];
  double K[1 + m][1 + m];
  for (i = 0; i <= m; i = i + 1) {
    for (j = 0; j <= m; j = j + 1) {
      if (i == j) {
        p[i][j] = 1.0 - vector[i] * vector[j];
      } else {
        p[i][j] = -vector[i] * vector[j];
      }
    }
  }
  for (i = 0; i <= m; i = i + 1) {
    for (j = 0; j <= m; j = j + 1) {
      K[i][j] = 0.0;
      for (k = 0; k <= m; k = k + 1) {
        K[i][j] = K[i][j] + hmwc[i][k] * p[k][j];
      }
    }
  }
  for (i = 0; i <= m; i = i + 1) {
    for (j = 0; j <= m; j = j + 1) {
      hmwc[i][j] = 0.0;
      for (k = 0; k <= m; k = k + 1) {
        hmwc[i][j] = hmwc[i][j] + p[i][k] * K[k][j];
      }
    }
  }
}


x86 assembly (clang, -O0):
<projectfrommatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %rax,-0x68(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %rax,-0x58(%rbp)
mov    %rax,%rcx
mov    %rax,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1290 <projectfrommatrix+0x190>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     127d <projectfrommatrix+0x17d>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1219 <projectfrommatrix+0x119>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe08(%rip),%xmm1
addsd  %xmm1,%xmm0
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    126a <projectfrommatrix+0x16a>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rsi
mulsd  (%rcx,%rsi,8),%xmm0
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    126f <projectfrommatrix+0x16f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    119b <projectfrommatrix+0x9b>
jmp    1282 <projectfrommatrix+0x182>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1188 <projectfrommatrix+0x88>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     139a <projectfrommatrix+0x29a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1387 <projectfrommatrix+0x287>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1374 <projectfrommatrix+0x274>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rdi
movslq -0x18(%rbp),%r8
imul   %rdx,%r8
shl    $0x3,%r8
mov    %rax,%rsi
add    %r8,%rsi
movslq -0x1c(%rbp),%r8
movsd  (%rsi,%r8,8),%xmm1
mov    -0x10(%rbp),%rsi
movslq -0x18(%rbp),%r8
mov    (%rsi,%r8,8),%rsi
movslq -0x20(%rbp),%r8
movsd  (%rsi,%r8,8),%xmm0
movslq -0x20(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x1c(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12e0 <projectfrommatrix+0x1e0>
jmp    1379 <projectfrommatrix+0x279>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12aa <projectfrommatrix+0x1aa>
jmp    138c <projectfrommatrix+0x28c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1297 <projectfrommatrix+0x197>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1492 <projectfrommatrix+0x392>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     147f <projectfrommatrix+0x37f>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     146c <projectfrommatrix+0x36c>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x18(%rbp),%r8
mov    (%rsi,%r8,8),%rsi
movslq -0x1c(%rbp),%r8
movsd  (%rsi,%r8,8),%xmm1
movslq -0x18(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13df <projectfrommatrix+0x2df>
jmp    1471 <projectfrommatrix+0x371>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b4 <projectfrommatrix+0x2b4>
jmp    1484 <projectfrommatrix+0x384>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13a1 <projectfrommatrix+0x2a1>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<projectfrommatrix>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,-0x50(%rbp)
lea    0x1(%rdx),%r13d
mov    %r13,%rax
imul   %r13,%rax
mov    %rsp,%rcx
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
test   %edx,%edx
js     145e <projectfrommatrix+0x35e>
lea    0x0(,%r13,8),%rcx
xor    %eax,%eax
movapd 0xea0(%rip),%xmm0
movsd  0xea8(%rip),%xmm1
mov    -0x30(%rbp),%r8
jmp    117c <projectfrommatrix+0x7c>
xchg   %ax,%ax
add    $0x1,%rax
add    %rcx,%r8
cmp    %r13,%rax
je     11d4 <projectfrommatrix+0xd4>
mov    %rax,%rsi
imul   %r13,%rsi
mov    -0x30(%rbp),%rbx
lea    (%rbx,%rsi,8),%rsi
movsd  (%rdi,%rax,8),%xmm4
movapd %xmm4,%xmm2
xorpd  %xmm0,%xmm2
mulsd  %xmm4,%xmm4
movapd %xmm1,%xmm3
subsd  %xmm4,%xmm3
xor    %ebx,%ebx
jmp    11c8 <projectfrommatrix+0xc8>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,8),%xmm4
mulsd  %xmm2,%xmm4
movsd  %xmm4,(%r8,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
je     1170 <projectfrommatrix+0x70>
cmp    %rbx,%rax
jne    11b0 <projectfrommatrix+0xb0>
movsd  %xmm3,(%rsi,%rax,8)
jmp    11bf <projectfrommatrix+0xbf>
test   %edx,%edx
js     145e <projectfrommatrix+0x35e>
mov    %rdx,-0x60(%rbp)
lea    -0x1(%r13),%rax
mov    %rax,-0x58(%rbp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %r13d,%ebx
and    $0xfffffffc,%ebx
mov    %r13,%r14
shl    $0x4,%r14
mov    %r13,%r11
shl    $0x5,%r11
lea    (%rcx,%rcx,2),%r15
xor    %edi,%edi
jmp    1221 <projectfrommatrix+0x121>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rbp),%rdi
add    $0x1,%rdi
cmp    %r13,%rdi
je     131e <projectfrommatrix+0x21e>
mov    %rdi,%rdx
imul   %r13,%rdx
mov    -0x48(%rbp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,-0x40(%rbp)
mov    -0x50(%rbp),%rdx
mov    %rdi,-0x38(%rbp)
mov    (%rdx,%rdi,8),%r8
mov    -0x30(%rbp),%r10
xor    %r9d,%r9d
jmp    1267 <projectfrommatrix+0x167>
nopl   0x0(%rax)
mov    -0x40(%rbp),%rdx
movsd  %xmm0,(%rdx,%r9,8)
add    $0x1,%r9
add    $0x8,%r10
cmp    %r13,%r9
je     1210 <projectfrommatrix+0x110>
cmpq   $0x3,-0x58(%rbp)
jae    1280 <projectfrommatrix+0x180>
xorpd  %xmm0,%xmm0
xor    %r12d,%r12d
jmp    12dd <projectfrommatrix+0x1dd>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    %r10,%rsi
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%r12,8),%xmm1
mulsd  (%rsi),%xmm1
movsd  0x8(%r8,%r12,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  (%rsi,%r13,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x10(%r8,%r12,8),%xmm1
mulsd  (%rsi,%r14,1),%xmm1
addsd  %xmm2,%xmm1
movsd  0x18(%r8,%r12,8),%xmm0
mulsd  (%rsi,%r15,1),%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%r12
add    %r11,%rsi
cmp    %r12,%rbx
jne    1290 <projectfrommatrix+0x190>
test   %rax,%rax
je     1250 <projectfrommatrix+0x150>
mov    %r13,%rdx
imul   %r12,%rdx
lea    (%r10,%rdx,8),%rsi
lea    (%r8,%r12,8),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rsi),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
add    %rcx,%rsi
cmp    %rdi,%rax
jne    1300 <projectfrommatrix+0x200>
jmp    1250 <projectfrommatrix+0x150>
cmpl   $0x0,-0x60(%rbp)
js     145e <projectfrommatrix+0x35e>
mov    %r13d,%edx
and    $0x3,%edx
mov    %r13d,%r10d
and    $0xfffffffc,%r10d
mov    -0x30(%rbp),%rax
lea    0x18(%rax),%rbx
xor    %esi,%esi
jmp    1368 <projectfrommatrix+0x268>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x38(%rbp),%rsi
add    $0x1,%rsi
add    %rcx,%rbx
add    %rcx,-0x30(%rbp)
cmp    %r13,%rsi
je     145e <projectfrommatrix+0x35e>
mov    -0x50(%rbp),%rax
mov    %rsi,-0x38(%rbp)
mov    (%rax,%rsi,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%r12
xor    %r8d,%r8d
jmp    13a7 <projectfrommatrix+0x2a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax,%r8,8)
add    $0x1,%r8
add    $0x8,%r12
cmp    %r13,%r8
je     1350 <projectfrommatrix+0x250>
cmpq   $0x3,-0x58(%rbp)
jae    13c0 <projectfrommatrix+0x2c0>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
jmp    141a <projectfrommatrix+0x31a>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    %r12,%r9
xor    %esi,%esi
nopl   0x0(%rax)
movsd  -0x18(%rbx,%rsi,8),%xmm1
mulsd  (%r9),%xmm1
movsd  -0x10(%rbx,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  (%r9,%rcx,1),%xmm2
addsd  %xmm1,%xmm2
movsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  (%r9,%r14,1),%xmm1
addsd  %xmm2,%xmm1
movsd  (%rbx,%rsi,8),%xmm0
mulsd  (%r9,%r15,1),%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rsi
add    %r11,%r9
cmp    %rsi,%r10
jne    13d0 <projectfrommatrix+0x2d0>
test   %rdx,%rdx
je     1390 <projectfrommatrix+0x290>
mov    %r13,%rax
imul   %rsi,%rax
lea    (%r12,%rax,8),%rax
mov    -0x30(%rbp),%rdi
lea    (%rdi,%rsi,8),%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  (%rax),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
add    %rcx,%rax
cmp    %rdi,%rdx
jne    1440 <projectfrommatrix+0x340>
jmp    1390 <projectfrommatrix+0x290>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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