int arParamDecompMat(double source[3][4], double cpara[3][4],
                     double trans[3][4]) {
  int r, c;
  double Cpara[3][4];
  double rem1, rem2, rem3;
  if (source[2][3] >= 0) {
    for (r = 0; r < 3; r++) {
      for (c = 0; c < 4; c++) {
        Cpara[r][c] = source[r][c];
      }
    }
  } else {
    for (r = 0; r < 3; r++) {
      for (c = 0; c < 4; c++) {
        Cpara[r][c] = -(source[r][c]);
      }
    }
  }
  for (r = 0; r < 3; r++) {
    for (c = 0; c < 4; c++) {
      cpara[r][c] = 0.0;
    }
  }
  cpara[2][2] = norm(Cpara[2][0], Cpara[2][1], Cpara[2][2]);
  trans[2][0] = Cpara[2][0] / cpara[2][2];
  trans[2][1] = Cpara[2][1] / cpara[2][2];
  trans[2][2] = Cpara[2][2] / cpara[2][2];
  trans[2][3] = Cpara[2][3] / cpara[2][2];
  cpara[1][2] = dot(trans[2][0], trans[2][1], trans[2][2], Cpara[1][0],
                    Cpara[1][1], Cpara[1][2]);
  rem1 = Cpara[1][0] - cpara[1][2] * trans[2][0];
  rem2 = Cpara[1][1] - cpara[1][2] * trans[2][1];
  rem3 = Cpara[1][2] - cpara[1][2] * trans[2][2];
  cpara[1][1] = norm(rem1, rem2, rem3);
  trans[1][0] = rem1 / cpara[1][1];
  trans[1][1] = rem2 / cpara[1][1];
  trans[1][2] = rem3 / cpara[1][1];
  cpara[0][2] = dot(trans[2][0], trans[2][1], trans[2][2], Cpara[0][0],
                    Cpara[0][1], Cpara[0][2]);
  cpara[0][1] = dot(trans[1][0], trans[1][1], trans[1][2], Cpara[0][0],
                    Cpara[0][1], Cpara[0][2]);
  rem1 = Cpara[0][0] - cpara[0][1] * trans[1][0] - cpara[0][2] * trans[2][0];
  rem2 = Cpara[0][1] - cpara[0][1] * trans[1][1] - cpara[0][2] * trans[2][1];
  rem3 = Cpara[0][2] - cpara[0][1] * trans[1][2] - cpara[0][2] * trans[2][2];
  cpara[0][0] = norm(rem1, rem2, rem3);
  trans[0][0] = rem1 / cpara[0][0];
  trans[0][1] = rem2 / cpara[0][0];
  trans[0][2] = rem3 / cpara[0][0];
  trans[1][3] = (Cpara[1][3] - cpara[1][2] * trans[2][3]) / cpara[1][1];
  trans[0][3] =
      (Cpara[0][3] - cpara[0][1] * trans[1][3] - cpara[0][2] * trans[2][3]) /
      cpara[0][0];
  for (r = 0; r < 3; r++) {
    for (c = 0; c < 3; c++) {
      cpara[r][c] /= cpara[2][2];
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<arParamDecompMat>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11c5 <arParamDecompMat+0xa5>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    11c0 <arParamDecompMat+0xa0>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    11ad <arParamDecompMat+0x8d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1165 <arParamDecompMat+0x45>
jmp    11b2 <arParamDecompMat+0x92>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1154 <arParamDecompMat+0x34>
jmp    1254 <arParamDecompMat+0x134>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    124f <arParamDecompMat+0x12f>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    123c <arParamDecompMat+0x11c>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11dd <arParamDecompMat+0xbd>
jmp    1241 <arParamDecompMat+0x121>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11cc <arParamDecompMat+0xac>
jmp    1254 <arParamDecompMat+0x134>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    12b2 <arParamDecompMat+0x192>
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    129f <arParamDecompMat+0x17f>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    126c <arParamDecompMat+0x14c>
jmp    12a4 <arParamDecompMat+0x184>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    125b <arParamDecompMat+0x13b>
movsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    $0x3,%al
call   1040 <norm@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
divsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
movsd  -0x60(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm4
movsd  -0x50(%rbp),%xmm5
mov    $0x6,%al
call   1030 <dot@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
mov    $0x3,%al
call   1040 <norm@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
movsd  -0x80(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm5
mov    $0x6,%al
call   1030 <dot@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm2
movsd  -0x80(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm5
mov    $0x6,%al
call   1030 <dot@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
mov    $0x3,%al
call   1040 <norm@plt>
cvtsi2sd %eax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x48(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
divsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    180e <arParamDecompMat+0x6ee>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    17fb <arParamDecompMat+0x6db>
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    17b9 <arParamDecompMat+0x699>
jmp    1800 <arParamDecompMat+0x6e0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17a8 <arParamDecompMat+0x688>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<arParamDecompMat>:
push   %r14
push   %rbx
sub    $0xa8,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
movsd  (%rdi),%xmm2
movsd  0x58(%rdi),%xmm4
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm4
jae    11a9 <arParamDecompMat+0x89>
movapd 0xeb5(%rip),%xmm0
xorpd  %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x8(%rdi),%xmm3
movsd  0x10(%rdi),%xmm2
xorpd  %xmm0,%xmm3
movapd %xmm3,0x20(%rsp)
xorpd  %xmm0,%xmm2
movapd %xmm2,0x30(%rsp)
movupd 0x18(%rdi),%xmm2
movupd 0x28(%rdi),%xmm5
movupd 0x38(%rdi),%xmm3
movupd 0x48(%rdi),%xmm1
xorpd  %xmm0,%xmm1
xorpd  %xmm0,%xmm3
xorpd  %xmm0,%xmm5
movapd %xmm5,0x50(%rsp)
xorpd  %xmm0,%xmm2
movapd %xmm2,0x60(%rsp)
xorpd  %xmm0,%xmm4
jmp    11e1 <arParamDecompMat+0xc1>
movsd  0x8(%rdi),%xmm0
movaps %xmm0,0x20(%rsp)
movsd  0x10(%rdi),%xmm0
movaps %xmm0,0x30(%rsp)
movupd 0x48(%rdi),%xmm1
movupd 0x38(%rdi),%xmm3
movups 0x28(%rdi),%xmm0
movaps %xmm0,0x50(%rsp)
movupd 0x18(%rdi),%xmm0
movapd %xmm0,0x60(%rsp)
movapd %xmm2,0x10(%rsp)
movapd %xmm4,(%rsp)
movapd %xmm1,0x80(%rsp)
movapd %xmm3,0x90(%rsp)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x50(%rbx)
movupd %xmm0,0x40(%rbx)
movupd %xmm0,0x30(%rbx)
movupd %xmm0,0x20(%rbx)
movupd %xmm0,0x10(%rbx)
movupd %xmm0,(%rbx)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,0x70(%rsp)
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm2,0x40(%rsp)
mov    $0x3,%al
call   1040 <norm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x50(%rbx)
movapd 0x70(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%r14)
movapd %xmm1,%xmm0
movsd  0x50(%rbx),%xmm1
movapd 0x80(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,0x48(%r14)
movapd %xmm2,%xmm1
movapd 0x40(%rsp),%xmm2
divsd  0x50(%rbx),%xmm2
movsd  %xmm2,0x50(%r14)
movapd (%rsp),%xmm3
divsd  0x50(%rbx),%xmm3
movsd  %xmm3,0x58(%r14)
movaps 0x60(%rsp),%xmm3
movhlps %xmm3,%xmm3
movaps %xmm3,0x40(%rsp)
movaps 0x50(%rsp),%xmm4
movaps %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
movaps %xmm5,(%rsp)
mov    $0x6,%al
call   1030 <dot@plt>
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  %xmm3,0x30(%rbx)
movsd  0x40(%r14),%xmm1
mulsd  %xmm3,%xmm1
movapd 0x40(%rsp),%xmm0
subsd  %xmm1,%xmm0
movapd %xmm0,0x40(%rsp)
movsd  0x48(%r14),%xmm2
mulsd  %xmm3,%xmm2
movapd 0x50(%rsp),%xmm1
subsd  %xmm2,%xmm1
movapd %xmm1,0x50(%rsp)
mulsd  0x50(%r14),%xmm3
movapd (%rsp),%xmm2
subsd  %xmm3,%xmm2
movapd %xmm2,(%rsp)
mov    $0x3,%al
call   1040 <norm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rbx)
movapd 0x40(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r14)
movapd 0x50(%rsp),%xmm0
divsd  0x28(%rbx),%xmm0
movsd  %xmm0,0x28(%r14)
movapd (%rsp),%xmm0
divsd  0x28(%rbx),%xmm0
movsd  %xmm0,0x30(%r14)
movsd  0x40(%r14),%xmm0
movsd  0x48(%r14),%xmm1
movsd  0x50(%r14),%xmm2
movaps 0x10(%rsp),%xmm3
movaps 0x20(%rsp),%xmm4
movaps 0x30(%rsp),%xmm5
mov    $0x6,%al
call   1030 <dot@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x20(%r14),%xmm0
movsd  0x28(%r14),%xmm1
movsd  0x30(%r14),%xmm2
movaps 0x10(%rsp),%xmm3
movaps 0x20(%rsp),%xmm4
movaps 0x30(%rsp),%xmm5
mov    $0x6,%al
call   1030 <dot@plt>
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movsd  %xmm4,0x8(%rbx)
movsd  0x20(%r14),%xmm1
mulsd  %xmm4,%xmm1
movapd 0x10(%rsp),%xmm3
subsd  %xmm1,%xmm3
movsd  0x10(%rbx),%xmm1
movsd  0x40(%r14),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
movapd %xmm3,%xmm0
movapd %xmm3,0x10(%rsp)
movsd  0x28(%r14),%xmm2
mulsd  %xmm4,%xmm2
movapd 0x20(%rsp),%xmm3
subsd  %xmm2,%xmm3
movsd  0x48(%r14),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
movapd %xmm3,0x20(%rsp)
mulsd  0x30(%r14),%xmm4
movapd 0x30(%rsp),%xmm2
subsd  %xmm4,%xmm2
mulsd  0x50(%r14),%xmm1
subsd  %xmm1,%xmm2
movapd %xmm2,0x30(%rsp)
movapd %xmm3,%xmm1
mov    $0x3,%al
call   1040 <norm@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rbx)
movapd 0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movapd 0x20(%rsp),%xmm0
divsd  (%rbx),%xmm0
movsd  %xmm0,0x8(%r14)
movapd 0x30(%rsp),%xmm0
divsd  (%rbx),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x58(%r14),%xmm0
movsd  0x30(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movapd 0x90(%rsp),%xmm2
subsd  %xmm1,%xmm2
divsd  0x28(%rbx),%xmm2
movsd  %xmm2,0x38(%r14)
mulsd  0x8(%rbx),%xmm2
movapd 0x60(%rsp),%xmm1
subsd  %xmm2,%xmm1
mulsd  0x10(%rbx),%xmm0
subsd  %xmm0,%xmm1
divsd  (%rbx),%xmm1
movsd  %xmm1,0x18(%r14)
movsd  0x50(%rbx),%xmm0
movupd (%rbx),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,(%rbx)
movsd  0x10(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx)
movupd 0x20(%rbx),%xmm1
divpd  %xmm2,%xmm1
movupd %xmm1,0x20(%rbx)
movsd  0x30(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rbx)
movupd 0x40(%rbx),%xmm1
divpd  %xmm2,%xmm1
movupd %xmm1,0x40(%rbx)
divsd  %xmm0,%xmm0
movsd  %xmm0,0x50(%rbx)
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @arParamDecompMat([4 x double]* %0, [4 x double]* %1, [4 x double]* %2) {
%4 = alloca [4 x double]*
%5 = alloca [4 x double]*
%6 = alloca [4 x double]*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [3 x [4 x double]]
%10 = alloca double
%11 = alloca double
%12 = alloca double
store [4 x double]* %0, [4 x double]** %4
store [4 x double]* %1, [4 x double]** %5
store [4 x double]* %2, [4 x double]** %6
%13 = load [4 x double]*, [4 x double]** %4
%14 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 2
%15 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 3
%16 = load double, double* %15
%17 = fcmp oge double %16, 0.000000e+00
br i1 %17, label %18, label %49
18: ; preds = %3
store i32 0, i32* %7
br label %19
19: ; preds = %45, %18
%20 = load i32, i32* %7
%21 = icmp slt i32 %20, 3
br i1 %21, label %22, label %48
22: ; preds = %19
store i32 0, i32* %8
br label %23
23: ; preds = %41, %22
%24 = load i32, i32* %8
%25 = icmp slt i32 %24, 4
br i1 %25, label %26, label %44
26: ; preds = %23
%27 = load [4 x double]*, [4 x double]** %4
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [4 x double], [4 x double]* %27, i64 %29
%31 = load i32, i32* %8
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [4 x double], [4 x double]* %30, i64 0, i64 %32
%34 = load double, double* %33
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 %36
%38 = load i32, i32* %8
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [4 x double], [4 x double]* %37, i64 0, i64 %39
store double %34, double* %40
br label %41
41: ; preds = %26
%42 = load i32, i32* %8
%43 = add nsw i32 %42, 1
store i32 %43, i32* %8
br label %23
44: ; preds = %23
br label %45
45: ; preds = %44
%46 = load i32, i32* %7
%47 = add nsw i32 %46, 1
store i32 %47, i32* %7
br label %19
48: ; preds = %19
br label %81
49: ; preds = %3
store i32 0, i32* %7
br label %50
50: ; preds = %77, %49
%51 = load i32, i32* %7
%52 = icmp slt i32 %51, 3
br i1 %52, label %53, label %80
53: ; preds = %50
store i32 0, i32* %8
br label %54
54: ; preds = %73, %53
%55 = load i32, i32* %8
%56 = icmp slt i32 %55, 4
br i1 %56, label %57, label %76
57: ; preds = %54
%58 = load [4 x double]*, [4 x double]** %4
%59 = load i32, i32* %7
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [4 x double], [4 x double]* %58, i64 %60
%62 = load i32, i32* %8
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [4 x double], [4 x double]* %61, i64 0, i64 %63
%65 = load double, double* %64
%66 = fneg double %65
%67 = load i32, i32* %7
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 %68
%70 = load i32, i32* %8
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [4 x double], [4 x double]* %69, i64 0, i64 %71
store double %66, double* %72
br label %73
73: ; preds = %57
%74 = load i32, i32* %8
%75 = add nsw i32 %74, 1
store i32 %75, i32* %8
br label %54
76: ; preds = %54
br label %77
77: ; preds = %76
%78 = load i32, i32* %7
%79 = add nsw i32 %78, 1
store i32 %79, i32* %7
br label %50
80: ; preds = %50
br label %81
81: ; preds = %80, %48
store i32 0, i32* %7
br label %82
82: ; preds = %101, %81
%83 = load i32, i32* %7
%84 = icmp slt i32 %83, 3
br i1 %84, label %85, label %104
85: ; preds = %82
store i32 0, i32* %8
br label %86
86: ; preds = %97, %85
%87 = load i32, i32* %8
%88 = icmp slt i32 %87, 4
br i1 %88, label %89, label %100
89: ; preds = %86
%90 = load [4 x double]*, [4 x double]** %5
%91 = load i32, i32* %7
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [4 x double], [4 x double]* %90, i64 %92
%94 = load i32, i32* %8
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [4 x double], [4 x double]* %93, i64 0, i64 %95
store double 0.000000e+00, double* %96
br label %97
97: ; preds = %89
%98 = load i32, i32* %8
%99 = add nsw i32 %98, 1
store i32 %99, i32* %8
br label %86
100: ; preds = %86
br label %101
101: ; preds = %100
%102 = load i32, i32* %7
%103 = add nsw i32 %102, 1
store i32 %103, i32* %7
br label %82
104: ; preds = %82
%105 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%106 = getelementptr inbounds [4 x double], [4 x double]* %105, i64 0, i64 0
%107 = load double, double* %106
%108 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%109 = getelementptr inbounds [4 x double], [4 x double]* %108, i64 0, i64 1
%110 = load double, double* %109
%111 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%112 = getelementptr inbounds [4 x double], [4 x double]* %111, i64 0, i64 2
%113 = load double, double* %112
%114 = call i32 (double, double, double, ...) bitcast (i32 (...)* @norm to i32 (double, double, double, ...)*)(double %107, double %110, double %113)
%115 = sitofp i32 %114 to double
%116 = load [4 x double]*, [4 x double]** %5
%117 = getelementptr inbounds [4 x double], [4 x double]* %116, i64 2
%118 = getelementptr inbounds [4 x double], [4 x double]* %117, i64 0, i64 2
store double %115, double* %118
%119 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%120 = getelementptr inbounds [4 x double], [4 x double]* %119, i64 0, i64 0
%121 = load double, double* %120
%122 = load [4 x double]*, [4 x double]** %5
%123 = getelementptr inbounds [4 x double], [4 x double]* %122, i64 2
%124 = getelementptr inbounds [4 x double], [4 x double]* %123, i64 0, i64 2
%125 = load double, double* %124
%126 = fdiv double %121, %125
%127 = load [4 x double]*, [4 x double]** %6
%128 = getelementptr inbounds [4 x double], [4 x double]* %127, i64 2
%129 = getelementptr inbounds [4 x double], [4 x double]* %128, i64 0, i64 0
store double %126, double* %129
%130 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%131 = getelementptr inbounds [4 x double], [4 x double]* %130, i64 0, i64 1
%132 = load double, double* %131
%133 = load [4 x double]*, [4 x double]** %5
%134 = getelementptr inbounds [4 x double], [4 x double]* %133, i64 2
%135 = getelementptr inbounds [4 x double], [4 x double]* %134, i64 0, i64 2
%136 = load double, double* %135
%137 = fdiv double %132, %136
%138 = load [4 x double]*, [4 x double]** %6
%139 = getelementptr inbounds [4 x double], [4 x double]* %138, i64 2
%140 = getelementptr inbounds [4 x double], [4 x double]* %139, i64 0, i64 1
store double %137, double* %140
%141 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%142 = getelementptr inbounds [4 x double], [4 x double]* %141, i64 0, i64 2
%143 = load double, double* %142
%144 = load [4 x double]*, [4 x double]** %5
%145 = getelementptr inbounds [4 x double], [4 x double]* %144, i64 2
%146 = getelementptr inbounds [4 x double], [4 x double]* %145, i64 0, i64 2
%147 = load double, double* %146
%148 = fdiv double %143, %147
%149 = load [4 x double]*, [4 x double]** %6
%150 = getelementptr inbounds [4 x double], [4 x double]* %149, i64 2
%151 = getelementptr inbounds [4 x double], [4 x double]* %150, i64 0, i64 2
store double %148, double* %151
%152 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 2
%153 = getelementptr inbounds [4 x double], [4 x double]* %152, i64 0, i64 3
%154 = load double, double* %153
%155 = load [4 x double]*, [4 x double]** %5
%156 = getelementptr inbounds [4 x double], [4 x double]* %155, i64 2
%157 = getelementptr inbounds [4 x double], [4 x double]* %156, i64 0, i64 2
%158 = load double, double* %157
%159 = fdiv double %154, %158
%160 = load [4 x double]*, [4 x double]** %6
%161 = getelementptr inbounds [4 x double], [4 x double]* %160, i64 2
%162 = getelementptr inbounds [4 x double], [4 x double]* %161, i64 0, i64 3
store double %159, double* %162
%163 = load [4 x double]*, [4 x double]** %6
%164 = getelementptr inbounds [4 x double], [4 x double]* %163, i64 2
%165 = getelementptr inbounds [4 x double], [4 x double]* %164, i64 0, i64 0
%166 = load double, double* %165
%167 = load [4 x double]*, [4 x double]** %6
%168 = getelementptr inbounds [4 x double], [4 x double]* %167, i64 2
%169 = getelementptr inbounds [4 x double], [4 x double]* %168, i64 0, i64 1
%170 = load double, double* %169
%171 = load [4 x double]*, [4 x double]** %6
%172 = getelementptr inbounds [4 x double], [4 x double]* %171, i64 2
%173 = getelementptr inbounds [4 x double], [4 x double]* %172, i64 0, i64 2
%174 = load double, double* %173
%175 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%176 = getelementptr inbounds [4 x double], [4 x double]* %175, i64 0, i64 0
%177 = load double, double* %176
%178 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%179 = getelementptr inbounds [4 x double], [4 x double]* %178, i64 0, i64 1
%180 = load double, double* %179
%181 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%182 = getelementptr inbounds [4 x double], [4 x double]* %181, i64 0, i64 2
%183 = load double, double* %182
%184 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dot to i32 (double, double, double, double, double, double, ...)*)(double %166, double %170, double %174, double %177, double %180, double %183)
%185 = sitofp i32 %184 to double
%186 = load [4 x double]*, [4 x double]** %5
%187 = getelementptr inbounds [4 x double], [4 x double]* %186, i64 1
%188 = getelementptr inbounds [4 x double], [4 x double]* %187, i64 0, i64 2
store double %185, double* %188
%189 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%190 = getelementptr inbounds [4 x double], [4 x double]* %189, i64 0, i64 0
%191 = load double, double* %190
%192 = load [4 x double]*, [4 x double]** %5
%193 = getelementptr inbounds [4 x double], [4 x double]* %192, i64 1
%194 = getelementptr inbounds [4 x double], [4 x double]* %193, i64 0, i64 2
%195 = load double, double* %194
%196 = load [4 x double]*, [4 x double]** %6
%197 = getelementptr inbounds [4 x double], [4 x double]* %196, i64 2
%198 = getelementptr inbounds [4 x double], [4 x double]* %197, i64 0, i64 0
%199 = load double, double* %198
%200 = fneg double %195
%201 = call double @llvm.fmuladd.f64(double %200, double %199, double %191)
store double %201, double* %10
%202 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%203 = getelementptr inbounds [4 x double], [4 x double]* %202, i64 0, i64 1
%204 = load double, double* %203
%205 = load [4 x double]*, [4 x double]** %5
%206 = getelementptr inbounds [4 x double], [4 x double]* %205, i64 1
%207 = getelementptr inbounds [4 x double], [4 x double]* %206, i64 0, i64 2
%208 = load double, double* %207
%209 = load [4 x double]*, [4 x double]** %6
%210 = getelementptr inbounds [4 x double], [4 x double]* %209, i64 2
%211 = getelementptr inbounds [4 x double], [4 x double]* %210, i64 0, i64 1
%212 = load double, double* %211
%213 = fneg double %208
%214 = call double @llvm.fmuladd.f64(double %213, double %212, double %204)
store double %214, double* %11
%215 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%216 = getelementptr inbounds [4 x double], [4 x double]* %215, i64 0, i64 2
%217 = load double, double* %216
%218 = load [4 x double]*, [4 x double]** %5
%219 = getelementptr inbounds [4 x double], [4 x double]* %218, i64 1
%220 = getelementptr inbounds [4 x double], [4 x double]* %219, i64 0, i64 2
%221 = load double, double* %220
%222 = load [4 x double]*, [4 x double]** %6
%223 = getelementptr inbounds [4 x double], [4 x double]* %222, i64 2
%224 = getelementptr inbounds [4 x double], [4 x double]* %223, i64 0, i64 2
%225 = load double, double* %224
%226 = fneg double %221
%227 = call double @llvm.fmuladd.f64(double %226, double %225, double %217)
store double %227, double* %12
%228 = load double, double* %10
%229 = load double, double* %11
%230 = load double, double* %12
%231 = call i32 (double, double, double, ...) bitcast (i32 (...)* @norm to i32 (double, double, double, ...)*)(double %228, double %229, double %230)
%232 = sitofp i32 %231 to double
%233 = load [4 x double]*, [4 x double]** %5
%234 = getelementptr inbounds [4 x double], [4 x double]* %233, i64 1
%235 = getelementptr inbounds [4 x double], [4 x double]* %234, i64 0, i64 1
store double %232, double* %235
%236 = load double, double* %10
%237 = load [4 x double]*, [4 x double]** %5
%238 = getelementptr inbounds [4 x double], [4 x double]* %237, i64 1
%239 = getelementptr inbounds [4 x double], [4 x double]* %238, i64 0, i64 1
%240 = load double, double* %239
%241 = fdiv double %236, %240
%242 = load [4 x double]*, [4 x double]** %6
%243 = getelementptr inbounds [4 x double], [4 x double]* %242, i64 1
%244 = getelementptr inbounds [4 x double], [4 x double]* %243, i64 0, i64 0
store double %241, double* %244
%245 = load double, double* %11
%246 = load [4 x double]*, [4 x double]** %5
%247 = getelementptr inbounds [4 x double], [4 x double]* %246, i64 1
%248 = getelementptr inbounds [4 x double], [4 x double]* %247, i64 0, i64 1
%249 = load double, double* %248
%250 = fdiv double %245, %249
%251 = load [4 x double]*, [4 x double]** %6
%252 = getelementptr inbounds [4 x double], [4 x double]* %251, i64 1
%253 = getelementptr inbounds [4 x double], [4 x double]* %252, i64 0, i64 1
store double %250, double* %253
%254 = load double, double* %12
%255 = load [4 x double]*, [4 x double]** %5
%256 = getelementptr inbounds [4 x double], [4 x double]* %255, i64 1
%257 = getelementptr inbounds [4 x double], [4 x double]* %256, i64 0, i64 1
%258 = load double, double* %257
%259 = fdiv double %254, %258
%260 = load [4 x double]*, [4 x double]** %6
%261 = getelementptr inbounds [4 x double], [4 x double]* %260, i64 1
%262 = getelementptr inbounds [4 x double], [4 x double]* %261, i64 0, i64 2
store double %259, double* %262
%263 = load [4 x double]*, [4 x double]** %6
%264 = getelementptr inbounds [4 x double], [4 x double]* %263, i64 2
%265 = getelementptr inbounds [4 x double], [4 x double]* %264, i64 0, i64 0
%266 = load double, double* %265
%267 = load [4 x double]*, [4 x double]** %6
%268 = getelementptr inbounds [4 x double], [4 x double]* %267, i64 2
%269 = getelementptr inbounds [4 x double], [4 x double]* %268, i64 0, i64 1
%270 = load double, double* %269
%271 = load [4 x double]*, [4 x double]** %6
%272 = getelementptr inbounds [4 x double], [4 x double]* %271, i64 2
%273 = getelementptr inbounds [4 x double], [4 x double]* %272, i64 0, i64 2
%274 = load double, double* %273
%275 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%276 = getelementptr inbounds [4 x double], [4 x double]* %275, i64 0, i64 0
%277 = load double, double* %276
%278 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%279 = getelementptr inbounds [4 x double], [4 x double]* %278, i64 0, i64 1
%280 = load double, double* %279
%281 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%282 = getelementptr inbounds [4 x double], [4 x double]* %281, i64 0, i64 2
%283 = load double, double* %282
%284 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dot to i32 (double, double, double, double, double, double, ...)*)(double %266, double %270, double %274, double %277, double %280, double %283)
%285 = sitofp i32 %284 to double
%286 = load [4 x double]*, [4 x double]** %5
%287 = getelementptr inbounds [4 x double], [4 x double]* %286, i64 0
%288 = getelementptr inbounds [4 x double], [4 x double]* %287, i64 0, i64 2
store double %285, double* %288
%289 = load [4 x double]*, [4 x double]** %6
%290 = getelementptr inbounds [4 x double], [4 x double]* %289, i64 1
%291 = getelementptr inbounds [4 x double], [4 x double]* %290, i64 0, i64 0
%292 = load double, double* %291
%293 = load [4 x double]*, [4 x double]** %6
%294 = getelementptr inbounds [4 x double], [4 x double]* %293, i64 1
%295 = getelementptr inbounds [4 x double], [4 x double]* %294, i64 0, i64 1
%296 = load double, double* %295
%297 = load [4 x double]*, [4 x double]** %6
%298 = getelementptr inbounds [4 x double], [4 x double]* %297, i64 1
%299 = getelementptr inbounds [4 x double], [4 x double]* %298, i64 0, i64 2
%300 = load double, double* %299
%301 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%302 = getelementptr inbounds [4 x double], [4 x double]* %301, i64 0, i64 0
%303 = load double, double* %302
%304 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%305 = getelementptr inbounds [4 x double], [4 x double]* %304, i64 0, i64 1
%306 = load double, double* %305
%307 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%308 = getelementptr inbounds [4 x double], [4 x double]* %307, i64 0, i64 2
%309 = load double, double* %308
%310 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dot to i32 (double, double, double, double, double, double, ...)*)(double %292, double %296, double %300, double %303, double %306, double %309)
%311 = sitofp i32 %310 to double
%312 = load [4 x double]*, [4 x double]** %5
%313 = getelementptr inbounds [4 x double], [4 x double]* %312, i64 0
%314 = getelementptr inbounds [4 x double], [4 x double]* %313, i64 0, i64 1
store double %311, double* %314
%315 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%316 = getelementptr inbounds [4 x double], [4 x double]* %315, i64 0, i64 0
%317 = load double, double* %316
%318 = load [4 x double]*, [4 x double]** %5
%319 = getelementptr inbounds [4 x double], [4 x double]* %318, i64 0
%320 = getelementptr inbounds [4 x double], [4 x double]* %319, i64 0, i64 1
%321 = load double, double* %320
%322 = load [4 x double]*, [4 x double]** %6
%323 = getelementptr inbounds [4 x double], [4 x double]* %322, i64 1
%324 = getelementptr inbounds [4 x double], [4 x double]* %323, i64 0, i64 0
%325 = load double, double* %324
%326 = fneg double %321
%327 = call double @llvm.fmuladd.f64(double %326, double %325, double %317)
%328 = load [4 x double]*, [4 x double]** %5
%329 = getelementptr inbounds [4 x double], [4 x double]* %328, i64 0
%330 = getelementptr inbounds [4 x double], [4 x double]* %329, i64 0, i64 2
%331 = load double, double* %330
%332 = load [4 x double]*, [4 x double]** %6
%333 = getelementptr inbounds [4 x double], [4 x double]* %332, i64 2
%334 = getelementptr inbounds [4 x double], [4 x double]* %333, i64 0, i64 0
%335 = load double, double* %334
%336 = fneg double %331
%337 = call double @llvm.fmuladd.f64(double %336, double %335, double %327)
store double %337, double* %10
%338 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%339 = getelementptr inbounds [4 x double], [4 x double]* %338, i64 0, i64 1
%340 = load double, double* %339
%341 = load [4 x double]*, [4 x double]** %5
%342 = getelementptr inbounds [4 x double], [4 x double]* %341, i64 0
%343 = getelementptr inbounds [4 x double], [4 x double]* %342, i64 0, i64 1
%344 = load double, double* %343
%345 = load [4 x double]*, [4 x double]** %6
%346 = getelementptr inbounds [4 x double], [4 x double]* %345, i64 1
%347 = getelementptr inbounds [4 x double], [4 x double]* %346, i64 0, i64 1
%348 = load double, double* %347
%349 = fneg double %344
%350 = call double @llvm.fmuladd.f64(double %349, double %348, double %340)
%351 = load [4 x double]*, [4 x double]** %5
%352 = getelementptr inbounds [4 x double], [4 x double]* %351, i64 0
%353 = getelementptr inbounds [4 x double], [4 x double]* %352, i64 0, i64 2
%354 = load double, double* %353
%355 = load [4 x double]*, [4 x double]** %6
%356 = getelementptr inbounds [4 x double], [4 x double]* %355, i64 2
%357 = getelementptr inbounds [4 x double], [4 x double]* %356, i64 0, i64 1
%358 = load double, double* %357
%359 = fneg double %354
%360 = call double @llvm.fmuladd.f64(double %359, double %358, double %350)
store double %360, double* %11
%361 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%362 = getelementptr inbounds [4 x double], [4 x double]* %361, i64 0, i64 2
%363 = load double, double* %362
%364 = load [4 x double]*, [4 x double]** %5
%365 = getelementptr inbounds [4 x double], [4 x double]* %364, i64 0
%366 = getelementptr inbounds [4 x double], [4 x double]* %365, i64 0, i64 1
%367 = load double, double* %366
%368 = load [4 x double]*, [4 x double]** %6
%369 = getelementptr inbounds [4 x double], [4 x double]* %368, i64 1
%370 = getelementptr inbounds [4 x double], [4 x double]* %369, i64 0, i64 2
%371 = load double, double* %370
%372 = fneg double %367
%373 = call double @llvm.fmuladd.f64(double %372, double %371, double %363)
%374 = load [4 x double]*, [4 x double]** %5
%375 = getelementptr inbounds [4 x double], [4 x double]* %374, i64 0
%376 = getelementptr inbounds [4 x double], [4 x double]* %375, i64 0, i64 2
%377 = load double, double* %376
%378 = load [4 x double]*, [4 x double]** %6
%379 = getelementptr inbounds [4 x double], [4 x double]* %378, i64 2
%380 = getelementptr inbounds [4 x double], [4 x double]* %379, i64 0, i64 2
%381 = load double, double* %380
%382 = fneg double %377
%383 = call double @llvm.fmuladd.f64(double %382, double %381, double %373)
store double %383, double* %12
%384 = load double, double* %10
%385 = load double, double* %11
%386 = load double, double* %12
%387 = call i32 (double, double, double, ...) bitcast (i32 (...)* @norm to i32 (double, double, double, ...)*)(double %384, double %385, double %386)
%388 = sitofp i32 %387 to double
%389 = load [4 x double]*, [4 x double]** %5
%390 = getelementptr inbounds [4 x double], [4 x double]* %389, i64 0
%391 = getelementptr inbounds [4 x double], [4 x double]* %390, i64 0, i64 0
store double %388, double* %391
%392 = load double, double* %10
%393 = load [4 x double]*, [4 x double]** %5
%394 = getelementptr inbounds [4 x double], [4 x double]* %393, i64 0
%395 = getelementptr inbounds [4 x double], [4 x double]* %394, i64 0, i64 0
%396 = load double, double* %395
%397 = fdiv double %392, %396
%398 = load [4 x double]*, [4 x double]** %6
%399 = getelementptr inbounds [4 x double], [4 x double]* %398, i64 0
%400 = getelementptr inbounds [4 x double], [4 x double]* %399, i64 0, i64 0
store double %397, double* %400
%401 = load double, double* %11
%402 = load [4 x double]*, [4 x double]** %5
%403 = getelementptr inbounds [4 x double], [4 x double]* %402, i64 0
%404 = getelementptr inbounds [4 x double], [4 x double]* %403, i64 0, i64 0
%405 = load double, double* %404
%406 = fdiv double %401, %405
%407 = load [4 x double]*, [4 x double]** %6
%408 = getelementptr inbounds [4 x double], [4 x double]* %407, i64 0
%409 = getelementptr inbounds [4 x double], [4 x double]* %408, i64 0, i64 1
store double %406, double* %409
%410 = load double, double* %12
%411 = load [4 x double]*, [4 x double]** %5
%412 = getelementptr inbounds [4 x double], [4 x double]* %411, i64 0
%413 = getelementptr inbounds [4 x double], [4 x double]* %412, i64 0, i64 0
%414 = load double, double* %413
%415 = fdiv double %410, %414
%416 = load [4 x double]*, [4 x double]** %6
%417 = getelementptr inbounds [4 x double], [4 x double]* %416, i64 0
%418 = getelementptr inbounds [4 x double], [4 x double]* %417, i64 0, i64 2
store double %415, double* %418
%419 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 1
%420 = getelementptr inbounds [4 x double], [4 x double]* %419, i64 0, i64 3
%421 = load double, double* %420
%422 = load [4 x double]*, [4 x double]** %5
%423 = getelementptr inbounds [4 x double], [4 x double]* %422, i64 1
%424 = getelementptr inbounds [4 x double], [4 x double]* %423, i64 0, i64 2
%425 = load double, double* %424
%426 = load [4 x double]*, [4 x double]** %6
%427 = getelementptr inbounds [4 x double], [4 x double]* %426, i64 2
%428 = getelementptr inbounds [4 x double], [4 x double]* %427, i64 0, i64 3
%429 = load double, double* %428
%430 = fneg double %425
%431 = call double @llvm.fmuladd.f64(double %430, double %429, double %421)
%432 = load [4 x double]*, [4 x double]** %5
%433 = getelementptr inbounds [4 x double], [4 x double]* %432, i64 1
%434 = getelementptr inbounds [4 x double], [4 x double]* %433, i64 0, i64 1
%435 = load double, double* %434
%436 = fdiv double %431, %435
%437 = load [4 x double]*, [4 x double]** %6
%438 = getelementptr inbounds [4 x double], [4 x double]* %437, i64 1
%439 = getelementptr inbounds [4 x double], [4 x double]* %438, i64 0, i64 3
store double %436, double* %439
%440 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %9, i64 0, i64 0
%441 = getelementptr inbounds [4 x double], [4 x double]* %440, i64 0, i64 3
%442 = load double, double* %441
%443 = load [4 x double]*, [4 x double]** %5
%444 = getelementptr inbounds [4 x double], [4 x double]* %443, i64 0
%445 = getelementptr inbounds [4 x double], [4 x double]* %444, i64 0, i64 1
%446 = load double, double* %445
%447 = load [4 x double]*, [4 x double]** %6
%448 = getelementptr inbounds [4 x double], [4 x double]* %447, i64 1
%449 = getelementptr inbounds [4 x double], [4 x double]* %448, i64 0, i64 3
%450 = load double, double* %449
%451 = fneg double %446
%452 = call double @llvm.fmuladd.f64(double %451, double %450, double %442)
%453 = load [4 x double]*, [4 x double]** %5
%454 = getelementptr inbounds [4 x double], [4 x double]* %453, i64 0
%455 = getelementptr inbounds [4 x double], [4 x double]* %454, i64 0, i64 2
%456 = load double, double* %455
%457 = load [4 x double]*, [4 x double]** %6
%458 = getelementptr inbounds [4 x double], [4 x double]* %457, i64 2
%459 = getelementptr inbounds [4 x double], [4 x double]* %458, i64 0, i64 3
%460 = load double, double* %459
%461 = fneg double %456
%462 = call double @llvm.fmuladd.f64(double %461, double %460, double %452)
%463 = load [4 x double]*, [4 x double]** %5
%464 = getelementptr inbounds [4 x double], [4 x double]* %463, i64 0
%465 = getelementptr inbounds [4 x double], [4 x double]* %464, i64 0, i64 0
%466 = load double, double* %465
%467 = fdiv double %462, %466
%468 = load [4 x double]*, [4 x double]** %6
%469 = getelementptr inbounds [4 x double], [4 x double]* %468, i64 0
%470 = getelementptr inbounds [4 x double], [4 x double]* %469, i64 0, i64 3
store double %467, double* %470
store i32 0, i32* %7
br label %471
471: ; preds = %496, %104
%472 = load i32, i32* %7
%473 = icmp slt i32 %472, 3
br i1 %473, label %474, label %499
474: ; preds = %471
store i32 0, i32* %8
br label %475
475: ; preds = %492, %474
%476 = load i32, i32* %8
%477 = icmp slt i32 %476, 3
br i1 %477, label %478, label %495
478: ; preds = %475
%479 = load [4 x double]*, [4 x double]** %5
%480 = getelementptr inbounds [4 x double], [4 x double]* %479, i64 2
%481 = getelementptr inbounds [4 x double], [4 x double]* %480, i64 0, i64 2
%482 = load double, double* %481
%483 = load [4 x double]*, [4 x double]** %5
%484 = load i32, i32* %7
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds [4 x double], [4 x double]* %483, i64 %485
%487 = load i32, i32* %8
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [4 x double], [4 x double]* %486, i64 0, i64 %488
%490 = load double, double* %489
%491 = fdiv double %490, %482
store double %491, double* %489
br label %492
492: ; preds = %478
%493 = load i32, i32* %8
%494 = add nsw i32 %493, 1
store i32 %494, i32* %8
br label %475
495: ; preds = %475
br label %496
496: ; preds = %495
%497 = load i32, i32* %7
%498 = add nsw i32 %497, 1
store i32 %498, i32* %7
br label %471
499: ; preds = %471
ret i32 0
}

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