#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double const);
double sin(double const);
void rpy_to_quat_cov(const double rpy[3], double quat[4],
                     const double cov_rpy[6][6], double cov_quat[7][7]) {
  double J[7][6] = {0};
  double c_r = cos(rpy[0] / 2);
  double c_p = cos(rpy[1] / 2);
  double c_y = cos(rpy[2] / 2);
  double s_r = sin(rpy[0] / 2);
  double s_p = sin(rpy[1] / 2);
  double s_y = sin(rpy[2] / 2);
  double ccc = c_r * c_p * c_y;
  double sss = s_r * s_p * s_y;
  double ccs = c_r * c_p * s_y;
  double csc = c_r * s_p * c_y;
  double scc = s_r * c_p * c_y;
  double ssc = s_r * s_p * c_y;
  double scs = s_r * c_p * s_y;
  double css = c_r * s_p * s_y;
  J[0][0] = 1;
  J[1][1] = 1;
  J[2][2] = 1;
  J[3][3] = (ssc - ccs) / 2;
  J[3][4] = (scs - csc) / 2;
  J[3][5] = (css - scc) / 2;
  J[4][3] = -(csc + scs) / 2;
  J[4][4] = -(ssc + ccs) / 2;
  J[4][5] = (ccc + sss) / 2;
  J[5][3] = (scc - css) / 2;
  J[5][4] = (ccc - sss) / 2;
  J[5][5] = (ccs - ssc) / 2;
  J[6][3] = (ccc + sss) / 2;
  J[6][4] = -(css + scc) / 2;
  J[6][5] = -(csc + scs) / 2;
  double tmp[7][6] = {0};
  for (int i = 0; i < 7; i++) {
    for (int j = 0; j < 6; j++) {
      for (int k = 0; k < 6; k++) {
        tmp[i][j] += J[i][k] * cov_rpy[k][j];
      }
    }
  }
  for (int i = 0; i < 7; i++) {
    for (int j = 0; j < 7; j++) {
      for (int k = 0; k < 6; k++) {
        cov_quat[i][j] += tmp[i][k] * J[j][k];
      }
    }
  }
}


x86 assembly (clang, -O0):
<rpy_to_quat_cov>:
push   %rbp
mov    %rsp,%rbp
sub    $0x350,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
lea    -0x170(%rbp),%rdi
xor    %esi,%esi
mov    $0x150,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xe92(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  0xe70(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xe4e(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xe2d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  0xe0b(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xde9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
mulsd  -0x198(%rbp),%xmm0
ff
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x198(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
mulsd  -0x198(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x198(%rbp),%xmm0
ff
mulsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  0xcd8(%rip),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  0xcc8(%rip),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0xcb8(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
subsd  -0x1b8(%rbp),%xmm0
ff
movsd  0xc90(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
subsd  -0x1c0(%rbp),%xmm0
ff
movsd  0xc6c(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
subsd  -0x1c8(%rbp),%xmm0
ff
movsd  0xc48(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
addsd  -0x1d8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xc0d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
addsd  -0x1b8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xbd2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
addsd  -0x1b0(%rbp),%xmm0
ff
movsd  0xbae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
subsd  -0x1e0(%rbp),%xmm0
ff
movsd  0xb8a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x1a8(%rbp),%xmm0
ff
subsd  -0x1b0(%rbp),%xmm0
ff
movsd  0xb69(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x1b8(%rbp),%xmm0
ff
subsd  -0x1d0(%rbp),%xmm0
ff
movsd  0xb48(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x1a8(%rbp),%xmm0
ff
addsd  -0x1b0(%rbp),%xmm0
ff
movsd  0xb27(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x1e0(%rbp),%xmm0
ff
addsd  -0x1c8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xaef(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x1c0(%rbp),%xmm0
ff
addsd  -0x1d8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xab7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    -0x330(%rbp),%rdi
xor    %esi,%esi
mov    $0x150,%edx
call   1030 <memset@plt>
movl   $0x0,-0x334(%rbp)
cmpl   $0x7,-0x334(%rbp)
jge    165d <rpy_to_quat_cov+0x52d>
movl   $0x0,-0x338(%rbp)
cmpl   $0x6,-0x338(%rbp)
jge    1644 <rpy_to_quat_cov+0x514>
movl   $0x0,-0x33c(%rbp)
cmpl   $0x6,-0x33c(%rbp)
jge    162b <rpy_to_quat_cov+0x4fb>
movslq -0x334(%rbp),%rcx
lea    -0x170(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x33c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x33c(%rbp),%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x338(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x334(%rbp),%rcx
lea    -0x330(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x338(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x33c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33c(%rbp)
jmp    159d <rpy_to_quat_cov+0x46d>
jmp    1630 <rpy_to_quat_cov+0x500>
mov    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x338(%rbp)
jmp    1586 <rpy_to_quat_cov+0x456>
jmp    1649 <rpy_to_quat_cov+0x519>
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    156f <rpy_to_quat_cov+0x43f>
movl   $0x0,-0x340(%rbp)
cmpl   $0x7,-0x340(%rbp)
jge    1755 <rpy_to_quat_cov+0x625>
movl   $0x0,-0x344(%rbp)
cmpl   $0x7,-0x344(%rbp)
jge    173c <rpy_to_quat_cov+0x60c>
movl   $0x0,-0x348(%rbp)
cmpl   $0x6,-0x348(%rbp)
jge    1723 <rpy_to_quat_cov+0x5f3>
movslq -0x340(%rbp),%rcx
lea    -0x330(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x348(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x344(%rbp),%rcx
lea    -0x170(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x348(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x340(%rbp),%rcx
imul   $0x38,%rcx,%rcx
add    %rcx,%rax
movslq -0x344(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x348(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x348(%rbp)
jmp    1695 <rpy_to_quat_cov+0x565>
jmp    1728 <rpy_to_quat_cov+0x5f8>
mov    -0x344(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x344(%rbp)
jmp    167e <rpy_to_quat_cov+0x54e>
jmp    1741 <rpy_to_quat_cov+0x611>
mov    -0x340(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x340(%rbp)
jmp    1667 <rpy_to_quat_cov+0x537>
add    $0x350,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rpy_to_quat_cov>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x358,%rsp
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rdi,%r15
lea    0xb0(%rsp),%rdi
xor    %r12d,%r12d
mov    $0x140,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movsd  (%r15),%xmm0
mulsd  0xe95(%rip),%xmm0
call   1050 <cos@plt>
movapd %xmm0,0x30(%rsp)
movsd  0x8(%r15),%xmm0
mulsd  0xe7c(%rip),%xmm0
call   1050 <cos@plt>
movapd %xmm0,0x40(%rsp)
movsd  0x10(%r15),%xmm0
mulsd  0xe63(%rip),%xmm0
call   1050 <cos@plt>
movapd %xmm0,0x20(%rsp)
movsd  (%r15),%xmm0
mulsd  0xe4b(%rip),%xmm0
call   1040 <sin@plt>
movapd %xmm0,0x10(%rsp)
movsd  0x8(%r15),%xmm0
mulsd  0xe32(%rip),%xmm0
call   1040 <sin@plt>
movapd %xmm0,(%rsp)
movsd  0x10(%r15),%xmm0
mulsd  0xe1a(%rip),%xmm0
call   1040 <sin@plt>
movapd 0x30(%rsp),%xmm2
movapd %xmm2,%xmm1
movapd 0x10(%rsp),%xmm3
unpcklpd %xmm3,%xmm1
movapd (%rsp),%xmm5
unpcklpd %xmm5,%xmm5
mulpd  %xmm1,%xmm5
unpcklpd %xmm2,%xmm3
movapd 0x40(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movapd %xmm1,%xmm3
movapd 0x20(%rsp),%xmm4
shufpd $0x1,%xmm4,%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm5,%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm4,%xmm2
unpcklpd %xmm4,%xmm2
mulpd  %xmm3,%xmm2
unpcklpd %xmm3,%xmm4
movapd %xmm5,%xmm3
shufpd $0x1,%xmm0,%xmm3
mulpd  %xmm4,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm5,%xmm0
movabs $0x3ff0000000000000,%rax
mov    %rax,0xb0(%rsp)
mov    %rax,0xe8(%rsp)
mov    %rax,0x120(%rsp)
movapd %xmm3,%xmm4
subpd  %xmm1,%xmm4
movapd 0xd7c(%rip),%xmm5
mulpd  %xmm5,%xmm4
movupd %xmm4,0x158(%rsp)
movapd %xmm0,%xmm4
subsd  %xmm2,%xmm4
movsd  0xd4f(%rip),%xmm7
mulsd  %xmm7,%xmm4
movapd %xmm3,%xmm6
addpd  %xmm1,%xmm6
mulpd  0xd5b(%rip),%xmm6
movsd  %xmm4,0x168(%rsp)
movapd %xmm6,%xmm4
shufpd $0x1,%xmm6,%xmm4
movupd %xmm4,0x188(%rsp)
movapd %xmm2,%xmm4
addpd  %xmm0,%xmm4
mulpd  0xd40(%rip),%xmm4
movhpd %xmm4,0x198(%rsp)
subpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm2
movupd %xmm2,0x1b8(%rsp)
subsd  %xmm3,%xmm1
mulsd  %xmm7,%xmm1
movsd  %xmm1,0x1c8(%rsp)
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,0x1e8(%rsp)
movhpd %xmm6,0x1f8(%rsp)
lea    0x200(%rsp),%rdi
mov    $0x150,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movups (%r14),%xmm0
movaps %xmm0,0x40(%rsp)
movups 0x10(%r14),%xmm0
movaps %xmm0,0x30(%rsp)
movups 0x20(%r14),%xmm0
movaps %xmm0,0x20(%rsp)
movups 0x30(%r14),%xmm0
movaps %xmm0,0x10(%rsp)
movups 0x60(%r14),%xmm0
movaps %xmm0,(%rsp)
movups 0x90(%r14),%xmm0
movaps %xmm0,0xa0(%rsp)
movups 0xc0(%r14),%xmm0
movaps %xmm0,0x90(%rsp)
movups 0xf0(%r14),%xmm0
movaps %xmm0,0x80(%rsp)
movups 0x40(%r14),%xmm0
movaps %xmm0,0x70(%rsp)
movups 0x70(%r14),%xmm0
movaps %xmm0,0x60(%rsp)
movups 0xa0(%r14),%xmm0
movaps %xmm0,0x50(%rsp)
movupd 0xd0(%r14),%xmm3
movupd 0x100(%r14),%xmm4
movupd 0x50(%r14),%xmm5
movupd 0x80(%r14),%xmm6
movupd 0xb0(%r14),%xmm7
movupd 0xe0(%r14),%xmm8
movupd 0x110(%r14),%xmm9
movsd  0xbfd(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm10
unpcklpd %xmm0,%xmm10
movapd %xmm10,%xmm1
mulpd  0x40(%rsp),%xmm1
addpd  0x200(%rsp,%r12,1),%xmm1
movsd  0xb8(%rsp,%r12,1),%xmm14
movsd  0xc0(%rsp,%r12,1),%xmm13
movsd  0xc8(%rsp,%r12,1),%xmm12
movsd  0xd0(%rsp,%r12,1),%xmm11
unpcklpd %xmm14,%xmm14
movapd %xmm14,%xmm2
mulpd  0x10(%rsp),%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm13,%xmm13
movapd %xmm13,%xmm1
mulpd  (%rsp),%xmm1
addpd  %xmm2,%xmm1
unpcklpd %xmm12,%xmm12
movapd %xmm12,%xmm2
mulpd  0xa0(%rsp),%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm11,%xmm11
movapd %xmm11,%xmm1
mulpd  0x90(%rsp),%xmm1
addpd  %xmm2,%xmm1
movsd  0xd8(%rsp,%r12,1),%xmm15
unpcklpd %xmm15,%xmm15
movapd %xmm15,%xmm2
mulpd  0x80(%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x200(%rsp,%r12,1)
mulpd  0x30(%rsp),%xmm10
addpd  0x210(%rsp,%r12,1),%xmm10
movapd %xmm14,%xmm1
mulpd  0x70(%rsp),%xmm1
addpd  %xmm10,%xmm1
movapd %xmm13,%xmm2
mulpd  0x60(%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm12,%xmm1
mulpd  0x50(%rsp),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm11,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm15,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movhpd 0xb0(%rsp,%r12,1),%xmm0
movapd %xmm1,0x210(%rsp,%r12,1)
mulpd  0x20(%rsp),%xmm0
addpd  0x220(%rsp,%r12,1),%xmm0
mulpd  %xmm5,%xmm14
addpd  %xmm0,%xmm14
mulpd  %xmm6,%xmm13
addpd  %xmm14,%xmm13
mulpd  %xmm7,%xmm12
addpd  %xmm13,%xmm12
mulpd  %xmm8,%xmm11
addpd  %xmm12,%xmm11
mulpd  %xmm9,%xmm15
addpd  %xmm11,%xmm15
movapd %xmm15,0x220(%rsp,%r12,1)
cmp    $0x120,%r12
je     15ac <rpy_to_quat_cov+0x47c>
movsd  0xe0(%rsp,%r12,1),%xmm0
add    $0x30,%r12
jmp    1410 <rpy_to_quat_cov+0x2e0>
lea    0xd8(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%rcx,2),%rdx
shl    $0x4,%rdx
movsd  0x200(%rsp,%rdx,1),%xmm0
movsd  0x208(%rsp,%rdx,1),%xmm1
movsd  0x210(%rsp,%rdx,1),%xmm2
movsd  0x218(%rsp,%rdx,1),%xmm3
movsd  0x220(%rsp,%rdx,1),%xmm4
movsd  0x228(%rsp,%rdx,1),%xmm5
mov    %rax,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x28(%rdx),%xmm6
mulsd  %xmm0,%xmm6
addsd  (%rbx,%rsi,8),%xmm6
movsd  -0x20(%rdx),%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm6,%xmm7
movsd  -0x18(%rdx),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm7,%xmm6
movsd  -0x10(%rdx),%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
movsd  -0x8(%rdx),%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm7,%xmm6
movsd  (%rdx),%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm6,%xmm7
movsd  %xmm7,(%rbx,%rsi,8)
add    $0x1,%rsi
add    $0x30,%rdx
cmp    $0x7,%rsi
jne    1610 <rpy_to_quat_cov+0x4e0>
add    $0x1,%rcx
add    $0x38,%rbx
cmp    $0x7,%rcx
jne    15c0 <rpy_to_quat_cov+0x490>
add    $0x358,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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