void pseudoinverse(double (*in)[3], double (*out)[3], int size) {
  double work[3][6], num;
  int i, j, k;
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 6; j++)
      work[i][j] = j == i + 3;
    for (j = 0; j < 3; j++)
      for (k = 0; k < size; k++)
        work[i][j] += in[k][i] * in[k][j];
  }
  for (i = 0; i < 3; i++) {
    num = work[i][i];
    for (j = 0; j < 6; j++)
      work[i][j] /= num;
    for (k = 0; k < 3; k++) {
      if (k == i)
        continue;
      num = work[k][i];
      for (j = 0; j < 6; j++)
        work[k][j] -= work[i][j] * num;
    }
  }
  for (i = 0; i < size; i++)
    for (j = 0; j < 3; j++)
      for (out[i][j] = k = 0; k < 3; k++)
        out[i][j] += work[j][k + 3] * in[i][k];
}


x86 assembly (clang, -O0):
<pseudoinverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0xbc(%rbp)
cmpl   $0x3,-0xbc(%rbp)
jge    1273 <pseudoinverse+0x173>
movl   $0x0,-0xc0(%rbp)
cmpl   $0x6,-0xc0(%rbp)
jge    1193 <pseudoinverse+0x93>
mov    -0xc0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2sd %eax,%xmm0
movslq -0xbc(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1134 <pseudoinverse+0x34>
movl   $0x0,-0xc0(%rbp)
cmpl   $0x3,-0xc0(%rbp)
jge    125a <pseudoinverse+0x15a>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1241 <pseudoinverse+0x141>
mov    -0x8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0xbc(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    11b4 <pseudoinverse+0xb4>
jmp    1246 <pseudoinverse+0x146>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    119d <pseudoinverse+0x9d>
jmp    125f <pseudoinverse+0x15f>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    111d <pseudoinverse+0x1d>
movl   $0x0,-0xbc(%rbp)
cmpl   $0x3,-0xbc(%rbp)
jge    1432 <pseudoinverse+0x332>
movslq -0xbc(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xc0(%rbp)
cmpl   $0x6,-0xc0(%rbp)
jge    1310 <pseudoinverse+0x210>
movsd  -0xb8(%rbp),%xmm1
ff
movslq -0xbc(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    12bd <pseudoinverse+0x1bd>
movl   $0x0,-0xc4(%rbp)
cmpl   $0x3,-0xc4(%rbp)
jge    1419 <pseudoinverse+0x319>
mov    -0xc4(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jne    133e <pseudoinverse+0x23e>
jmp    1405 <pseudoinverse+0x305>
movslq -0xc4(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xc0(%rbp)
cmpl   $0x6,-0xc0(%rbp)
jge    1400 <pseudoinverse+0x300>
movslq -0xbc(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movslq -0xc4(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%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    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1371 <pseudoinverse+0x271>
jmp    1405 <pseudoinverse+0x305>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    131a <pseudoinverse+0x21a>
jmp    141e <pseudoinverse+0x31e>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    127d <pseudoinverse+0x17d>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    154f <pseudoinverse+0x44f>
movl   $0x0,-0xc0(%rbp)
cmpl   $0x3,-0xc0(%rbp)
jge    1536 <pseudoinverse+0x436>
movl   $0x0,-0xc4(%rbp)
mov    -0x10(%rbp),%rax
movslq -0xbc(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x3,-0xc4(%rbp)
jge    151d <pseudoinverse+0x41d>
movslq -0xc0(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
mov    -0xc4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xbc(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xbc(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    148d <pseudoinverse+0x38d>
jmp    1522 <pseudoinverse+0x422>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1455 <pseudoinverse+0x355>
jmp    153b <pseudoinverse+0x43b>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    143c <pseudoinverse+0x33c>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pseudoinverse>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edx,%r8d
lea    -0x1(%r8),%r10
mov    %r8d,%r15d
and    $0xfffffffe,%r15d
lea    0x18(%rdi),%r9
xor    %ecx,%ecx
movsd  0xedb(%rip),%xmm0
xorpd  %xmm1,%xmm1
xor    %r11d,%r11d
jmp    114e <pseudoinverse+0x4e>
xchg   %ax,%ax
lea    (%rsp,%r14,1),%rax
add    $0xffffffffffffff90,%rax
movsd  %xmm2,(%rax)
add    $0x1,%r11
add    $0x8,%rcx
cmp    $0x3,%r11
je     1337 <pseudoinverse+0x237>
lea    0x3(%r11),%rax
movapd %xmm0,%xmm2
test   %r11,%r11
je     115f <pseudoinverse+0x5f>
xorpd  %xmm2,%xmm2
movapd %xmm0,%xmm3
cmp    $0x4,%rax
je     116d <pseudoinverse+0x6d>
xorpd  %xmm3,%xmm3
lea    (%r11,%r11,2),%r14
shl    $0x4,%r14
movapd %xmm0,%xmm4
cmp    $0x5,%rax
je     1183 <pseudoinverse+0x83>
xorpd  %xmm4,%xmm4
movapd %xmm1,-0x80(%rsp,%r14,1)
movq   $0x0,-0x70(%rsp,%r14,1)
movsd  %xmm2,-0x68(%rsp,%r14,1)
movsd  %xmm3,-0x60(%rsp,%r14,1)
movsd  %xmm4,-0x58(%rsp,%r14,1)
test   %edx,%edx
jle    113c <pseudoinverse+0x3c>
test   %r10,%r10
je     12e0 <pseudoinverse+0x1e0>
xorpd  %xmm3,%xmm3
mov    %rdi,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movsd  (%rax,%rcx,1),%xmm4
mulsd  (%rax),%xmm4
movsd  0x18(%rax,%rcx,1),%xmm2
addsd  %xmm3,%xmm4
mulsd  0x18(%rax),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rbx
add    $0x30,%rax
movapd %xmm2,%xmm3
cmp    %rbx,%r15
jne    11c0 <pseudoinverse+0xc0>
test   $0x1,%r8b
je     120a <pseudoinverse+0x10a>
lea    (%rbx,%rbx,2),%rax
lea    (%rdi,%rax,8),%rbx
movsd  (%rbx,%r11,8),%xmm3
mulsd  (%rdi,%rax,8),%xmm3
addsd  %xmm3,%xmm2
lea    (%rsp,%r14,1),%rax
add    $0xffffffffffffff80,%rax
movsd  %xmm2,(%rax)
test   %edx,%edx
jle    113c <pseudoinverse+0x3c>
test   %r10,%r10
je     12f5 <pseudoinverse+0x1f5>
xorpd  %xmm3,%xmm3
mov    %r9,%rax
xor    %ebx,%ebx
movsd  -0x18(%rax,%rcx,1),%xmm4
mulsd  -0x10(%rax),%xmm4
movsd  (%rax,%rcx,1),%xmm2
addsd  %xmm3,%xmm4
mulsd  0x8(%rax),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rbx
add    $0x30,%rax
movapd %xmm2,%xmm3
cmp    %rbx,%r15
jne    1230 <pseudoinverse+0x130>
test   $0x1,%r8b
je     127c <pseudoinverse+0x17c>
lea    (%rbx,%rbx,2),%rax
lea    (%rdi,%rax,8),%rbx
movsd  (%rbx,%r11,8),%xmm3
mulsd  0x8(%rdi,%rax,8),%xmm3
addsd  %xmm3,%xmm2
lea    (%rsp,%r14,1),%rax
add    $0xffffffffffffff88,%rax
movsd  %xmm2,(%rax)
test   %edx,%edx
jle    113c <pseudoinverse+0x3c>
test   %r10,%r10
je     130a <pseudoinverse+0x20a>
xorpd  %xmm3,%xmm3
mov    %r9,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movsd  -0x18(%rax,%rcx,1),%xmm4
mulsd  -0x8(%rax),%xmm4
movsd  (%rax,%rcx,1),%xmm2
addsd  %xmm3,%xmm4
mulsd  0x10(%rax),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%rbx
add    $0x30,%rax
movapd %xmm2,%xmm3
cmp    %rbx,%r15
jne    12a0 <pseudoinverse+0x1a0>
test   $0x1,%r8b
je     1130 <pseudoinverse+0x30>
jmp    131a <pseudoinverse+0x21a>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
test   $0x1,%r8b
jne    11f3 <pseudoinverse+0xf3>
jmp    120a <pseudoinverse+0x10a>
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
test   $0x1,%r8b
jne    1264 <pseudoinverse+0x164>
jmp    127c <pseudoinverse+0x17c>
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
test   $0x1,%r8b
je     1130 <pseudoinverse+0x30>
lea    (%rbx,%rbx,2),%rax
lea    (%rdi,%rax,8),%rbx
movsd  (%rbx,%r11,8),%xmm3
mulsd  0x10(%rdi,%rax,8),%xmm3
addsd  %xmm3,%xmm2
jmp    1130 <pseudoinverse+0x30>
mov    $0x4,%eax
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    13be <pseudoinverse+0x2be>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x20(%rsp,%rbx,1),%xmm0
unpcklpd %xmm0,%xmm0
movapd -0xa0(%rsp,%rax,8),%xmm1
ff ff
mulpd  %xmm0,%xmm1
movapd -0x20(%rsp),%xmm2
subpd  %xmm1,%xmm2
movapd -0x10(%rsp),%xmm1
movapd (%rsp),%xmm3
movapd %xmm2,-0x20(%rsp)
movapd -0x90(%rsp,%rax,8),%xmm2
ff ff
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm1
movapd %xmm1,-0x10(%rsp)
mulpd  -0x80(%rsp,%rax,8),%xmm0
subpd  %xmm0,%xmm3
movapd %xmm3,(%rsp)
add    $0x8,%rbx
add    $0x38,%rcx
add    $0x6,%rax
cmp    $0x18,%rbx
je     14d6 <pseudoinverse+0x3d6>
movsd  -0x80(%rsp,%rcx,1),%xmm0
unpcklpd %xmm0,%xmm0
movapd -0xa0(%rsp,%rax,8),%xmm1
ff ff
movapd -0x90(%rsp,%rax,8),%xmm2
ff ff
movapd -0x80(%rsp,%rax,8),%xmm3
divpd  %xmm0,%xmm1
movapd %xmm1,-0xa0(%rsp,%rax,8)
ff ff
divpd  %xmm0,%xmm2
movapd %xmm2,-0x90(%rsp,%rax,8)
ff ff
divpd  %xmm0,%xmm3
movapd %xmm3,-0x80(%rsp,%rax,8)
test   %rbx,%rbx
je     146d <pseudoinverse+0x36d>
movsd  -0x80(%rsp,%rbx,1),%xmm0
unpcklpd %xmm0,%xmm0
movapd -0xa0(%rsp,%rax,8),%xmm1
ff ff
mulpd  %xmm0,%xmm1
movapd -0x80(%rsp),%xmm2
subpd  %xmm1,%xmm2
movapd -0x70(%rsp),%xmm1
movapd -0x60(%rsp),%xmm3
movapd %xmm2,-0x80(%rsp)
movapd -0x90(%rsp,%rax,8),%xmm2
ff ff
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm1
movapd %xmm1,-0x70(%rsp)
mulpd  -0x80(%rsp,%rax,8),%xmm0
subpd  %xmm0,%xmm3
movapd %xmm3,-0x60(%rsp)
cmp    $0x8,%rbx
je     1350 <pseudoinverse+0x250>
movsd  -0x50(%rsp,%rbx,1),%xmm0
unpcklpd %xmm0,%xmm0
movapd -0xa0(%rsp,%rax,8),%xmm1
ff ff
mulpd  %xmm0,%xmm1
movapd -0x50(%rsp),%xmm2
subpd  %xmm1,%xmm2
movapd -0x40(%rsp),%xmm1
movapd -0x30(%rsp),%xmm3
movapd %xmm2,-0x50(%rsp)
movapd -0x90(%rsp,%rax,8),%xmm2
ff ff
mulpd  %xmm0,%xmm2
subpd  %xmm2,%xmm1
movapd %xmm1,-0x40(%rsp)
mulpd  -0x80(%rsp,%rax,8),%xmm0
subpd  %xmm0,%xmm3
movapd %xmm3,-0x30(%rsp)
cmp    $0x10,%rbx
jne    1350 <pseudoinverse+0x250>
jmp    13a8 <pseudoinverse+0x2a8>
test   %edx,%edx
jle    1609 <pseudoinverse+0x509>
movsd  -0x68(%rsp),%xmm8
movsd  -0x60(%rsp),%xmm9
movsd  -0x58(%rsp),%xmm10
movsd  -0x38(%rsp),%xmm11
movsd  -0x30(%rsp),%xmm4
movsd  -0x28(%rsp),%xmm5
movsd  -0x8(%rsp),%xmm6
movsd  (%rsp),%xmm7
movsd  0x8(%rsp),%xmm0
shl    $0x3,%r8
lea    (%r8,%r8,2),%rax
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,(%rsi,%rcx,1)
movsd  (%rdi,%rcx,1),%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rcx,1)
movsd  0x8(%rdi,%rcx,1),%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rcx,1)
movsd  0x10(%rdi,%rcx,1),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rsi,%rcx,1)
movq   $0x0,0x8(%rsi,%rcx,1)
movsd  (%rdi,%rcx,1),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,1)
movsd  0x8(%rdi,%rcx,1),%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%rsi,%rcx,1)
movsd  0x10(%rdi,%rcx,1),%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,1)
movq   $0x0,0x10(%rsi,%rcx,1)
movsd  (%rdi,%rcx,1),%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsi,%rcx,1)
movsd  0x8(%rdi,%rcx,1),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x10(%rsi,%rcx,1)
movsd  0x10(%rdi,%rcx,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x10(%rsi,%rcx,1)
add    $0x18,%rcx
cmp    %rcx,%rax
jne    1530 <pseudoinverse+0x430>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @pseudoinverse([3 x double]* nocapture %0, [3 x double]* nocapture %1, i32 %2) {
%4 = alloca [3 x [6 x double]]
%5 = bitcast [3 x [6 x double]]* %4 to i8*
%6 = icmp sgt i32 %2, 0
%7 = zext i32 %2 to i64
%8 = add nsw i64 %7, -1
%9 = and i64 %7, 1
%10 = icmp eq i64 %8, 0
%11 = and i64 %7, 4294967294
%12 = icmp eq i64 %9, 0
%13 = and i64 %7, 1
%14 = icmp eq i64 %8, 0
%15 = and i64 %7, 4294967294
%16 = icmp eq i64 %13, 0
%17 = and i64 %7, 1
%18 = icmp eq i64 %8, 0
%19 = and i64 %7, 4294967294
%20 = icmp eq i64 %17, 0
br label %21
21: ; preds = %3, %130
%22 = phi i64 [ 0, %3 ], [ %131, %130 ]
%23 = add nuw nsw i64 %22, 3
%24 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 0
%25 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 1
%26 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 2
%27 = icmp eq i64 %22, 0
%28 = uitofp i1 %27 to double
%29 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 3
%30 = bitcast double* %24 to i8*
store double %28, double* %29
%31 = icmp eq i64 %23, 4
%32 = uitofp i1 %31 to double
%33 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 4
store double %32, double* %33
%34 = icmp eq i64 %23, 5
%35 = uitofp i1 %34 to double
%36 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %22, i64 5
store double %35, double* %36
br i1 %6, label %37, label %130
37: ; preds = %21
br i1 %10, label %56, label %38
38: ; preds = %37, %38
%39 = phi i64 [ %53, %38 ], [ 0, %37 ]
%40 = phi double [ %52, %38 ], [ 0.000000e+00, %37 ]
%41 = phi i64 [ %54, %38 ], [ 0, %37 ]
%42 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %39, i64 %22
%43 = load double, double* %42
%44 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %39, i64 0
%45 = load double, double* %44
%46 = tail call double @llvm.fmuladd.f64(double %43, double %45, double %40)
%47 = or i64 %39, 1
%48 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %47, i64 %22
%49 = load double, double* %48
%50 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %47, i64 0
%51 = load double, double* %50
%52 = tail call double @llvm.fmuladd.f64(double %49, double %51, double %46)
%53 = add nuw nsw i64 %39, 2
%54 = add i64 %41, 2
%55 = icmp eq i64 %54, %11
br i1 %55, label %56, label %38
56: ; preds = %38, %37
%57 = phi double [ undef, %37 ], [ %52, %38 ]
%58 = phi i64 [ 0, %37 ], [ %53, %38 ]
%59 = phi double [ 0.000000e+00, %37 ], [ %52, %38 ]
br i1 %12, label %66, label %60
60: ; preds = %56
%61 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %58, i64 %22
%62 = load double, double* %61
%63 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %58, i64 0
%64 = load double, double* %63
%65 = tail call double @llvm.fmuladd.f64(double %62, double %64, double %59)
br label %66
66: ; preds = %56, %60
%67 = phi double [ %57, %56 ], [ %65, %60 ]
store double %67, double* %24
br i1 %6, label %68, label %130
68: ; preds = %66
br i1 %14, label %87, label %69
69: ; preds = %68, %69
%70 = phi i64 [ %84, %69 ], [ 0, %68 ]
%71 = phi double [ %83, %69 ], [ 0.000000e+00, %68 ]
%72 = phi i64 [ %85, %69 ], [ 0, %68 ]
%73 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %70, i64 %22
%74 = load double, double* %73
%75 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %70, i64 1
%76 = load double, double* %75
%77 = tail call double @llvm.fmuladd.f64(double %74, double %76, double %71)
%78 = or i64 %70, 1
%79 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %78, i64 %22
%80 = load double, double* %79
%81 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %78, i64 1
%82 = load double, double* %81
%83 = tail call double @llvm.fmuladd.f64(double %80, double %82, double %77)
%84 = add nuw nsw i64 %70, 2
%85 = add i64 %72, 2
%86 = icmp eq i64 %85, %15
br i1 %86, label %87, label %69
87: ; preds = %69, %68
%88 = phi double [ undef, %68 ], [ %83, %69 ]
%89 = phi i64 [ 0, %68 ], [ %84, %69 ]
%90 = phi double [ 0.000000e+00, %68 ], [ %83, %69 ]
br i1 %16, label %97, label %91
91: ; preds = %87
%92 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %89, i64 %22
%93 = load double, double* %92
%94 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %89, i64 1
%95 = load double, double* %94
%96 = tail call double @llvm.fmuladd.f64(double %93, double %95, double %90)
br label %97
97: ; preds = %87, %91
%98 = phi double [ %88, %87 ], [ %96, %91 ]
store double %98, double* %25
br i1 %6, label %99, label %130
99: ; preds = %97
br i1 %18, label %118, label %100
100: ; preds = %99, %100
%101 = phi i64 [ %115, %100 ], [ 0, %99 ]
%102 = phi double [ %114, %100 ], [ 0.000000e+00, %99 ]
%103 = phi i64 [ %116, %100 ], [ 0, %99 ]
%104 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %101, i64 %22
%105 = load double, double* %104
%106 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %101, i64 2
%107 = load double, double* %106
%108 = tail call double @llvm.fmuladd.f64(double %105, double %107, double %102)
%109 = or i64 %101, 1
%110 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %109, i64 %22
%111 = load double, double* %110
%112 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %109, i64 2
%113 = load double, double* %112
%114 = tail call double @llvm.fmuladd.f64(double %111, double %113, double %108)
%115 = add nuw nsw i64 %101, 2
%116 = add i64 %103, 2
%117 = icmp eq i64 %116, %19
br i1 %117, label %118, label %100
118: ; preds = %100, %99
%119 = phi double [ undef, %99 ], [ %114, %100 ]
%120 = phi i64 [ 0, %99 ], [ %115, %100 ]
%121 = phi double [ 0.000000e+00, %99 ], [ %114, %100 ]
br i1 %20, label %128, label %122
122: ; preds = %118
%123 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %120, i64 %22
%124 = load double, double* %123
%125 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %120, i64 2
%126 = load double, double* %125
%127 = tail call double @llvm.fmuladd.f64(double %124, double %126, double %121)
br label %128
128: ; preds = %118, %122
%129 = phi double [ %119, %118 ], [ %127, %122 ]
store double %129, double* %26
br label %130
130: ; preds = %21, %66, %128, %97
%131 = add nuw nsw i64 %22, 1
%132 = icmp eq i64 %131, 3
br i1 %132, label %133, label %21
133: ; preds = %130
%134 = bitcast [3 x [6 x double]]* %4 to <2 x double>*
%135 = bitcast [3 x [6 x double]]* %4 to <2 x double>*
%136 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 2
%137 = bitcast double* %136 to <2 x double>*
%138 = bitcast double* %136 to <2 x double>*
%139 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 4
%140 = bitcast double* %139 to <2 x double>*
%141 = bitcast double* %139 to <2 x double>*
%142 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 0
%143 = bitcast double* %142 to <2 x double>*
%144 = bitcast double* %142 to <2 x double>*
%145 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 2
%146 = bitcast double* %145 to <2 x double>*
%147 = bitcast double* %145 to <2 x double>*
%148 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 4
%149 = bitcast double* %148 to <2 x double>*
%150 = bitcast double* %148 to <2 x double>*
%151 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 0
%152 = bitcast double* %151 to <2 x double>*
%153 = bitcast double* %151 to <2 x double>*
%154 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 2
%155 = bitcast double* %154 to <2 x double>*
%156 = bitcast double* %154 to <2 x double>*
%157 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 4
%158 = bitcast double* %157 to <2 x double>*
%159 = bitcast double* %157 to <2 x double>*
br label %181
160: ; preds = %265
br i1 %6, label %161, label %296
161: ; preds = %160
%162 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 3
%163 = zext i32 %2 to i64
%164 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 3
%165 = load double, double* %164
%166 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 4
%167 = load double, double* %166
%168 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 5
%169 = load double, double* %168
%170 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 3
%171 = load double, double* %170
%172 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 4
%173 = load double, double* %172
%174 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 5
%175 = load double, double* %174
%176 = load double, double* %162
%177 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 4
%178 = load double, double* %177
%179 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 5
%180 = load double, double* %179
br label %268
181: ; preds = %133, %265
%182 = phi i64 [ %266, %265 ], [ 0, %133 ]
%183 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %182, i64 %182
%184 = load double, double* %183
%185 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %182, i64 0
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = insertelement <2 x double> poison, double %184, i64 0
%189 = shufflevector <2 x double> %188, <2 x double> poison, <2 x i32> zeroinitializer
%190 = fdiv <2 x double> %187, %189
%191 = bitcast double* %185 to <2 x double>*
store <2 x double> %190, <2 x double>* %191
%192 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %182, i64 2
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = fdiv <2 x double> %194, %189
%196 = bitcast double* %192 to <2 x double>*
store <2 x double> %195, <2 x double>* %196
%197 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 %182, i64 4
%198 = bitcast double* %197 to <2 x double>*
%199 = load <2 x double>, <2 x double>* %198
%200 = fdiv <2 x double> %199, %189
%201 = bitcast double* %197 to <2 x double>*
store <2 x double> %200, <2 x double>* %201
%202 = icmp eq i64 %182, 0
br i1 %202, label %224, label %203
203: ; preds = %181
%204 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 0, i64 %182
%205 = load double, double* %204
%206 = bitcast double* %185 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = load <2 x double>, <2 x double>* %134
%209 = fneg <2 x double> %207
%210 = insertelement <2 x double> poison, double %205, i64 0
%211 = shufflevector <2 x double> %210, <2 x double> poison, <2 x i32> zeroinitializer
%212 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %209, <2 x double> %211, <2 x double> %208)
store <2 x double> %212, <2 x double>* %135
%213 = bitcast double* %192 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = load <2 x double>, <2 x double>* %137
%216 = fneg <2 x double> %214
%217 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> %211, <2 x double> %215)
store <2 x double> %217, <2 x double>* %138
%218 = bitcast double* %197 to <2 x double>*
%219 = load <2 x double>, <2 x double>* %218
%220 = load <2 x double>, <2 x double>* %140
%221 = fneg <2 x double> %219
%222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %221, <2 x double> %211, <2 x double> %220)
store <2 x double> %222, <2 x double>* %141
%223 = icmp eq i64 %182, 1
br i1 %223, label %245, label %224
224: ; preds = %203, %181
%225 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 1, i64 %182
%226 = load double, double* %225
%227 = bitcast double* %185 to <2 x double>*
%228 = load <2 x double>, <2 x double>* %227
%229 = load <2 x double>, <2 x double>* %143
%230 = fneg <2 x double> %228
%231 = insertelement <2 x double> poison, double %226, i64 0
%232 = shufflevector <2 x double> %231, <2 x double> poison, <2 x i32> zeroinitializer
%233 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %230, <2 x double> %232, <2 x double> %229)
store <2 x double> %233, <2 x double>* %144
%234 = bitcast double* %192 to <2 x double>*
%235 = load <2 x double>, <2 x double>* %234
%236 = load <2 x double>, <2 x double>* %146
%237 = fneg <2 x double> %235
%238 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %237, <2 x double> %232, <2 x double> %236)
store <2 x double> %238, <2 x double>* %147
%239 = bitcast double* %197 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = load <2 x double>, <2 x double>* %149
%242 = fneg <2 x double> %240
%243 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %242, <2 x double> %232, <2 x double> %241)
store <2 x double> %243, <2 x double>* %150
%244 = icmp eq i64 %182, 2
br i1 %244, label %265, label %245
245: ; preds = %203, %224
%246 = getelementptr inbounds [3 x [6 x double]], [3 x [6 x double]]* %4, i64 0, i64 2, i64 %182
%247 = load double, double* %246
%248 = bitcast double* %185 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = load <2 x double>, <2 x double>* %152
%251 = fneg <2 x double> %249
%252 = insertelement <2 x double> poison, double %247, i64 0
%253 = shufflevector <2 x double> %252, <2 x double> poison, <2 x i32> zeroinitializer
%254 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %251, <2 x double> %253, <2 x double> %250)
store <2 x double> %254, <2 x double>* %153
%255 = bitcast double* %192 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = load <2 x double>, <2 x double>* %155
%258 = fneg <2 x double> %256
%259 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %258, <2 x double> %253, <2 x double> %257)
store <2 x double> %259, <2 x double>* %156
%260 = bitcast double* %197 to <2 x double>*
%261 = load <2 x double>, <2 x double>* %260
%262 = load <2 x double>, <2 x double>* %158
%263 = fneg <2 x double> %261
%264 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %263, <2 x double> %253, <2 x double> %262)
store <2 x double> %264, <2 x double>* %159
br label %265
265: ; preds = %245, %224
%266 = add nuw nsw i64 %182, 1
%267 = icmp eq i64 %266, 3
br i1 %267, label %160, label %181
268: ; preds = %161, %268
%269 = phi i64 [ 0, %161 ], [ %294, %268 ]
%270 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 %269, i64 0
store double 0.000000e+00, double* %270
%271 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %269, i64 0
%272 = load double, double* %271
%273 = tail call double @llvm.fmuladd.f64(double %165, double %272, double 0.000000e+00)
store double %273, double* %270
%274 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %269, i64 1
%275 = load double, double* %274
%276 = tail call double @llvm.fmuladd.f64(double %167, double %275, double %273)
store double %276, double* %270
%277 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 %269, i64 2
%278 = load double, double* %277
%279 = tail call double @llvm.fmuladd.f64(double %169, double %278, double %276)
store double %279, double* %270
%280 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 %269, i64 1
store double 0.000000e+00, double* %280
%281 = load double, double* %271
%282 = tail call double @llvm.fmuladd.f64(double %171, double %281, double 0.000000e+00)
store double %282, double* %280
%283 = load double, double* %274
%284 = tail call double @llvm.fmuladd.f64(double %173, double %283, double %282)
store double %284, double* %280
%285 = load double, double* %277
%286 = tail call double @llvm.fmuladd.f64(double %175, double %285, double %284)
store double %286, double* %280
%287 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 %269, i64 2
store double 0.000000e+00, double* %287
%288 = load double, double* %271
%289 = tail call double @llvm.fmuladd.f64(double %176, double %288, double 0.000000e+00)
store double %289, double* %287
%290 = load double, double* %274
%291 = tail call double @llvm.fmuladd.f64(double %178, double %290, double %289)
store double %291, double* %287
%292 = load double, double* %277
%293 = tail call double @llvm.fmuladd.f64(double %180, double %292, double %291)
store double %293, double* %287
%294 = add nuw nsw i64 %269, 1
%295 = icmp eq i64 %294, %163
br i1 %295, label %296, label %268
296: ; preds = %268, %160
ret void
}