void reconstructCameraPose(float camerapos[3], float *camerayaw,
                           float feature_pps[3][4],
                           double reconrightMatrix[4][4],
                           double intrMatrx_inv[3][3]) {
  double LiMatrix[3][4];
  double LiiMatrix[3][4];
  double scalefactor;
  int c, d, k;
  int m = 3;
  int q = 4;
  int p = 4;
  double sum = 0.0;
  for (c = 0; c < m; c++) {
    for (d = 0; d < q; d++) {
      for (k = 0; k < p; k++) {
        sum = sum + feature_pps[c][k] * reconrightMatrix[k][d];
      }
      LiMatrix[c][d] = sum;
      sum = 0;
    }
  }
  for (c = 0; c < m; c++) {
    for (d = 0; d < q; d++) {
      for (k = 0; k < m; k++) {
        sum = sum + intrMatrx_inv[c][k] * LiMatrix[k][d];
      }
      LiiMatrix[c][d] = sum;
      sum = 0;
    }
  }
  scalefactor = 1 / sqrt(pow(LiiMatrix[0][0], 2) + pow(LiiMatrix[0][1], 2));
  camerapos[0] = (float)(LiiMatrix[1][3] * scalefactor);
  camerapos[1] = (float)(-LiiMatrix[0][3] * scalefactor);
  camerapos[2] = (float)(LiiMatrix[2][3] * scalefactor);
  float cosa = (LiiMatrix[0][0]) * scalefactor;
  float sina = -(LiiMatrix[0][1]) * scalefactor;
  if (cosa > 0) {
    if (sina < 0) {
      *camerayaw = (float)(acos(cosa) - 1.571);
    } else {
      *camerayaw = (float)(-acos(cosa) - 1.571);
    };
  } else {
    if (sina < 0) {
      *camerayaw = (float)(acos(cosa) - 1.571);
    } else {
      *camerayaw = (float)(-acos(cosa) + 1.571 * 3);
    };
  };
}


x86 assembly (clang, -O0):
<reconstructCameraPose>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x3,-0x108(%rbp)
movl   $0x4,-0x10c(%rbp)
movl   $0x4,-0x110(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x108(%rbp),%eax
jge    1299 <reconstructCameraPose+0x169>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    1280 <reconstructCameraPose+0x150>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x110(%rbp),%eax
jge    1238 <reconstructCameraPose+0x108>
movsd  -0x118(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0xfc(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x104(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x104(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    11ba <reconstructCameraPose+0x8a>
movsd  -0x118(%rbp),%xmm0
ff
movslq -0xfc(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    119e <reconstructCameraPose+0x6e>
jmp    1285 <reconstructCameraPose+0x155>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1182 <reconstructCameraPose+0x52>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x108(%rbp),%eax
jge    13b9 <reconstructCameraPose+0x289>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    13a0 <reconstructCameraPose+0x270>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x108(%rbp),%eax
jge    1358 <reconstructCameraPose+0x228>
movsd  -0x118(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0xfc(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x104(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x100(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    12db <reconstructCameraPose+0x1ab>
movsd  -0x118(%rbp),%xmm0
ff
movslq -0xfc(%rbp),%rcx
lea    -0xf0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x100(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    12bf <reconstructCameraPose+0x18f>
jmp    13a5 <reconstructCameraPose+0x275>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    12a3 <reconstructCameraPose+0x173>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  0xc3f(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  0xc22(%rip),%xmm1
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xbf6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xf8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0xf8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xf8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x120(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1569 <reconstructCameraPose+0x439>
xorps  %xmm0,%xmm0
ucomiss -0x120(%rbp),%xmm0
jbe    1524 <reconstructCameraPose+0x3f4>
movss  -0x11c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <acos@plt>
movsd  0xb09(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1564 <reconstructCameraPose+0x434>
movss  -0x11c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <acos@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xac4(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    15ec <reconstructCameraPose+0x4bc>
xorps  %xmm0,%xmm0
ucomiss -0x120(%rbp),%xmm0
jbe    15a7 <reconstructCameraPose+0x477>
movss  -0x11c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <acos@plt>
movsd  0xa86(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    15e7 <reconstructCameraPose+0x4b7>
movss  -0x11c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <acos@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xa39(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    15ec <reconstructCameraPose+0x4bc>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reconstructCameraPose>:
push   %r14
push   %rbx
sub    $0xe8,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
movupd 0x40(%rcx),%xmm14
movupd 0x60(%rcx),%xmm8
movupd (%rcx),%xmm9
movupd 0x10(%rcx),%xmm2
movupd 0x20(%rcx),%xmm15
movupd 0x30(%rcx),%xmm11
movupd 0x50(%rcx),%xmm0
movapd %xmm0,0x10(%rsp)
movupd 0x70(%rcx),%xmm12
movss  (%rdx),%xmm1
movss  0x4(%rdx),%xmm3
cvtss2sd %xmm1,%xmm5
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movss  0x8(%rdx),%xmm3
cvtss2sd %xmm3,%xmm4
movss  0xc(%rdx),%xmm3
cvtss2sd %xmm3,%xmm10
movlhps %xmm5,%xmm5
movaps %xmm5,%xmm3
mulpd  %xmm9,%xmm3
xorpd  %xmm6,%xmm6
addpd  %xmm6,%xmm3
movlhps %xmm1,%xmm1
movaps %xmm1,%xmm6
mulpd  %xmm15,%xmm6
addpd  %xmm3,%xmm6
movlhps %xmm4,%xmm4
movaps %xmm4,%xmm7
mulpd  %xmm14,%xmm7
addpd  %xmm6,%xmm7
movlhps %xmm10,%xmm10
movaps %xmm10,%xmm13
mulpd  %xmm8,%xmm13
addpd  %xmm7,%xmm13
movapd %xmm13,0x80(%rsp)
movapd %xmm2,(%rsp)
mulpd  %xmm2,%xmm5
xorpd  %xmm3,%xmm3
addpd  %xmm3,%xmm5
mulpd  %xmm11,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm12,%xmm10
addpd  %xmm4,%xmm10
movapd %xmm10,0x90(%rsp)
movss  0x10(%rdx),%xmm1
movss  0x14(%rdx),%xmm4
xorps  %xmm7,%xmm7
cvtss2sd %xmm1,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm4,%xmm6
movss  0x18(%rdx),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movlhps %xmm7,%xmm7
movaps %xmm7,%xmm4
mulpd  %xmm9,%xmm4
addpd  %xmm3,%xmm4
xorpd  %xmm3,%xmm3
movlhps %xmm6,%xmm6
movaps %xmm6,%xmm5
mulpd  %xmm15,%xmm5
addpd  %xmm4,%xmm5
movlhps %xmm0,%xmm0
movaps %xmm0,%xmm1
mulpd  %xmm14,%xmm1
addpd  %xmm5,%xmm1
movss  0x1c(%rdx),%xmm4
cvtss2sd %xmm4,%xmm4
movlhps %xmm4,%xmm4
movaps %xmm4,%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm11,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm5,0xa0(%rsp)
movapd 0x10(%rsp),%xmm3
mulpd  %xmm3,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm12,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm4,0xb0(%rsp)
movss  0x20(%rdx),%xmm0
movss  0x24(%rdx),%xmm1
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
cvtss2sd %xmm1,%xmm1
movlhps %xmm6,%xmm6
mulpd  %xmm6,%xmm9
xorpd  %xmm7,%xmm7
addpd  %xmm7,%xmm9
movlhps %xmm1,%xmm1
mulpd  %xmm1,%xmm15
addpd  %xmm9,%xmm15
movss  0x28(%rdx),%xmm0
cvtss2sd %xmm0,%xmm0
movlhps %xmm0,%xmm0
mulpd  %xmm0,%xmm14
addpd  %xmm15,%xmm14
movss  0x2c(%rdx),%xmm2
xorps  %xmm15,%xmm15
cvtss2sd %xmm2,%xmm15
movlhps %xmm15,%xmm15
mulpd  %xmm15,%xmm8
addpd  %xmm14,%xmm8
mulpd  (%rsp),%xmm6
movapd %xmm8,0xc0(%rsp)
addpd  %xmm7,%xmm6
xorpd  %xmm9,%xmm9
mulpd  %xmm11,%xmm1
addpd  %xmm6,%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
mulpd  %xmm12,%xmm15
addpd  %xmm0,%xmm15
movapd %xmm15,0xd0(%rsp)
movsd  (%r8),%xmm0
movsd  0x8(%r8),%xmm2
movsd  0x10(%r8),%xmm6
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm7
mulpd  %xmm13,%xmm7
addpd  %xmm9,%xmm7
unpcklpd %xmm2,%xmm2
movapd %xmm2,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm7,%xmm1
unpcklpd %xmm6,%xmm6
movapd %xmm6,%xmm3
mulpd  %xmm8,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm3,0x20(%rsp)
mulpd  %xmm10,%xmm0
addpd  %xmm9,%xmm0
mulpd  %xmm4,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm15,%xmm6
addpd  %xmm2,%xmm6
movapd %xmm6,0x30(%rsp)
movsd  0x18(%r8),%xmm0
movsd  0x20(%r8),%xmm1
movsd  0x28(%r8),%xmm2
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm6
mulpd  %xmm13,%xmm6
addpd  %xmm9,%xmm6
unpcklpd %xmm1,%xmm1
movapd %xmm1,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
unpcklpd %xmm2,%xmm2
movapd %xmm2,%xmm6
mulpd  %xmm8,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm6,0x40(%rsp)
mulpd  %xmm10,%xmm0
xorpd  %xmm6,%xmm6
addpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm15,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x50(%rsp)
movsd  0x30(%r8),%xmm0
movsd  0x38(%r8),%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm13
addpd  %xmm6,%xmm13
xorpd  %xmm6,%xmm6
unpcklpd %xmm1,%xmm1
mulpd  %xmm1,%xmm5
addpd  %xmm13,%xmm5
movsd  0x40(%r8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm8
addpd  %xmm5,%xmm8
movapd %xmm8,0x60(%rsp)
mulpd  %xmm10,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm15,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x70(%rsp)
movapd %xmm3,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14ba <reconstructCameraPose+0x39a>
sqrtsd %xmm0,%xmm0
jmp    14c9 <reconstructCameraPose+0x3a9>
movapd %xmm3,(%rsp)
call   1040 <sqrt@plt>
movapd (%rsp),%xmm3
movsd  0xb2f(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x58(%rsp),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
movapd 0xb31(%rip),%xmm0
movsd  0x38(%rsp),%xmm2
xorpd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%rbx)
movsd  0x78(%rsp),%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x8(%rbx)
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x10(%rsp)
unpckhpd %xmm3,%xmm3
xorpd  %xmm0,%xmm3
mulsd  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
movss  %xmm0,(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
call   1030 <acos@plt>
xorpd  %xmm1,%xmm1
movss  0x10(%rsp),%xmm2
ucomiss %xmm1,%xmm2
jbe    156e <reconstructCameraPose+0x44e>
ucomiss (%rsp),%xmm1
ja     1574 <reconstructCameraPose+0x454>
movsd  0xaa4(%rip),%xmm1
jmp    1586 <reconstructCameraPose+0x466>
ucomiss (%rsp),%xmm1
jbe    157e <reconstructCameraPose+0x45e>
addsd  0xa94(%rip),%xmm0
jmp    158e <reconstructCameraPose+0x46e>
movsd  0xa82(%rip),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14)
add    $0xe8,%rsp
pop    %rbx
pop    %r14
ret

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

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