void mul4(double *Out, const double A[4][4], const double B[4][4]) {
  unsigned n;
  double Res[16];
  Res[0] = A[0][0] * B[0][0] + A[0][1] * B[1][0] + A[0][2] * B[2][0] +
           A[0][3] * B[3][0];
  Res[1] = A[0][0] * B[0][1] + A[0][1] * B[1][1] + A[0][2] * B[2][1] +
           A[0][3] * B[3][1];
  Res[2] = A[0][0] * B[0][2] + A[0][1] * B[1][2] + A[0][2] * B[2][2] +
           A[0][3] * B[3][2];
  Res[3] = A[0][0] * B[0][3] + A[0][1] * B[1][3] + A[0][2] * B[2][3] +
           A[0][3] * B[3][3];
  Res[4] = A[1][0] * B[0][0] + A[1][1] * B[1][0] + A[1][2] * B[2][0] +
           A[1][3] * B[3][0];
  Res[5] = A[1][0] * B[0][1] + A[1][1] * B[1][1] + A[1][2] * B[2][1] +
           A[1][3] * B[3][1];
  Res[6] = A[1][0] * B[0][2] + A[1][1] * B[1][2] + A[1][2] * B[2][2] +
           A[1][3] * B[3][2];
  Res[7] = A[1][0] * B[0][3] + A[1][1] * B[1][3] + A[1][2] * B[2][3] +
           A[1][3] * B[3][3];
  Res[8] = A[2][0] * B[0][0] + A[2][1] * B[1][0] + A[2][2] * B[2][0] +
           A[2][3] * B[3][0];
  Res[9] = A[2][0] * B[0][1] + A[2][1] * B[1][1] + A[2][2] * B[2][1] +
           A[2][3] * B[3][1];
  Res[10] = A[2][0] * B[0][2] + A[2][1] * B[1][2] + A[2][2] * B[2][2] +
            A[2][3] * B[3][2];
  Res[11] = A[2][0] * B[0][3] + A[2][1] * B[1][3] + A[2][2] * B[2][3] +
            A[2][3] * B[3][3];
  Res[12] = A[3][0] * B[0][0] + A[3][1] * B[1][0] + A[3][2] * B[2][0] +
            A[3][3] * B[3][0];
  Res[13] = A[3][0] * B[0][1] + A[3][1] * B[1][1] + A[3][2] * B[2][1] +
            A[3][3] * B[3][1];
  Res[14] = A[3][0] * B[0][2] + A[3][1] * B[1][2] + A[3][2] * B[2][2] +
            A[3][3] * B[3][2];
  Res[15] = A[3][0] * B[0][3] + A[3][1] * B[1][3] + A[3][2] * B[2][3] +
            A[3][3] * B[3][3];
  for (n = 0; n < 16; ++n)
    Out[n] = Res[n];
}


x86 assembly (clang, -O0):
<mul4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x60(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x68(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x70(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x78(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x60(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x68(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x70(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x78(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x60(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x68(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x70(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x78(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x60(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x68(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x70(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x78(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x10,-0x1c(%rbp)
jae    179f <mul4+0x69f>
mov    -0x1c(%rbp),%eax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    176f <mul4+0x66f>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mul4>:
movsd  (%rsi),%xmm3
movsd  0x8(%rsi),%xmm4
movsd  0x10(%rsi),%xmm0
movsd  0x18(%rsi),%xmm14
unpcklpd %xmm4,%xmm4
movupd (%rdx),%xmm11
movupd 0x10(%rdx),%xmm9
movupd 0x20(%rdx),%xmm13
movupd 0x30(%rdx),%xmm6
movapd %xmm4,%xmm2
mulpd  %xmm13,%xmm2
unpcklpd %xmm3,%xmm3
movapd %xmm3,%xmm7
mulpd  %xmm11,%xmm7
addpd  %xmm2,%xmm7
movupd 0x40(%rdx),%xmm10
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm7,%xmm1
movupd 0x60(%rdx),%xmm15
unpcklpd %xmm14,%xmm14
movapd %xmm14,%xmm2
mulpd  %xmm15,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,-0x18(%rsp)
mulpd  %xmm6,%xmm4
mulpd  %xmm9,%xmm3
movapd %xmm9,%xmm5
movapd %xmm9,-0x38(%rsp)
addpd  %xmm4,%xmm3
movupd 0x50(%rdx),%xmm8
mulpd  %xmm8,%xmm0
addpd  %xmm3,%xmm0
movupd 0x70(%rdx),%xmm9
mulpd  %xmm9,%xmm14
addpd  %xmm0,%xmm14
movsd  0x28(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm13,%xmm1
mulpd  %xmm0,%xmm1
movsd  0x20(%rsi),%xmm4
unpcklpd %xmm4,%xmm4
movapd %xmm4,%xmm3
mulpd  %xmm11,%xmm3
addpd  %xmm1,%xmm3
movsd  0x30(%rsi),%xmm7
unpcklpd %xmm7,%xmm7
movapd %xmm7,%xmm2
mulpd  %xmm10,%xmm2
addpd  %xmm3,%xmm2
movsd  0x38(%rsi),%xmm3
unpcklpd %xmm3,%xmm3
movapd %xmm3,%xmm12
mulpd  %xmm15,%xmm12
addpd  %xmm2,%xmm12
movapd %xmm6,-0x28(%rsp)
mulpd  %xmm6,%xmm0
mulpd  %xmm5,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm8,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm9,%xmm3
addpd  %xmm7,%xmm3
movsd  0x48(%rsi),%xmm2
unpcklpd %xmm2,%xmm2
movapd %xmm13,%xmm0
mulpd  %xmm2,%xmm0
movsd  0x40(%rsi),%xmm7
unpcklpd %xmm7,%xmm7
movapd %xmm7,%xmm4
mulpd  %xmm11,%xmm4
addpd  %xmm0,%xmm4
movsd  0x50(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm4,%xmm1
movsd  0x58(%rsi),%xmm4
unpcklpd %xmm4,%xmm4
movapd %xmm4,%xmm5
mulpd  %xmm15,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm6,%xmm2
movapd -0x38(%rsp),%xmm6
mulpd  %xmm6,%xmm7
addpd  %xmm2,%xmm7
mulpd  %xmm8,%xmm0
addpd  %xmm7,%xmm0
mulpd  %xmm9,%xmm4
addpd  %xmm0,%xmm4
movsd  0x68(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm13
movsd  0x60(%rsi),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm1,%xmm11
addpd  %xmm13,%xmm11
movsd  0x70(%rsi),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm10
addpd  %xmm11,%xmm10
movsd  0x78(%rsi),%xmm7
unpcklpd %xmm7,%xmm7
mulpd  %xmm7,%xmm15
addpd  %xmm10,%xmm15
mulpd  -0x28(%rsp),%xmm0
mulpd  %xmm6,%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm8,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm9,%xmm7
addpd  %xmm2,%xmm7
movaps -0x18(%rsp),%xmm0
movups %xmm0,(%rdi)
movupd %xmm14,0x10(%rdi)
movupd %xmm12,0x20(%rdi)
movupd %xmm3,0x30(%rdi)
movupd %xmm5,0x40(%rdi)
movupd %xmm4,0x50(%rdi)
movupd %xmm15,0x60(%rdi)
movupd %xmm7,0x70(%rdi)
ret

LLVM IR (-O0):
define void @mul4(double* %0, [4 x double]* %1, [4 x double]* %2) {
%4 = alloca double*
%5 = alloca [4 x double]*
%6 = alloca [4 x double]*
%7 = alloca i32
%8 = alloca [16 x double]
store double* %0, double** %4
store [4 x double]* %1, [4 x double]** %5
store [4 x double]* %2, [4 x double]** %6
%9 = load [4 x double]*, [4 x double]** %5
%10 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0
%11 = getelementptr inbounds [4 x double], [4 x double]* %10, i64 0, i64 0
%12 = load double, double* %11
%13 = load [4 x double]*, [4 x double]** %6
%14 = getelementptr inbounds [4 x double], [4 x double]* %13, i64 0
%15 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 0
%16 = load double, double* %15
%17 = load [4 x double]*, [4 x double]** %5
%18 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0
%19 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 1
%20 = load double, double* %19
%21 = load [4 x double]*, [4 x double]** %6
%22 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 1
%23 = getelementptr inbounds [4 x double], [4 x double]* %22, i64 0, i64 0
%24 = load double, double* %23
%25 = fmul double %20, %24
%26 = call double @llvm.fmuladd.f64(double %12, double %16, double %25)
%27 = load [4 x double]*, [4 x double]** %5
%28 = getelementptr inbounds [4 x double], [4 x double]* %27, i64 0
%29 = getelementptr inbounds [4 x double], [4 x double]* %28, i64 0, i64 2
%30 = load double, double* %29
%31 = load [4 x double]*, [4 x double]** %6
%32 = getelementptr inbounds [4 x double], [4 x double]* %31, i64 2
%33 = getelementptr inbounds [4 x double], [4 x double]* %32, i64 0, i64 0
%34 = load double, double* %33
%35 = call double @llvm.fmuladd.f64(double %30, double %34, double %26)
%36 = load [4 x double]*, [4 x double]** %5
%37 = getelementptr inbounds [4 x double], [4 x double]* %36, i64 0
%38 = getelementptr inbounds [4 x double], [4 x double]* %37, i64 0, i64 3
%39 = load double, double* %38
%40 = load [4 x double]*, [4 x double]** %6
%41 = getelementptr inbounds [4 x double], [4 x double]* %40, i64 3
%42 = getelementptr inbounds [4 x double], [4 x double]* %41, i64 0, i64 0
%43 = load double, double* %42
%44 = call double @llvm.fmuladd.f64(double %39, double %43, double %35)
%45 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 0
store double %44, double* %45
%46 = load [4 x double]*, [4 x double]** %5
%47 = getelementptr inbounds [4 x double], [4 x double]* %46, i64 0
%48 = getelementptr inbounds [4 x double], [4 x double]* %47, i64 0, i64 0
%49 = load double, double* %48
%50 = load [4 x double]*, [4 x double]** %6
%51 = getelementptr inbounds [4 x double], [4 x double]* %50, i64 0
%52 = getelementptr inbounds [4 x double], [4 x double]* %51, i64 0, i64 1
%53 = load double, double* %52
%54 = load [4 x double]*, [4 x double]** %5
%55 = getelementptr inbounds [4 x double], [4 x double]* %54, i64 0
%56 = getelementptr inbounds [4 x double], [4 x double]* %55, i64 0, i64 1
%57 = load double, double* %56
%58 = load [4 x double]*, [4 x double]** %6
%59 = getelementptr inbounds [4 x double], [4 x double]* %58, i64 1
%60 = getelementptr inbounds [4 x double], [4 x double]* %59, i64 0, i64 1
%61 = load double, double* %60
%62 = fmul double %57, %61
%63 = call double @llvm.fmuladd.f64(double %49, double %53, double %62)
%64 = load [4 x double]*, [4 x double]** %5
%65 = getelementptr inbounds [4 x double], [4 x double]* %64, i64 0
%66 = getelementptr inbounds [4 x double], [4 x double]* %65, i64 0, i64 2
%67 = load double, double* %66
%68 = load [4 x double]*, [4 x double]** %6
%69 = getelementptr inbounds [4 x double], [4 x double]* %68, i64 2
%70 = getelementptr inbounds [4 x double], [4 x double]* %69, i64 0, i64 1
%71 = load double, double* %70
%72 = call double @llvm.fmuladd.f64(double %67, double %71, double %63)
%73 = load [4 x double]*, [4 x double]** %5
%74 = getelementptr inbounds [4 x double], [4 x double]* %73, i64 0
%75 = getelementptr inbounds [4 x double], [4 x double]* %74, i64 0, i64 3
%76 = load double, double* %75
%77 = load [4 x double]*, [4 x double]** %6
%78 = getelementptr inbounds [4 x double], [4 x double]* %77, i64 3
%79 = getelementptr inbounds [4 x double], [4 x double]* %78, i64 0, i64 1
%80 = load double, double* %79
%81 = call double @llvm.fmuladd.f64(double %76, double %80, double %72)
%82 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 1
store double %81, double* %82
%83 = load [4 x double]*, [4 x double]** %5
%84 = getelementptr inbounds [4 x double], [4 x double]* %83, i64 0
%85 = getelementptr inbounds [4 x double], [4 x double]* %84, i64 0, i64 0
%86 = load double, double* %85
%87 = load [4 x double]*, [4 x double]** %6
%88 = getelementptr inbounds [4 x double], [4 x double]* %87, i64 0
%89 = getelementptr inbounds [4 x double], [4 x double]* %88, i64 0, i64 2
%90 = load double, double* %89
%91 = load [4 x double]*, [4 x double]** %5
%92 = getelementptr inbounds [4 x double], [4 x double]* %91, i64 0
%93 = getelementptr inbounds [4 x double], [4 x double]* %92, i64 0, i64 1
%94 = load double, double* %93
%95 = load [4 x double]*, [4 x double]** %6
%96 = getelementptr inbounds [4 x double], [4 x double]* %95, i64 1
%97 = getelementptr inbounds [4 x double], [4 x double]* %96, i64 0, i64 2
%98 = load double, double* %97
%99 = fmul double %94, %98
%100 = call double @llvm.fmuladd.f64(double %86, double %90, double %99)
%101 = load [4 x double]*, [4 x double]** %5
%102 = getelementptr inbounds [4 x double], [4 x double]* %101, i64 0
%103 = getelementptr inbounds [4 x double], [4 x double]* %102, i64 0, i64 2
%104 = load double, double* %103
%105 = load [4 x double]*, [4 x double]** %6
%106 = getelementptr inbounds [4 x double], [4 x double]* %105, i64 2
%107 = getelementptr inbounds [4 x double], [4 x double]* %106, i64 0, i64 2
%108 = load double, double* %107
%109 = call double @llvm.fmuladd.f64(double %104, double %108, double %100)
%110 = load [4 x double]*, [4 x double]** %5
%111 = getelementptr inbounds [4 x double], [4 x double]* %110, i64 0
%112 = getelementptr inbounds [4 x double], [4 x double]* %111, i64 0, i64 3
%113 = load double, double* %112
%114 = load [4 x double]*, [4 x double]** %6
%115 = getelementptr inbounds [4 x double], [4 x double]* %114, i64 3
%116 = getelementptr inbounds [4 x double], [4 x double]* %115, i64 0, i64 2
%117 = load double, double* %116
%118 = call double @llvm.fmuladd.f64(double %113, double %117, double %109)
%119 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 2
store double %118, double* %119
%120 = load [4 x double]*, [4 x double]** %5
%121 = getelementptr inbounds [4 x double], [4 x double]* %120, i64 0
%122 = getelementptr inbounds [4 x double], [4 x double]* %121, i64 0, i64 0
%123 = load double, double* %122
%124 = load [4 x double]*, [4 x double]** %6
%125 = getelementptr inbounds [4 x double], [4 x double]* %124, i64 0
%126 = getelementptr inbounds [4 x double], [4 x double]* %125, i64 0, i64 3
%127 = load double, double* %126
%128 = load [4 x double]*, [4 x double]** %5
%129 = getelementptr inbounds [4 x double], [4 x double]* %128, i64 0
%130 = getelementptr inbounds [4 x double], [4 x double]* %129, i64 0, i64 1
%131 = load double, double* %130
%132 = load [4 x double]*, [4 x double]** %6
%133 = getelementptr inbounds [4 x double], [4 x double]* %132, i64 1
%134 = getelementptr inbounds [4 x double], [4 x double]* %133, i64 0, i64 3
%135 = load double, double* %134
%136 = fmul double %131, %135
%137 = call double @llvm.fmuladd.f64(double %123, double %127, double %136)
%138 = load [4 x double]*, [4 x double]** %5
%139 = getelementptr inbounds [4 x double], [4 x double]* %138, i64 0
%140 = getelementptr inbounds [4 x double], [4 x double]* %139, i64 0, i64 2
%141 = load double, double* %140
%142 = load [4 x double]*, [4 x double]** %6
%143 = getelementptr inbounds [4 x double], [4 x double]* %142, i64 2
%144 = getelementptr inbounds [4 x double], [4 x double]* %143, i64 0, i64 3
%145 = load double, double* %144
%146 = call double @llvm.fmuladd.f64(double %141, double %145, double %137)
%147 = load [4 x double]*, [4 x double]** %5
%148 = getelementptr inbounds [4 x double], [4 x double]* %147, i64 0
%149 = getelementptr inbounds [4 x double], [4 x double]* %148, i64 0, i64 3
%150 = load double, double* %149
%151 = load [4 x double]*, [4 x double]** %6
%152 = getelementptr inbounds [4 x double], [4 x double]* %151, i64 3
%153 = getelementptr inbounds [4 x double], [4 x double]* %152, i64 0, i64 3
%154 = load double, double* %153
%155 = call double @llvm.fmuladd.f64(double %150, double %154, double %146)
%156 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 3
store double %155, double* %156
%157 = load [4 x double]*, [4 x double]** %5
%158 = getelementptr inbounds [4 x double], [4 x double]* %157, i64 1
%159 = getelementptr inbounds [4 x double], [4 x double]* %158, i64 0, i64 0
%160 = load double, double* %159
%161 = load [4 x double]*, [4 x double]** %6
%162 = getelementptr inbounds [4 x double], [4 x double]* %161, i64 0
%163 = getelementptr inbounds [4 x double], [4 x double]* %162, i64 0, i64 0
%164 = load double, double* %163
%165 = load [4 x double]*, [4 x double]** %5
%166 = getelementptr inbounds [4 x double], [4 x double]* %165, i64 1
%167 = getelementptr inbounds [4 x double], [4 x double]* %166, i64 0, i64 1
%168 = load double, double* %167
%169 = load [4 x double]*, [4 x double]** %6
%170 = getelementptr inbounds [4 x double], [4 x double]* %169, i64 1
%171 = getelementptr inbounds [4 x double], [4 x double]* %170, i64 0, i64 0
%172 = load double, double* %171
%173 = fmul double %168, %172
%174 = call double @llvm.fmuladd.f64(double %160, double %164, double %173)
%175 = load [4 x double]*, [4 x double]** %5
%176 = getelementptr inbounds [4 x double], [4 x double]* %175, i64 1
%177 = getelementptr inbounds [4 x double], [4 x double]* %176, i64 0, i64 2
%178 = load double, double* %177
%179 = load [4 x double]*, [4 x double]** %6
%180 = getelementptr inbounds [4 x double], [4 x double]* %179, i64 2
%181 = getelementptr inbounds [4 x double], [4 x double]* %180, i64 0, i64 0
%182 = load double, double* %181
%183 = call double @llvm.fmuladd.f64(double %178, double %182, double %174)
%184 = load [4 x double]*, [4 x double]** %5
%185 = getelementptr inbounds [4 x double], [4 x double]* %184, i64 1
%186 = getelementptr inbounds [4 x double], [4 x double]* %185, i64 0, i64 3
%187 = load double, double* %186
%188 = load [4 x double]*, [4 x double]** %6
%189 = getelementptr inbounds [4 x double], [4 x double]* %188, i64 3
%190 = getelementptr inbounds [4 x double], [4 x double]* %189, i64 0, i64 0
%191 = load double, double* %190
%192 = call double @llvm.fmuladd.f64(double %187, double %191, double %183)
%193 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 4
store double %192, double* %193
%194 = load [4 x double]*, [4 x double]** %5
%195 = getelementptr inbounds [4 x double], [4 x double]* %194, i64 1
%196 = getelementptr inbounds [4 x double], [4 x double]* %195, i64 0, i64 0
%197 = load double, double* %196
%198 = load [4 x double]*, [4 x double]** %6
%199 = getelementptr inbounds [4 x double], [4 x double]* %198, i64 0
%200 = getelementptr inbounds [4 x double], [4 x double]* %199, i64 0, i64 1
%201 = load double, double* %200
%202 = load [4 x double]*, [4 x double]** %5
%203 = getelementptr inbounds [4 x double], [4 x double]* %202, i64 1
%204 = getelementptr inbounds [4 x double], [4 x double]* %203, i64 0, i64 1
%205 = load double, double* %204
%206 = load [4 x double]*, [4 x double]** %6
%207 = getelementptr inbounds [4 x double], [4 x double]* %206, i64 1
%208 = getelementptr inbounds [4 x double], [4 x double]* %207, i64 0, i64 1
%209 = load double, double* %208
%210 = fmul double %205, %209
%211 = call double @llvm.fmuladd.f64(double %197, double %201, double %210)
%212 = load [4 x double]*, [4 x double]** %5
%213 = getelementptr inbounds [4 x double], [4 x double]* %212, i64 1
%214 = getelementptr inbounds [4 x double], [4 x double]* %213, i64 0, i64 2
%215 = load double, double* %214
%216 = load [4 x double]*, [4 x double]** %6
%217 = getelementptr inbounds [4 x double], [4 x double]* %216, i64 2
%218 = getelementptr inbounds [4 x double], [4 x double]* %217, i64 0, i64 1
%219 = load double, double* %218
%220 = call double @llvm.fmuladd.f64(double %215, double %219, double %211)
%221 = load [4 x double]*, [4 x double]** %5
%222 = getelementptr inbounds [4 x double], [4 x double]* %221, i64 1
%223 = getelementptr inbounds [4 x double], [4 x double]* %222, i64 0, i64 3
%224 = load double, double* %223
%225 = load [4 x double]*, [4 x double]** %6
%226 = getelementptr inbounds [4 x double], [4 x double]* %225, i64 3
%227 = getelementptr inbounds [4 x double], [4 x double]* %226, i64 0, i64 1
%228 = load double, double* %227
%229 = call double @llvm.fmuladd.f64(double %224, double %228, double %220)
%230 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 5
store double %229, double* %230
%231 = load [4 x double]*, [4 x double]** %5
%232 = getelementptr inbounds [4 x double], [4 x double]* %231, i64 1
%233 = getelementptr inbounds [4 x double], [4 x double]* %232, i64 0, i64 0
%234 = load double, double* %233
%235 = load [4 x double]*, [4 x double]** %6
%236 = getelementptr inbounds [4 x double], [4 x double]* %235, i64 0
%237 = getelementptr inbounds [4 x double], [4 x double]* %236, i64 0, i64 2
%238 = load double, double* %237
%239 = load [4 x double]*, [4 x double]** %5
%240 = getelementptr inbounds [4 x double], [4 x double]* %239, i64 1
%241 = getelementptr inbounds [4 x double], [4 x double]* %240, i64 0, i64 1
%242 = load double, double* %241
%243 = load [4 x double]*, [4 x double]** %6
%244 = getelementptr inbounds [4 x double], [4 x double]* %243, i64 1
%245 = getelementptr inbounds [4 x double], [4 x double]* %244, i64 0, i64 2
%246 = load double, double* %245
%247 = fmul double %242, %246
%248 = call double @llvm.fmuladd.f64(double %234, double %238, double %247)
%249 = load [4 x double]*, [4 x double]** %5
%250 = getelementptr inbounds [4 x double], [4 x double]* %249, i64 1
%251 = getelementptr inbounds [4 x double], [4 x double]* %250, i64 0, i64 2
%252 = load double, double* %251
%253 = load [4 x double]*, [4 x double]** %6
%254 = getelementptr inbounds [4 x double], [4 x double]* %253, i64 2
%255 = getelementptr inbounds [4 x double], [4 x double]* %254, i64 0, i64 2
%256 = load double, double* %255
%257 = call double @llvm.fmuladd.f64(double %252, double %256, double %248)
%258 = load [4 x double]*, [4 x double]** %5
%259 = getelementptr inbounds [4 x double], [4 x double]* %258, i64 1
%260 = getelementptr inbounds [4 x double], [4 x double]* %259, i64 0, i64 3
%261 = load double, double* %260
%262 = load [4 x double]*, [4 x double]** %6
%263 = getelementptr inbounds [4 x double], [4 x double]* %262, i64 3
%264 = getelementptr inbounds [4 x double], [4 x double]* %263, i64 0, i64 2
%265 = load double, double* %264
%266 = call double @llvm.fmuladd.f64(double %261, double %265, double %257)
%267 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 6
store double %266, double* %267
%268 = load [4 x double]*, [4 x double]** %5
%269 = getelementptr inbounds [4 x double], [4 x double]* %268, i64 1
%270 = getelementptr inbounds [4 x double], [4 x double]* %269, i64 0, i64 0
%271 = load double, double* %270
%272 = load [4 x double]*, [4 x double]** %6
%273 = getelementptr inbounds [4 x double], [4 x double]* %272, i64 0
%274 = getelementptr inbounds [4 x double], [4 x double]* %273, i64 0, i64 3
%275 = load double, double* %274
%276 = load [4 x double]*, [4 x double]** %5
%277 = getelementptr inbounds [4 x double], [4 x double]* %276, i64 1
%278 = getelementptr inbounds [4 x double], [4 x double]* %277, i64 0, i64 1
%279 = load double, double* %278
%280 = load [4 x double]*, [4 x double]** %6
%281 = getelementptr inbounds [4 x double], [4 x double]* %280, i64 1
%282 = getelementptr inbounds [4 x double], [4 x double]* %281, i64 0, i64 3
%283 = load double, double* %282
%284 = fmul double %279, %283
%285 = call double @llvm.fmuladd.f64(double %271, double %275, double %284)
%286 = load [4 x double]*, [4 x double]** %5
%287 = getelementptr inbounds [4 x double], [4 x double]* %286, i64 1
%288 = getelementptr inbounds [4 x double], [4 x double]* %287, i64 0, i64 2
%289 = load double, double* %288
%290 = load [4 x double]*, [4 x double]** %6
%291 = getelementptr inbounds [4 x double], [4 x double]* %290, i64 2
%292 = getelementptr inbounds [4 x double], [4 x double]* %291, i64 0, i64 3
%293 = load double, double* %292
%294 = call double @llvm.fmuladd.f64(double %289, double %293, double %285)
%295 = load [4 x double]*, [4 x double]** %5
%296 = getelementptr inbounds [4 x double], [4 x double]* %295, i64 1
%297 = getelementptr inbounds [4 x double], [4 x double]* %296, i64 0, i64 3
%298 = load double, double* %297
%299 = load [4 x double]*, [4 x double]** %6
%300 = getelementptr inbounds [4 x double], [4 x double]* %299, i64 3
%301 = getelementptr inbounds [4 x double], [4 x double]* %300, i64 0, i64 3
%302 = load double, double* %301
%303 = call double @llvm.fmuladd.f64(double %298, double %302, double %294)
%304 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 7
store double %303, double* %304
%305 = load [4 x double]*, [4 x double]** %5
%306 = getelementptr inbounds [4 x double], [4 x double]* %305, i64 2
%307 = getelementptr inbounds [4 x double], [4 x double]* %306, i64 0, i64 0
%308 = load double, double* %307
%309 = load [4 x double]*, [4 x double]** %6
%310 = getelementptr inbounds [4 x double], [4 x double]* %309, i64 0
%311 = getelementptr inbounds [4 x double], [4 x double]* %310, i64 0, i64 0
%312 = load double, double* %311
%313 = load [4 x double]*, [4 x double]** %5
%314 = getelementptr inbounds [4 x double], [4 x double]* %313, i64 2
%315 = getelementptr inbounds [4 x double], [4 x double]* %314, i64 0, i64 1
%316 = load double, double* %315
%317 = load [4 x double]*, [4 x double]** %6
%318 = getelementptr inbounds [4 x double], [4 x double]* %317, i64 1
%319 = getelementptr inbounds [4 x double], [4 x double]* %318, i64 0, i64 0
%320 = load double, double* %319
%321 = fmul double %316, %320
%322 = call double @llvm.fmuladd.f64(double %308, double %312, double %321)
%323 = load [4 x double]*, [4 x double]** %5
%324 = getelementptr inbounds [4 x double], [4 x double]* %323, i64 2
%325 = getelementptr inbounds [4 x double], [4 x double]* %324, i64 0, i64 2
%326 = load double, double* %325
%327 = load [4 x double]*, [4 x double]** %6
%328 = getelementptr inbounds [4 x double], [4 x double]* %327, i64 2
%329 = getelementptr inbounds [4 x double], [4 x double]* %328, i64 0, i64 0
%330 = load double, double* %329
%331 = call double @llvm.fmuladd.f64(double %326, double %330, double %322)
%332 = load [4 x double]*, [4 x double]** %5
%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 3
%335 = load double, double* %334
%336 = load [4 x double]*, [4 x double]** %6
%337 = getelementptr inbounds [4 x double], [4 x double]* %336, i64 3
%338 = getelementptr inbounds [4 x double], [4 x double]* %337, i64 0, i64 0
%339 = load double, double* %338
%340 = call double @llvm.fmuladd.f64(double %335, double %339, double %331)
%341 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 8
store double %340, double* %341
%342 = load [4 x double]*, [4 x double]** %5
%343 = getelementptr inbounds [4 x double], [4 x double]* %342, i64 2
%344 = getelementptr inbounds [4 x double], [4 x double]* %343, i64 0, i64 0
%345 = load double, double* %344
%346 = load [4 x double]*, [4 x double]** %6
%347 = getelementptr inbounds [4 x double], [4 x double]* %346, i64 0
%348 = getelementptr inbounds [4 x double], [4 x double]* %347, i64 0, i64 1
%349 = load double, double* %348
%350 = load [4 x double]*, [4 x double]** %5
%351 = getelementptr inbounds [4 x double], [4 x double]* %350, i64 2
%352 = getelementptr inbounds [4 x double], [4 x double]* %351, i64 0, i64 1
%353 = load double, double* %352
%354 = load [4 x double]*, [4 x double]** %6
%355 = getelementptr inbounds [4 x double], [4 x double]* %354, i64 1
%356 = getelementptr inbounds [4 x double], [4 x double]* %355, i64 0, i64 1
%357 = load double, double* %356
%358 = fmul double %353, %357
%359 = call double @llvm.fmuladd.f64(double %345, double %349, double %358)
%360 = load [4 x double]*, [4 x double]** %5
%361 = getelementptr inbounds [4 x double], [4 x double]* %360, i64 2
%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]** %6
%365 = getelementptr inbounds [4 x double], [4 x double]* %364, i64 2
%366 = getelementptr inbounds [4 x double], [4 x double]* %365, i64 0, i64 1
%367 = load double, double* %366
%368 = call double @llvm.fmuladd.f64(double %363, double %367, double %359)
%369 = load [4 x double]*, [4 x double]** %5
%370 = getelementptr inbounds [4 x double], [4 x double]* %369, i64 2
%371 = getelementptr inbounds [4 x double], [4 x double]* %370, i64 0, i64 3
%372 = load double, double* %371
%373 = load [4 x double]*, [4 x double]** %6
%374 = getelementptr inbounds [4 x double], [4 x double]* %373, i64 3
%375 = getelementptr inbounds [4 x double], [4 x double]* %374, i64 0, i64 1
%376 = load double, double* %375
%377 = call double @llvm.fmuladd.f64(double %372, double %376, double %368)
%378 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 9
store double %377, double* %378
%379 = load [4 x double]*, [4 x double]** %5
%380 = getelementptr inbounds [4 x double], [4 x double]* %379, i64 2
%381 = getelementptr inbounds [4 x double], [4 x double]* %380, i64 0, i64 0
%382 = load double, double* %381
%383 = load [4 x double]*, [4 x double]** %6
%384 = getelementptr inbounds [4 x double], [4 x double]* %383, i64 0
%385 = getelementptr inbounds [4 x double], [4 x double]* %384, i64 0, i64 2
%386 = load double, double* %385
%387 = load [4 x double]*, [4 x double]** %5
%388 = getelementptr inbounds [4 x double], [4 x double]* %387, i64 2
%389 = getelementptr inbounds [4 x double], [4 x double]* %388, i64 0, i64 1
%390 = load double, double* %389
%391 = load [4 x double]*, [4 x double]** %6
%392 = getelementptr inbounds [4 x double], [4 x double]* %391, i64 1
%393 = getelementptr inbounds [4 x double], [4 x double]* %392, i64 0, i64 2
%394 = load double, double* %393
%395 = fmul double %390, %394
%396 = call double @llvm.fmuladd.f64(double %382, double %386, double %395)
%397 = load [4 x double]*, [4 x double]** %5
%398 = getelementptr inbounds [4 x double], [4 x double]* %397, i64 2
%399 = getelementptr inbounds [4 x double], [4 x double]* %398, i64 0, i64 2
%400 = load double, double* %399
%401 = load [4 x double]*, [4 x double]** %6
%402 = getelementptr inbounds [4 x double], [4 x double]* %401, i64 2
%403 = getelementptr inbounds [4 x double], [4 x double]* %402, i64 0, i64 2
%404 = load double, double* %403
%405 = call double @llvm.fmuladd.f64(double %400, double %404, double %396)
%406 = load [4 x double]*, [4 x double]** %5
%407 = getelementptr inbounds [4 x double], [4 x double]* %406, i64 2
%408 = getelementptr inbounds [4 x double], [4 x double]* %407, i64 0, i64 3
%409 = load double, double* %408
%410 = load [4 x double]*, [4 x double]** %6
%411 = getelementptr inbounds [4 x double], [4 x double]* %410, i64 3
%412 = getelementptr inbounds [4 x double], [4 x double]* %411, i64 0, i64 2
%413 = load double, double* %412
%414 = call double @llvm.fmuladd.f64(double %409, double %413, double %405)
%415 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 10
store double %414, double* %415
%416 = load [4 x double]*, [4 x double]** %5
%417 = getelementptr inbounds [4 x double], [4 x double]* %416, i64 2
%418 = getelementptr inbounds [4 x double], [4 x double]* %417, i64 0, i64 0
%419 = load double, double* %418
%420 = load [4 x double]*, [4 x double]** %6
%421 = getelementptr inbounds [4 x double], [4 x double]* %420, i64 0
%422 = getelementptr inbounds [4 x double], [4 x double]* %421, i64 0, i64 3
%423 = load double, double* %422
%424 = load [4 x double]*, [4 x double]** %5
%425 = getelementptr inbounds [4 x double], [4 x double]* %424, i64 2
%426 = getelementptr inbounds [4 x double], [4 x double]* %425, i64 0, i64 1
%427 = load double, double* %426
%428 = load [4 x double]*, [4 x double]** %6
%429 = getelementptr inbounds [4 x double], [4 x double]* %428, i64 1
%430 = getelementptr inbounds [4 x double], [4 x double]* %429, i64 0, i64 3
%431 = load double, double* %430
%432 = fmul double %427, %431
%433 = call double @llvm.fmuladd.f64(double %419, double %423, double %432)
%434 = load [4 x double]*, [4 x double]** %5
%435 = getelementptr inbounds [4 x double], [4 x double]* %434, i64 2
%436 = getelementptr inbounds [4 x double], [4 x double]* %435, i64 0, i64 2
%437 = load double, double* %436
%438 = load [4 x double]*, [4 x double]** %6
%439 = getelementptr inbounds [4 x double], [4 x double]* %438, i64 2
%440 = getelementptr inbounds [4 x double], [4 x double]* %439, i64 0, i64 3
%441 = load double, double* %440
%442 = call double @llvm.fmuladd.f64(double %437, double %441, double %433)
%443 = load [4 x double]*, [4 x double]** %5
%444 = getelementptr inbounds [4 x double], [4 x double]* %443, i64 2
%445 = getelementptr inbounds [4 x double], [4 x double]* %444, i64 0, i64 3
%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 3
%449 = getelementptr inbounds [4 x double], [4 x double]* %448, i64 0, i64 3
%450 = load double, double* %449
%451 = call double @llvm.fmuladd.f64(double %446, double %450, double %442)
%452 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 11
store double %451, double* %452
%453 = load [4 x double]*, [4 x double]** %5
%454 = getelementptr inbounds [4 x double], [4 x double]* %453, i64 3
%455 = getelementptr inbounds [4 x double], [4 x double]* %454, i64 0, i64 0
%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 0
%459 = getelementptr inbounds [4 x double], [4 x double]* %458, i64 0, i64 0
%460 = load double, double* %459
%461 = load [4 x double]*, [4 x double]** %5
%462 = getelementptr inbounds [4 x double], [4 x double]* %461, i64 3
%463 = getelementptr inbounds [4 x double], [4 x double]* %462, i64 0, i64 1
%464 = load double, double* %463
%465 = load [4 x double]*, [4 x double]** %6
%466 = getelementptr inbounds [4 x double], [4 x double]* %465, i64 1
%467 = getelementptr inbounds [4 x double], [4 x double]* %466, i64 0, i64 0
%468 = load double, double* %467
%469 = fmul double %464, %468
%470 = call double @llvm.fmuladd.f64(double %456, double %460, double %469)
%471 = load [4 x double]*, [4 x double]** %5
%472 = getelementptr inbounds [4 x double], [4 x double]* %471, i64 3
%473 = getelementptr inbounds [4 x double], [4 x double]* %472, i64 0, i64 2
%474 = load double, double* %473
%475 = load [4 x double]*, [4 x double]** %6
%476 = getelementptr inbounds [4 x double], [4 x double]* %475, i64 2
%477 = getelementptr inbounds [4 x double], [4 x double]* %476, i64 0, i64 0
%478 = load double, double* %477
%479 = call double @llvm.fmuladd.f64(double %474, double %478, double %470)
%480 = load [4 x double]*, [4 x double]** %5
%481 = getelementptr inbounds [4 x double], [4 x double]* %480, i64 3
%482 = getelementptr inbounds [4 x double], [4 x double]* %481, i64 0, i64 3
%483 = load double, double* %482
%484 = load [4 x double]*, [4 x double]** %6
%485 = getelementptr inbounds [4 x double], [4 x double]* %484, i64 3
%486 = getelementptr inbounds [4 x double], [4 x double]* %485, i64 0, i64 0
%487 = load double, double* %486
%488 = call double @llvm.fmuladd.f64(double %483, double %487, double %479)
%489 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 12
store double %488, double* %489
%490 = load [4 x double]*, [4 x double]** %5
%491 = getelementptr inbounds [4 x double], [4 x double]* %490, i64 3
%492 = getelementptr inbounds [4 x double], [4 x double]* %491, i64 0, i64 0
%493 = load double, double* %492
%494 = load [4 x double]*, [4 x double]** %6
%495 = getelementptr inbounds [4 x double], [4 x double]* %494, i64 0
%496 = getelementptr inbounds [4 x double], [4 x double]* %495, i64 0, i64 1
%497 = load double, double* %496
%498 = load [4 x double]*, [4 x double]** %5
%499 = getelementptr inbounds [4 x double], [4 x double]* %498, i64 3
%500 = getelementptr inbounds [4 x double], [4 x double]* %499, i64 0, i64 1
%501 = load double, double* %500
%502 = load [4 x double]*, [4 x double]** %6
%503 = getelementptr inbounds [4 x double], [4 x double]* %502, i64 1
%504 = getelementptr inbounds [4 x double], [4 x double]* %503, i64 0, i64 1
%505 = load double, double* %504
%506 = fmul double %501, %505
%507 = call double @llvm.fmuladd.f64(double %493, double %497, double %506)
%508 = load [4 x double]*, [4 x double]** %5
%509 = getelementptr inbounds [4 x double], [4 x double]* %508, i64 3
%510 = getelementptr inbounds [4 x double], [4 x double]* %509, i64 0, i64 2
%511 = load double, double* %510
%512 = load [4 x double]*, [4 x double]** %6
%513 = getelementptr inbounds [4 x double], [4 x double]* %512, i64 2
%514 = getelementptr inbounds [4 x double], [4 x double]* %513, i64 0, i64 1
%515 = load double, double* %514
%516 = call double @llvm.fmuladd.f64(double %511, double %515, double %507)
%517 = load [4 x double]*, [4 x double]** %5
%518 = getelementptr inbounds [4 x double], [4 x double]* %517, i64 3
%519 = getelementptr inbounds [4 x double], [4 x double]* %518, i64 0, i64 3
%520 = load double, double* %519
%521 = load [4 x double]*, [4 x double]** %6
%522 = getelementptr inbounds [4 x double], [4 x double]* %521, i64 3
%523 = getelementptr inbounds [4 x double], [4 x double]* %522, i64 0, i64 1
%524 = load double, double* %523
%525 = call double @llvm.fmuladd.f64(double %520, double %524, double %516)
%526 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 13
store double %525, double* %526
%527 = load [4 x double]*, [4 x double]** %5
%528 = getelementptr inbounds [4 x double], [4 x double]* %527, i64 3
%529 = getelementptr inbounds [4 x double], [4 x double]* %528, i64 0, i64 0
%530 = load double, double* %529
%531 = load [4 x double]*, [4 x double]** %6
%532 = getelementptr inbounds [4 x double], [4 x double]* %531, i64 0
%533 = getelementptr inbounds [4 x double], [4 x double]* %532, i64 0, i64 2
%534 = load double, double* %533
%535 = load [4 x double]*, [4 x double]** %5
%536 = getelementptr inbounds [4 x double], [4 x double]* %535, i64 3
%537 = getelementptr inbounds [4 x double], [4 x double]* %536, i64 0, i64 1
%538 = load double, double* %537
%539 = load [4 x double]*, [4 x double]** %6
%540 = getelementptr inbounds [4 x double], [4 x double]* %539, i64 1
%541 = getelementptr inbounds [4 x double], [4 x double]* %540, i64 0, i64 2
%542 = load double, double* %541
%543 = fmul double %538, %542
%544 = call double @llvm.fmuladd.f64(double %530, double %534, double %543)
%545 = load [4 x double]*, [4 x double]** %5
%546 = getelementptr inbounds [4 x double], [4 x double]* %545, i64 3
%547 = getelementptr inbounds [4 x double], [4 x double]* %546, i64 0, i64 2
%548 = load double, double* %547
%549 = load [4 x double]*, [4 x double]** %6
%550 = getelementptr inbounds [4 x double], [4 x double]* %549, i64 2
%551 = getelementptr inbounds [4 x double], [4 x double]* %550, i64 0, i64 2
%552 = load double, double* %551
%553 = call double @llvm.fmuladd.f64(double %548, double %552, double %544)
%554 = load [4 x double]*, [4 x double]** %5
%555 = getelementptr inbounds [4 x double], [4 x double]* %554, i64 3
%556 = getelementptr inbounds [4 x double], [4 x double]* %555, i64 0, i64 3
%557 = load double, double* %556
%558 = load [4 x double]*, [4 x double]** %6
%559 = getelementptr inbounds [4 x double], [4 x double]* %558, i64 3
%560 = getelementptr inbounds [4 x double], [4 x double]* %559, i64 0, i64 2
%561 = load double, double* %560
%562 = call double @llvm.fmuladd.f64(double %557, double %561, double %553)
%563 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 14
store double %562, double* %563
%564 = load [4 x double]*, [4 x double]** %5
%565 = getelementptr inbounds [4 x double], [4 x double]* %564, i64 3
%566 = getelementptr inbounds [4 x double], [4 x double]* %565, i64 0, i64 0
%567 = load double, double* %566
%568 = load [4 x double]*, [4 x double]** %6
%569 = getelementptr inbounds [4 x double], [4 x double]* %568, i64 0
%570 = getelementptr inbounds [4 x double], [4 x double]* %569, i64 0, i64 3
%571 = load double, double* %570
%572 = load [4 x double]*, [4 x double]** %5
%573 = getelementptr inbounds [4 x double], [4 x double]* %572, i64 3
%574 = getelementptr inbounds [4 x double], [4 x double]* %573, i64 0, i64 1
%575 = load double, double* %574
%576 = load [4 x double]*, [4 x double]** %6
%577 = getelementptr inbounds [4 x double], [4 x double]* %576, i64 1
%578 = getelementptr inbounds [4 x double], [4 x double]* %577, i64 0, i64 3
%579 = load double, double* %578
%580 = fmul double %575, %579
%581 = call double @llvm.fmuladd.f64(double %567, double %571, double %580)
%582 = load [4 x double]*, [4 x double]** %5
%583 = getelementptr inbounds [4 x double], [4 x double]* %582, i64 3
%584 = getelementptr inbounds [4 x double], [4 x double]* %583, i64 0, i64 2
%585 = load double, double* %584
%586 = load [4 x double]*, [4 x double]** %6
%587 = getelementptr inbounds [4 x double], [4 x double]* %586, i64 2
%588 = getelementptr inbounds [4 x double], [4 x double]* %587, i64 0, i64 3
%589 = load double, double* %588
%590 = call double @llvm.fmuladd.f64(double %585, double %589, double %581)
%591 = load [4 x double]*, [4 x double]** %5
%592 = getelementptr inbounds [4 x double], [4 x double]* %591, i64 3
%593 = getelementptr inbounds [4 x double], [4 x double]* %592, i64 0, i64 3
%594 = load double, double* %593
%595 = load [4 x double]*, [4 x double]** %6
%596 = getelementptr inbounds [4 x double], [4 x double]* %595, i64 3
%597 = getelementptr inbounds [4 x double], [4 x double]* %596, i64 0, i64 3
%598 = load double, double* %597
%599 = call double @llvm.fmuladd.f64(double %594, double %598, double %590)
%600 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 15
store double %599, double* %600
store i32 0, i32* %7
br label %601
601: ; preds = %613, %3
%602 = load i32, i32* %7
%603 = icmp ult i32 %602, 16
br i1 %603, label %604, label %616
604: ; preds = %601
%605 = load i32, i32* %7
%606 = zext i32 %605 to i64
%607 = getelementptr inbounds [16 x double], [16 x double]* %8, i64 0, i64 %606
%608 = load double, double* %607
%609 = load double*, double** %4
%610 = load i32, i32* %7
%611 = zext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
store double %608, double* %612
br label %613
613: ; preds = %604
%614 = load i32, i32* %7
%615 = add i32 %614, 1
store i32 %615, i32* %7
br label %601
616: ; preds = %601
ret void
}

LLVM IR (-O2):
define void @mul4(double* nocapture writeonly %0, [4 x double]* nocapture %1, [4 x double]* nocapture %2) {
%4 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 0
%5 = load double, double* %4
%6 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 1
%7 = load double, double* %6
%8 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 1, i64 0
%9 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 2
%10 = load double, double* %9
%11 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 2, i64 0
%12 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 3
%13 = load double, double* %12
%14 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 3, i64 0
%15 = bitcast [4 x double]* %2 to <2 x double>*
%16 = load <2 x double>, <2 x double>* %15
%17 = bitcast double* %8 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = insertelement <2 x double> poison, double %7, i64 0
%20 = shufflevector <2 x double> %19, <2 x double> poison, <2 x i32> zeroinitializer
%21 = fmul <2 x double> %20, %18
%22 = insertelement <2 x double> poison, double %5, i64 0
%23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> zeroinitializer
%24 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %23, <2 x double> %16, <2 x double> %21)
%25 = bitcast double* %11 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = insertelement <2 x double> poison, double %10, i64 0
%28 = shufflevector <2 x double> %27, <2 x double> poison, <2 x i32> zeroinitializer
%29 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %28, <2 x double> %26, <2 x double> %24)
%30 = bitcast double* %14 to <2 x double>*
%31 = load <2 x double>, <2 x double>* %30
%32 = insertelement <2 x double> poison, double %13, i64 0
%33 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> zeroinitializer
%34 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %33, <2 x double> %31, <2 x double> %29)
%35 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 0, i64 2
%36 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 1, i64 2
%37 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 2, i64 2
%38 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 3, i64 2
%39 = bitcast double* %35 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = bitcast double* %36 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = fmul <2 x double> %20, %42
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %23, <2 x double> %40, <2 x double> %43)
%45 = bitcast double* %37 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %28, <2 x double> %46, <2 x double> %44)
%48 = bitcast double* %38 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %33, <2 x double> %49, <2 x double> %47)
%51 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 0
%52 = load double, double* %51
%53 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 1
%54 = load double, double* %53
%55 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 2
%56 = load double, double* %55
%57 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 3
%58 = load double, double* %57
%59 = insertelement <2 x double> poison, double %54, i64 0
%60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
%61 = fmul <2 x double> %18, %60
%62 = insertelement <2 x double> poison, double %52, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%64 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %63, <2 x double> %16, <2 x double> %61)
%65 = insertelement <2 x double> poison, double %56, i64 0
%66 = shufflevector <2 x double> %65, <2 x double> poison, <2 x i32> zeroinitializer
%67 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %26, <2 x double> %64)
%68 = insertelement <2 x double> poison, double %58, i64 0
%69 = shufflevector <2 x double> %68, <2 x double> poison, <2 x i32> zeroinitializer
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %69, <2 x double> %31, <2 x double> %67)
%71 = fmul <2 x double> %42, %60
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %63, <2 x double> %40, <2 x double> %71)
%73 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %46, <2 x double> %72)
%74 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %69, <2 x double> %49, <2 x double> %73)
%75 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 0
%76 = load double, double* %75
%77 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 1
%78 = load double, double* %77
%79 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 2
%80 = load double, double* %79
%81 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 3
%82 = load double, double* %81
%83 = insertelement <2 x double> poison, double %78, i64 0
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> zeroinitializer
%85 = fmul <2 x double> %18, %84
%86 = insertelement <2 x double> poison, double %76, 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> %16, <2 x double> %85)
%89 = insertelement <2 x double> poison, double %80, i64 0
%90 = shufflevector <2 x double> %89, <2 x double> poison, <2 x i32> zeroinitializer
%91 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> %26, <2 x double> %88)
%92 = insertelement <2 x double> poison, double %82, i64 0
%93 = shufflevector <2 x double> %92, <2 x double> poison, <2 x i32> zeroinitializer
%94 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %93, <2 x double> %31, <2 x double> %91)
%95 = fmul <2 x double> %42, %84
%96 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %87, <2 x double> %40, <2 x double> %95)
%97 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> %46, <2 x double> %96)
%98 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %93, <2 x double> %49, <2 x double> %97)
%99 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 0
%100 = load double, double* %99
%101 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 1
%102 = load double, double* %101
%103 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 2
%104 = load double, double* %103
%105 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 3
%106 = load double, double* %105
%107 = insertelement <2 x double> poison, double %102, i64 0
%108 = shufflevector <2 x double> %107, <2 x double> poison, <2 x i32> zeroinitializer
%109 = fmul <2 x double> %18, %108
%110 = insertelement <2 x double> poison, double %100, i64 0
%111 = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> zeroinitializer
%112 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %16, <2 x double> %109)
%113 = insertelement <2 x double> poison, double %104, i64 0
%114 = shufflevector <2 x double> %113, <2 x double> poison, <2 x i32> zeroinitializer
%115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %26, <2 x double> %112)
%116 = insertelement <2 x double> poison, double %106, i64 0
%117 = shufflevector <2 x double> %116, <2 x double> poison, <2 x i32> zeroinitializer
%118 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %117, <2 x double> %31, <2 x double> %115)
%119 = fmul <2 x double> %42, %108
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %40, <2 x double> %119)
%121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %46, <2 x double> %120)
%122 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %117, <2 x double> %49, <2 x double> %121)
%123 = bitcast double* %0 to <2 x double>*
store <2 x double> %34, <2 x double>* %123
%124 = getelementptr inbounds double, double* %0, i64 2
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %50, <2 x double>* %125
%126 = getelementptr inbounds double, double* %0, i64 4
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> %70, <2 x double>* %127
%128 = getelementptr inbounds double, double* %0, i64 6
%129 = bitcast double* %128 to <2 x double>*
store <2 x double> %74, <2 x double>* %129
%130 = getelementptr inbounds double, double* %0, i64 8
%131 = bitcast double* %130 to <2 x double>*
store <2 x double> %94, <2 x double>* %131
%132 = getelementptr inbounds double, double* %0, i64 10
%133 = bitcast double* %132 to <2 x double>*
store <2 x double> %98, <2 x double>* %133
%134 = getelementptr inbounds double, double* %0, i64 12
%135 = bitcast double* %134 to <2 x double>*
store <2 x double> %118, <2 x double>* %135
%136 = getelementptr inbounds double, double* %0, i64 14
%137 = bitcast double* %136 to <2 x double>*
store <2 x double> %122, <2 x double>* %137
ret void
}