void matmul_sub(double ablock[5][5], double bblock[5][5], double cblock[5][5]) {
  cblock[0][0] = cblock[0][0] - ablock[0][0] * bblock[0][0] -
                 ablock[1][0] * bblock[0][1] - ablock[2][0] * bblock[0][2] -
                 ablock[3][0] * bblock[0][3] - ablock[4][0] * bblock[0][4];
  cblock[0][1] = cblock[0][1] - ablock[0][1] * bblock[0][0] -
                 ablock[1][1] * bblock[0][1] - ablock[2][1] * bblock[0][2] -
                 ablock[3][1] * bblock[0][3] - ablock[4][1] * bblock[0][4];
  cblock[0][2] = cblock[0][2] - ablock[0][2] * bblock[0][0] -
                 ablock[1][2] * bblock[0][1] - ablock[2][2] * bblock[0][2] -
                 ablock[3][2] * bblock[0][3] - ablock[4][2] * bblock[0][4];
  cblock[0][3] = cblock[0][3] - ablock[0][3] * bblock[0][0] -
                 ablock[1][3] * bblock[0][1] - ablock[2][3] * bblock[0][2] -
                 ablock[3][3] * bblock[0][3] - ablock[4][3] * bblock[0][4];
  cblock[0][4] = cblock[0][4] - ablock[0][4] * bblock[0][0] -
                 ablock[1][4] * bblock[0][1] - ablock[2][4] * bblock[0][2] -
                 ablock[3][4] * bblock[0][3] - ablock[4][4] * bblock[0][4];
  cblock[1][0] = cblock[1][0] - ablock[0][0] * bblock[1][0] -
                 ablock[1][0] * bblock[1][1] - ablock[2][0] * bblock[1][2] -
                 ablock[3][0] * bblock[1][3] - ablock[4][0] * bblock[1][4];
  cblock[1][1] = cblock[1][1] - ablock[0][1] * bblock[1][0] -
                 ablock[1][1] * bblock[1][1] - ablock[2][1] * bblock[1][2] -
                 ablock[3][1] * bblock[1][3] - ablock[4][1] * bblock[1][4];
  cblock[1][2] = cblock[1][2] - ablock[0][2] * bblock[1][0] -
                 ablock[1][2] * bblock[1][1] - ablock[2][2] * bblock[1][2] -
                 ablock[3][2] * bblock[1][3] - ablock[4][2] * bblock[1][4];
  cblock[1][3] = cblock[1][3] - ablock[0][3] * bblock[1][0] -
                 ablock[1][3] * bblock[1][1] - ablock[2][3] * bblock[1][2] -
                 ablock[3][3] * bblock[1][3] - ablock[4][3] * bblock[1][4];
  cblock[1][4] = cblock[1][4] - ablock[0][4] * bblock[1][0] -
                 ablock[1][4] * bblock[1][1] - ablock[2][4] * bblock[1][2] -
                 ablock[3][4] * bblock[1][3] - ablock[4][4] * bblock[1][4];
  cblock[2][0] = cblock[2][0] - ablock[0][0] * bblock[2][0] -
                 ablock[1][0] * bblock[2][1] - ablock[2][0] * bblock[2][2] -
                 ablock[3][0] * bblock[2][3] - ablock[4][0] * bblock[2][4];
  cblock[2][1] = cblock[2][1] - ablock[0][1] * bblock[2][0] -
                 ablock[1][1] * bblock[2][1] - ablock[2][1] * bblock[2][2] -
                 ablock[3][1] * bblock[2][3] - ablock[4][1] * bblock[2][4];
  cblock[2][2] = cblock[2][2] - ablock[0][2] * bblock[2][0] -
                 ablock[1][2] * bblock[2][1] - ablock[2][2] * bblock[2][2] -
                 ablock[3][2] * bblock[2][3] - ablock[4][2] * bblock[2][4];
  cblock[2][3] = cblock[2][3] - ablock[0][3] * bblock[2][0] -
                 ablock[1][3] * bblock[2][1] - ablock[2][3] * bblock[2][2] -
                 ablock[3][3] * bblock[2][3] - ablock[4][3] * bblock[2][4];
  cblock[2][4] = cblock[2][4] - ablock[0][4] * bblock[2][0] -
                 ablock[1][4] * bblock[2][1] - ablock[2][4] * bblock[2][2] -
                 ablock[3][4] * bblock[2][3] - ablock[4][4] * bblock[2][4];
  cblock[3][0] = cblock[3][0] - ablock[0][0] * bblock[3][0] -
                 ablock[1][0] * bblock[3][1] - ablock[2][0] * bblock[3][2] -
                 ablock[3][0] * bblock[3][3] - ablock[4][0] * bblock[3][4];
  cblock[3][1] = cblock[3][1] - ablock[0][1] * bblock[3][0] -
                 ablock[1][1] * bblock[3][1] - ablock[2][1] * bblock[3][2] -
                 ablock[3][1] * bblock[3][3] - ablock[4][1] * bblock[3][4];
  cblock[3][2] = cblock[3][2] - ablock[0][2] * bblock[3][0] -
                 ablock[1][2] * bblock[3][1] - ablock[2][2] * bblock[3][2] -
                 ablock[3][2] * bblock[3][3] - ablock[4][2] * bblock[3][4];
  cblock[3][3] = cblock[3][3] - ablock[0][3] * bblock[3][0] -
                 ablock[1][3] * bblock[3][1] - ablock[2][3] * bblock[3][2] -
                 ablock[3][3] * bblock[3][3] - ablock[4][3] * bblock[3][4];
  cblock[3][4] = cblock[3][4] - ablock[0][4] * bblock[3][0] -
                 ablock[1][4] * bblock[3][1] - ablock[2][4] * bblock[3][2] -
                 ablock[3][4] * bblock[3][3] - ablock[4][4] * bblock[3][4];
  cblock[4][0] = cblock[4][0] - ablock[0][0] * bblock[4][0] -
                 ablock[1][0] * bblock[4][1] - ablock[2][0] * bblock[4][2] -
                 ablock[3][0] * bblock[4][3] - ablock[4][0] * bblock[4][4];
  cblock[4][1] = cblock[4][1] - ablock[0][1] * bblock[4][0] -
                 ablock[1][1] * bblock[4][1] - ablock[2][1] * bblock[4][2] -
                 ablock[3][1] * bblock[4][3] - ablock[4][1] * bblock[4][4];
  cblock[4][2] = cblock[4][2] - ablock[0][2] * bblock[4][0] -
                 ablock[1][2] * bblock[4][1] - ablock[2][2] * bblock[4][2] -
                 ablock[3][2] * bblock[4][3] - ablock[4][2] * bblock[4][4];
  cblock[4][3] = cblock[4][3] - ablock[0][3] * bblock[4][0] -
                 ablock[1][3] * bblock[4][1] - ablock[2][3] * bblock[4][2] -
                 ablock[3][3] * bblock[4][3] - ablock[4][3] * bblock[4][4];
  cblock[4][4] = cblock[4][4] - ablock[0][4] * bblock[4][0] -
                 ablock[1][4] * bblock[4][1] - ablock[2][4] * bblock[4][2] -
                 ablock[3][4] * bblock[4][3] - ablock[4][4] * bblock[4][4];
}


x86 assembly (clang, -O0):
<matmul_sub>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x18(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x18(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x18(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x18(%rbp),%rax
movsd  0x60(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x18(%rbp),%rax
movsd  0x68(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x18(%rbp),%rax
movsd  0x70(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x70(%rax)
mov    -0x18(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x90(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x98(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x18(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x90(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x98(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x80(%rax)
mov    -0x18(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x90(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x98(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x88(%rax)
mov    -0x18(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x90(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x98(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x90(%rax)
mov    -0x18(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x90(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x98(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x98(%rax)
mov    -0x18(%rbp),%rax
movsd  0xa0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xa0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xa8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xc0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
mov    -0x18(%rbp),%rax
movsd  0xa8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xa0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xa8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xc0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
mov    -0x18(%rbp),%rax
movsd  0xb0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xa0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xa8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xc0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
mov    -0x18(%rbp),%rax
movsd  0xb8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xa0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xa8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xc0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
mov    -0x18(%rbp),%rax
movsd  0xc0(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xa0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xa8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xb0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0xb8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0xc0(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0xc0(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmul_sub>:
movsd  (%rdi),%xmm0
movsd  0x28(%rdi),%xmm1
mulsd  (%rsi),%xmm0
movsd  (%rdx),%xmm2
subsd  %xmm0,%xmm2
movsd  0x8(%rdx),%xmm0
mulsd  0x8(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0x50(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0x78(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  0xa0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdx)
movsd  0x8(%rdi),%xmm1
mulsd  (%rsi),%xmm1
movsd  0x30(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
movsd  0x38(%rdi),%xmm2
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rdx)
movsd  0x18(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
mulsd  (%rsi),%xmm1
movsd  0x40(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rdx)
movsd  0x20(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
movsd  0x48(%rdi),%xmm2
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0x10(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0x18(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0x20(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rdx)
movsd  0x28(%rdx),%xmm0
movsd  (%rdi),%xmm1
mulsd  0x28(%rsi),%xmm1
movsd  0x28(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x30(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x50(%rdi),%xmm1
mulsd  0x38(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x78(%rdi),%xmm1
mulsd  0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa0(%rdi),%xmm1
mulsd  0x48(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rdx)
movsd  0x30(%rdx),%xmm0
movsd  0x8(%rdi),%xmm1
movsd  0x30(%rdi),%xmm2
mulsd  0x28(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x30(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0x38(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0x48(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rdx)
movsd  0x38(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
mulsd  0x28(%rsi),%xmm1
movsd  0x38(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x30(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0x38(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0x48(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rdx)
movsd  0x40(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
movsd  0x40(%rdi),%xmm2
mulsd  0x28(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x30(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0x38(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0x48(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rdx)
movsd  0x48(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
mulsd  0x28(%rsi),%xmm1
movsd  0x48(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x30(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0x38(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0x48(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rdx)
movsd  0x50(%rdx),%xmm0
movsd  (%rdi),%xmm1
movsd  0x28(%rdi),%xmm2
mulsd  0x50(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x58(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x50(%rdi),%xmm1
mulsd  0x60(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x78(%rdi),%xmm1
mulsd  0x68(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa0(%rdi),%xmm1
mulsd  0x70(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x50(%rdx)
movsd  0x58(%rdx),%xmm0
movsd  0x8(%rdi),%xmm1
mulsd  0x50(%rsi),%xmm1
movsd  0x30(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x58(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0x60(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0x68(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0x70(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x58(%rdx)
movsd  0x60(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
movsd  0x38(%rdi),%xmm2
mulsd  0x50(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x58(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0x60(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0x68(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0x70(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x60(%rdx)
movsd  0x68(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
mulsd  0x50(%rsi),%xmm1
movsd  0x40(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x58(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0x60(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0x68(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0x70(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x68(%rdx)
movsd  0x70(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
movsd  0x48(%rdi),%xmm2
mulsd  0x50(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x58(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0x60(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0x68(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0x70(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x70(%rdx)
movsd  0x78(%rdx),%xmm0
movsd  (%rdi),%xmm1
mulsd  0x78(%rsi),%xmm1
movsd  0x28(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x80(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x50(%rdi),%xmm1
mulsd  0x88(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x78(%rdi),%xmm1
mulsd  0x90(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa0(%rdi),%xmm1
mulsd  0x98(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x78(%rdx)
movsd  0x80(%rdx),%xmm0
movsd  0x8(%rdi),%xmm1
movsd  0x30(%rdi),%xmm2
mulsd  0x78(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x80(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0x88(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0x90(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0x98(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x80(%rdx)
movsd  0x88(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
mulsd  0x78(%rsi),%xmm1
movsd  0x38(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x80(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0x88(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0x90(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0x98(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x88(%rdx)
movsd  0x90(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
movsd  0x40(%rdi),%xmm2
mulsd  0x78(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0x80(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0x88(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0x90(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0x98(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x90(%rdx)
movsd  0x98(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
mulsd  0x78(%rsi),%xmm1
movsd  0x48(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x80(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0x88(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0x90(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0x98(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x98(%rdx)
movsd  0xa0(%rdx),%xmm0
movsd  (%rdi),%xmm1
movsd  0x28(%rdi),%xmm2
mulsd  0xa0(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0xa8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x50(%rdi),%xmm1
mulsd  0xb0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x78(%rdi),%xmm1
mulsd  0xb8(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa0(%rdi),%xmm1
mulsd  0xc0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0xa0(%rdx)
movsd  0xa8(%rdx),%xmm0
movsd  0x8(%rdi),%xmm1
mulsd  0xa0(%rsi),%xmm1
movsd  0x30(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0xa8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x58(%rdi),%xmm1
mulsd  0xb0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x80(%rdi),%xmm1
mulsd  0xb8(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xa8(%rdi),%xmm1
mulsd  0xc0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0xa8(%rdx)
movsd  0xb0(%rdx),%xmm0
movsd  0x10(%rdi),%xmm1
movsd  0x38(%rdi),%xmm2
mulsd  0xa0(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0xa8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x60(%rdi),%xmm1
mulsd  0xb0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x88(%rdi),%xmm1
mulsd  0xb8(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb0(%rdi),%xmm1
mulsd  0xc0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0xb0(%rdx)
movsd  0xb8(%rdx),%xmm0
movsd  0x18(%rdi),%xmm1
mulsd  0xa0(%rsi),%xmm1
movsd  0x40(%rdi),%xmm2
subsd  %xmm1,%xmm0
mulsd  0xa8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x68(%rdi),%xmm1
mulsd  0xb0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x90(%rdi),%xmm1
mulsd  0xb8(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xb8(%rdi),%xmm1
mulsd  0xc0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0xb8(%rdx)
movsd  0xc0(%rdx),%xmm0
movsd  0x20(%rdi),%xmm1
movsd  0x48(%rdi),%xmm2
mulsd  0xa0(%rsi),%xmm1
subsd  %xmm1,%xmm0
mulsd  0xa8(%rsi),%xmm2
subsd  %xmm2,%xmm0
movsd  0x70(%rdi),%xmm1
mulsd  0xb0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0x98(%rdi),%xmm1
mulsd  0xb8(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc0(%rdi),%xmm1
mulsd  0xc0(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0xc0(%rdx)
ret

LLVM IR (-O0):
define void @matmul_sub([5 x double]* %0, [5 x double]* %1, [5 x double]* %2) {
%4 = alloca [5 x double]*
%5 = alloca [5 x double]*
%6 = alloca [5 x double]*
store [5 x double]* %0, [5 x double]** %4
store [5 x double]* %1, [5 x double]** %5
store [5 x double]* %2, [5 x double]** %6
%7 = load [5 x double]*, [5 x double]** %6
%8 = getelementptr inbounds [5 x double], [5 x double]* %7, i64 0
%9 = getelementptr inbounds [5 x double], [5 x double]* %8, i64 0, i64 0
%10 = load double, double* %9
%11 = load [5 x double]*, [5 x double]** %4
%12 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0
%13 = getelementptr inbounds [5 x double], [5 x double]* %12, i64 0, i64 0
%14 = load double, double* %13
%15 = load [5 x double]*, [5 x double]** %5
%16 = getelementptr inbounds [5 x double], [5 x double]* %15, i64 0
%17 = getelementptr inbounds [5 x double], [5 x double]* %16, i64 0, i64 0
%18 = load double, double* %17
%19 = fneg double %14
%20 = call double @llvm.fmuladd.f64(double %19, double %18, double %10)
%21 = load [5 x double]*, [5 x double]** %4
%22 = getelementptr inbounds [5 x double], [5 x double]* %21, i64 1
%23 = getelementptr inbounds [5 x double], [5 x double]* %22, i64 0, i64 0
%24 = load double, double* %23
%25 = load [5 x double]*, [5 x double]** %5
%26 = getelementptr inbounds [5 x double], [5 x double]* %25, i64 0
%27 = getelementptr inbounds [5 x double], [5 x double]* %26, i64 0, i64 1
%28 = load double, double* %27
%29 = fneg double %24
%30 = call double @llvm.fmuladd.f64(double %29, double %28, double %20)
%31 = load [5 x double]*, [5 x double]** %4
%32 = getelementptr inbounds [5 x double], [5 x double]* %31, i64 2
%33 = getelementptr inbounds [5 x double], [5 x double]* %32, i64 0, i64 0
%34 = load double, double* %33
%35 = load [5 x double]*, [5 x double]** %5
%36 = getelementptr inbounds [5 x double], [5 x double]* %35, i64 0
%37 = getelementptr inbounds [5 x double], [5 x double]* %36, i64 0, i64 2
%38 = load double, double* %37
%39 = fneg double %34
%40 = call double @llvm.fmuladd.f64(double %39, double %38, double %30)
%41 = load [5 x double]*, [5 x double]** %4
%42 = getelementptr inbounds [5 x double], [5 x double]* %41, i64 3
%43 = getelementptr inbounds [5 x double], [5 x double]* %42, i64 0, i64 0
%44 = load double, double* %43
%45 = load [5 x double]*, [5 x double]** %5
%46 = getelementptr inbounds [5 x double], [5 x double]* %45, i64 0
%47 = getelementptr inbounds [5 x double], [5 x double]* %46, i64 0, i64 3
%48 = load double, double* %47
%49 = fneg double %44
%50 = call double @llvm.fmuladd.f64(double %49, double %48, double %40)
%51 = load [5 x double]*, [5 x double]** %4
%52 = getelementptr inbounds [5 x double], [5 x double]* %51, i64 4
%53 = getelementptr inbounds [5 x double], [5 x double]* %52, i64 0, i64 0
%54 = load double, double* %53
%55 = load [5 x double]*, [5 x double]** %5
%56 = getelementptr inbounds [5 x double], [5 x double]* %55, i64 0
%57 = getelementptr inbounds [5 x double], [5 x double]* %56, i64 0, i64 4
%58 = load double, double* %57
%59 = fneg double %54
%60 = call double @llvm.fmuladd.f64(double %59, double %58, double %50)
%61 = load [5 x double]*, [5 x double]** %6
%62 = getelementptr inbounds [5 x double], [5 x double]* %61, i64 0
%63 = getelementptr inbounds [5 x double], [5 x double]* %62, i64 0, i64 0
store double %60, double* %63
%64 = load [5 x double]*, [5 x double]** %6
%65 = getelementptr inbounds [5 x double], [5 x double]* %64, i64 0
%66 = getelementptr inbounds [5 x double], [5 x double]* %65, i64 0, i64 1
%67 = load double, double* %66
%68 = load [5 x double]*, [5 x double]** %4
%69 = getelementptr inbounds [5 x double], [5 x double]* %68, i64 0
%70 = getelementptr inbounds [5 x double], [5 x double]* %69, i64 0, i64 1
%71 = load double, double* %70
%72 = load [5 x double]*, [5 x double]** %5
%73 = getelementptr inbounds [5 x double], [5 x double]* %72, i64 0
%74 = getelementptr inbounds [5 x double], [5 x double]* %73, i64 0, i64 0
%75 = load double, double* %74
%76 = fneg double %71
%77 = call double @llvm.fmuladd.f64(double %76, double %75, double %67)
%78 = load [5 x double]*, [5 x double]** %4
%79 = getelementptr inbounds [5 x double], [5 x double]* %78, i64 1
%80 = getelementptr inbounds [5 x double], [5 x double]* %79, i64 0, i64 1
%81 = load double, double* %80
%82 = load [5 x double]*, [5 x double]** %5
%83 = getelementptr inbounds [5 x double], [5 x double]* %82, i64 0
%84 = getelementptr inbounds [5 x double], [5 x double]* %83, i64 0, i64 1
%85 = load double, double* %84
%86 = fneg double %81
%87 = call double @llvm.fmuladd.f64(double %86, double %85, double %77)
%88 = load [5 x double]*, [5 x double]** %4
%89 = getelementptr inbounds [5 x double], [5 x double]* %88, i64 2
%90 = getelementptr inbounds [5 x double], [5 x double]* %89, i64 0, i64 1
%91 = load double, double* %90
%92 = load [5 x double]*, [5 x double]** %5
%93 = getelementptr inbounds [5 x double], [5 x double]* %92, i64 0
%94 = getelementptr inbounds [5 x double], [5 x double]* %93, i64 0, i64 2
%95 = load double, double* %94
%96 = fneg double %91
%97 = call double @llvm.fmuladd.f64(double %96, double %95, double %87)
%98 = load [5 x double]*, [5 x double]** %4
%99 = getelementptr inbounds [5 x double], [5 x double]* %98, i64 3
%100 = getelementptr inbounds [5 x double], [5 x double]* %99, i64 0, i64 1
%101 = load double, double* %100
%102 = load [5 x double]*, [5 x double]** %5
%103 = getelementptr inbounds [5 x double], [5 x double]* %102, i64 0
%104 = getelementptr inbounds [5 x double], [5 x double]* %103, i64 0, i64 3
%105 = load double, double* %104
%106 = fneg double %101
%107 = call double @llvm.fmuladd.f64(double %106, double %105, double %97)
%108 = load [5 x double]*, [5 x double]** %4
%109 = getelementptr inbounds [5 x double], [5 x double]* %108, i64 4
%110 = getelementptr inbounds [5 x double], [5 x double]* %109, i64 0, i64 1
%111 = load double, double* %110
%112 = load [5 x double]*, [5 x double]** %5
%113 = getelementptr inbounds [5 x double], [5 x double]* %112, i64 0
%114 = getelementptr inbounds [5 x double], [5 x double]* %113, i64 0, i64 4
%115 = load double, double* %114
%116 = fneg double %111
%117 = call double @llvm.fmuladd.f64(double %116, double %115, double %107)
%118 = load [5 x double]*, [5 x double]** %6
%119 = getelementptr inbounds [5 x double], [5 x double]* %118, i64 0
%120 = getelementptr inbounds [5 x double], [5 x double]* %119, i64 0, i64 1
store double %117, double* %120
%121 = load [5 x double]*, [5 x double]** %6
%122 = getelementptr inbounds [5 x double], [5 x double]* %121, i64 0
%123 = getelementptr inbounds [5 x double], [5 x double]* %122, i64 0, i64 2
%124 = load double, double* %123
%125 = load [5 x double]*, [5 x double]** %4
%126 = getelementptr inbounds [5 x double], [5 x double]* %125, i64 0
%127 = getelementptr inbounds [5 x double], [5 x double]* %126, i64 0, i64 2
%128 = load double, double* %127
%129 = load [5 x double]*, [5 x double]** %5
%130 = getelementptr inbounds [5 x double], [5 x double]* %129, i64 0
%131 = getelementptr inbounds [5 x double], [5 x double]* %130, i64 0, i64 0
%132 = load double, double* %131
%133 = fneg double %128
%134 = call double @llvm.fmuladd.f64(double %133, double %132, double %124)
%135 = load [5 x double]*, [5 x double]** %4
%136 = getelementptr inbounds [5 x double], [5 x double]* %135, i64 1
%137 = getelementptr inbounds [5 x double], [5 x double]* %136, i64 0, i64 2
%138 = load double, double* %137
%139 = load [5 x double]*, [5 x double]** %5
%140 = getelementptr inbounds [5 x double], [5 x double]* %139, i64 0
%141 = getelementptr inbounds [5 x double], [5 x double]* %140, i64 0, i64 1
%142 = load double, double* %141
%143 = fneg double %138
%144 = call double @llvm.fmuladd.f64(double %143, double %142, double %134)
%145 = load [5 x double]*, [5 x double]** %4
%146 = getelementptr inbounds [5 x double], [5 x double]* %145, i64 2
%147 = getelementptr inbounds [5 x double], [5 x double]* %146, i64 0, i64 2
%148 = load double, double* %147
%149 = load [5 x double]*, [5 x double]** %5
%150 = getelementptr inbounds [5 x double], [5 x double]* %149, i64 0
%151 = getelementptr inbounds [5 x double], [5 x double]* %150, i64 0, i64 2
%152 = load double, double* %151
%153 = fneg double %148
%154 = call double @llvm.fmuladd.f64(double %153, double %152, double %144)
%155 = load [5 x double]*, [5 x double]** %4
%156 = getelementptr inbounds [5 x double], [5 x double]* %155, i64 3
%157 = getelementptr inbounds [5 x double], [5 x double]* %156, i64 0, i64 2
%158 = load double, double* %157
%159 = load [5 x double]*, [5 x double]** %5
%160 = getelementptr inbounds [5 x double], [5 x double]* %159, i64 0
%161 = getelementptr inbounds [5 x double], [5 x double]* %160, i64 0, i64 3
%162 = load double, double* %161
%163 = fneg double %158
%164 = call double @llvm.fmuladd.f64(double %163, double %162, double %154)
%165 = load [5 x double]*, [5 x double]** %4
%166 = getelementptr inbounds [5 x double], [5 x double]* %165, i64 4
%167 = getelementptr inbounds [5 x double], [5 x double]* %166, i64 0, i64 2
%168 = load double, double* %167
%169 = load [5 x double]*, [5 x double]** %5
%170 = getelementptr inbounds [5 x double], [5 x double]* %169, i64 0
%171 = getelementptr inbounds [5 x double], [5 x double]* %170, i64 0, i64 4
%172 = load double, double* %171
%173 = fneg double %168
%174 = call double @llvm.fmuladd.f64(double %173, double %172, double %164)
%175 = load [5 x double]*, [5 x double]** %6
%176 = getelementptr inbounds [5 x double], [5 x double]* %175, i64 0
%177 = getelementptr inbounds [5 x double], [5 x double]* %176, i64 0, i64 2
store double %174, double* %177
%178 = load [5 x double]*, [5 x double]** %6
%179 = getelementptr inbounds [5 x double], [5 x double]* %178, i64 0
%180 = getelementptr inbounds [5 x double], [5 x double]* %179, i64 0, i64 3
%181 = load double, double* %180
%182 = load [5 x double]*, [5 x double]** %4
%183 = getelementptr inbounds [5 x double], [5 x double]* %182, i64 0
%184 = getelementptr inbounds [5 x double], [5 x double]* %183, i64 0, i64 3
%185 = load double, double* %184
%186 = load [5 x double]*, [5 x double]** %5
%187 = getelementptr inbounds [5 x double], [5 x double]* %186, i64 0
%188 = getelementptr inbounds [5 x double], [5 x double]* %187, i64 0, i64 0
%189 = load double, double* %188
%190 = fneg double %185
%191 = call double @llvm.fmuladd.f64(double %190, double %189, double %181)
%192 = load [5 x double]*, [5 x double]** %4
%193 = getelementptr inbounds [5 x double], [5 x double]* %192, i64 1
%194 = getelementptr inbounds [5 x double], [5 x double]* %193, i64 0, i64 3
%195 = load double, double* %194
%196 = load [5 x double]*, [5 x double]** %5
%197 = getelementptr inbounds [5 x double], [5 x double]* %196, i64 0
%198 = getelementptr inbounds [5 x double], [5 x double]* %197, i64 0, i64 1
%199 = load double, double* %198
%200 = fneg double %195
%201 = call double @llvm.fmuladd.f64(double %200, double %199, double %191)
%202 = load [5 x double]*, [5 x double]** %4
%203 = getelementptr inbounds [5 x double], [5 x double]* %202, i64 2
%204 = getelementptr inbounds [5 x double], [5 x double]* %203, i64 0, i64 3
%205 = load double, double* %204
%206 = load [5 x double]*, [5 x double]** %5
%207 = getelementptr inbounds [5 x double], [5 x double]* %206, i64 0
%208 = getelementptr inbounds [5 x double], [5 x double]* %207, i64 0, i64 2
%209 = load double, double* %208
%210 = fneg double %205
%211 = call double @llvm.fmuladd.f64(double %210, double %209, double %201)
%212 = load [5 x double]*, [5 x double]** %4
%213 = getelementptr inbounds [5 x double], [5 x double]* %212, i64 3
%214 = getelementptr inbounds [5 x double], [5 x double]* %213, i64 0, i64 3
%215 = load double, double* %214
%216 = load [5 x double]*, [5 x double]** %5
%217 = getelementptr inbounds [5 x double], [5 x double]* %216, i64 0
%218 = getelementptr inbounds [5 x double], [5 x double]* %217, i64 0, i64 3
%219 = load double, double* %218
%220 = fneg double %215
%221 = call double @llvm.fmuladd.f64(double %220, double %219, double %211)
%222 = load [5 x double]*, [5 x double]** %4
%223 = getelementptr inbounds [5 x double], [5 x double]* %222, i64 4
%224 = getelementptr inbounds [5 x double], [5 x double]* %223, i64 0, i64 3
%225 = load double, double* %224
%226 = load [5 x double]*, [5 x double]** %5
%227 = getelementptr inbounds [5 x double], [5 x double]* %226, i64 0
%228 = getelementptr inbounds [5 x double], [5 x double]* %227, i64 0, i64 4
%229 = load double, double* %228
%230 = fneg double %225
%231 = call double @llvm.fmuladd.f64(double %230, double %229, double %221)
%232 = load [5 x double]*, [5 x double]** %6
%233 = getelementptr inbounds [5 x double], [5 x double]* %232, i64 0
%234 = getelementptr inbounds [5 x double], [5 x double]* %233, i64 0, i64 3
store double %231, double* %234
%235 = load [5 x double]*, [5 x double]** %6
%236 = getelementptr inbounds [5 x double], [5 x double]* %235, i64 0
%237 = getelementptr inbounds [5 x double], [5 x double]* %236, i64 0, i64 4
%238 = load double, double* %237
%239 = load [5 x double]*, [5 x double]** %4
%240 = getelementptr inbounds [5 x double], [5 x double]* %239, i64 0
%241 = getelementptr inbounds [5 x double], [5 x double]* %240, i64 0, i64 4
%242 = load double, double* %241
%243 = load [5 x double]*, [5 x double]** %5
%244 = getelementptr inbounds [5 x double], [5 x double]* %243, i64 0
%245 = getelementptr inbounds [5 x double], [5 x double]* %244, i64 0, i64 0
%246 = load double, double* %245
%247 = fneg double %242
%248 = call double @llvm.fmuladd.f64(double %247, double %246, double %238)
%249 = load [5 x double]*, [5 x double]** %4
%250 = getelementptr inbounds [5 x double], [5 x double]* %249, i64 1
%251 = getelementptr inbounds [5 x double], [5 x double]* %250, i64 0, i64 4
%252 = load double, double* %251
%253 = load [5 x double]*, [5 x double]** %5
%254 = getelementptr inbounds [5 x double], [5 x double]* %253, i64 0
%255 = getelementptr inbounds [5 x double], [5 x double]* %254, i64 0, i64 1
%256 = load double, double* %255
%257 = fneg double %252
%258 = call double @llvm.fmuladd.f64(double %257, double %256, double %248)
%259 = load [5 x double]*, [5 x double]** %4
%260 = getelementptr inbounds [5 x double], [5 x double]* %259, i64 2
%261 = getelementptr inbounds [5 x double], [5 x double]* %260, i64 0, i64 4
%262 = load double, double* %261
%263 = load [5 x double]*, [5 x double]** %5
%264 = getelementptr inbounds [5 x double], [5 x double]* %263, i64 0
%265 = getelementptr inbounds [5 x double], [5 x double]* %264, i64 0, i64 2
%266 = load double, double* %265
%267 = fneg double %262
%268 = call double @llvm.fmuladd.f64(double %267, double %266, double %258)
%269 = load [5 x double]*, [5 x double]** %4
%270 = getelementptr inbounds [5 x double], [5 x double]* %269, i64 3
%271 = getelementptr inbounds [5 x double], [5 x double]* %270, i64 0, i64 4
%272 = load double, double* %271
%273 = load [5 x double]*, [5 x double]** %5
%274 = getelementptr inbounds [5 x double], [5 x double]* %273, i64 0
%275 = getelementptr inbounds [5 x double], [5 x double]* %274, i64 0, i64 3
%276 = load double, double* %275
%277 = fneg double %272
%278 = call double @llvm.fmuladd.f64(double %277, double %276, double %268)
%279 = load [5 x double]*, [5 x double]** %4
%280 = getelementptr inbounds [5 x double], [5 x double]* %279, i64 4
%281 = getelementptr inbounds [5 x double], [5 x double]* %280, i64 0, i64 4
%282 = load double, double* %281
%283 = load [5 x double]*, [5 x double]** %5
%284 = getelementptr inbounds [5 x double], [5 x double]* %283, i64 0
%285 = getelementptr inbounds [5 x double], [5 x double]* %284, i64 0, i64 4
%286 = load double, double* %285
%287 = fneg double %282
%288 = call double @llvm.fmuladd.f64(double %287, double %286, double %278)
%289 = load [5 x double]*, [5 x double]** %6
%290 = getelementptr inbounds [5 x double], [5 x double]* %289, i64 0
%291 = getelementptr inbounds [5 x double], [5 x double]* %290, i64 0, i64 4
store double %288, double* %291
%292 = load [5 x double]*, [5 x double]** %6
%293 = getelementptr inbounds [5 x double], [5 x double]* %292, i64 1
%294 = getelementptr inbounds [5 x double], [5 x double]* %293, i64 0, i64 0
%295 = load double, double* %294
%296 = load [5 x double]*, [5 x double]** %4
%297 = getelementptr inbounds [5 x double], [5 x double]* %296, i64 0
%298 = getelementptr inbounds [5 x double], [5 x double]* %297, i64 0, i64 0
%299 = load double, double* %298
%300 = load [5 x double]*, [5 x double]** %5
%301 = getelementptr inbounds [5 x double], [5 x double]* %300, i64 1
%302 = getelementptr inbounds [5 x double], [5 x double]* %301, i64 0, i64 0
%303 = load double, double* %302
%304 = fneg double %299
%305 = call double @llvm.fmuladd.f64(double %304, double %303, double %295)
%306 = load [5 x double]*, [5 x double]** %4
%307 = getelementptr inbounds [5 x double], [5 x double]* %306, i64 1
%308 = getelementptr inbounds [5 x double], [5 x double]* %307, i64 0, i64 0
%309 = load double, double* %308
%310 = load [5 x double]*, [5 x double]** %5
%311 = getelementptr inbounds [5 x double], [5 x double]* %310, i64 1
%312 = getelementptr inbounds [5 x double], [5 x double]* %311, i64 0, i64 1
%313 = load double, double* %312
%314 = fneg double %309
%315 = call double @llvm.fmuladd.f64(double %314, double %313, double %305)
%316 = load [5 x double]*, [5 x double]** %4
%317 = getelementptr inbounds [5 x double], [5 x double]* %316, i64 2
%318 = getelementptr inbounds [5 x double], [5 x double]* %317, i64 0, i64 0
%319 = load double, double* %318
%320 = load [5 x double]*, [5 x double]** %5
%321 = getelementptr inbounds [5 x double], [5 x double]* %320, i64 1
%322 = getelementptr inbounds [5 x double], [5 x double]* %321, i64 0, i64 2
%323 = load double, double* %322
%324 = fneg double %319
%325 = call double @llvm.fmuladd.f64(double %324, double %323, double %315)
%326 = load [5 x double]*, [5 x double]** %4
%327 = getelementptr inbounds [5 x double], [5 x double]* %326, i64 3
%328 = getelementptr inbounds [5 x double], [5 x double]* %327, i64 0, i64 0
%329 = load double, double* %328
%330 = load [5 x double]*, [5 x double]** %5
%331 = getelementptr inbounds [5 x double], [5 x double]* %330, i64 1
%332 = getelementptr inbounds [5 x double], [5 x double]* %331, i64 0, i64 3
%333 = load double, double* %332
%334 = fneg double %329
%335 = call double @llvm.fmuladd.f64(double %334, double %333, double %325)
%336 = load [5 x double]*, [5 x double]** %4
%337 = getelementptr inbounds [5 x double], [5 x double]* %336, i64 4
%338 = getelementptr inbounds [5 x double], [5 x double]* %337, i64 0, i64 0
%339 = load double, double* %338
%340 = load [5 x double]*, [5 x double]** %5
%341 = getelementptr inbounds [5 x double], [5 x double]* %340, i64 1
%342 = getelementptr inbounds [5 x double], [5 x double]* %341, i64 0, i64 4
%343 = load double, double* %342
%344 = fneg double %339
%345 = call double @llvm.fmuladd.f64(double %344, double %343, double %335)
%346 = load [5 x double]*, [5 x double]** %6
%347 = getelementptr inbounds [5 x double], [5 x double]* %346, i64 1
%348 = getelementptr inbounds [5 x double], [5 x double]* %347, i64 0, i64 0
store double %345, double* %348
%349 = load [5 x double]*, [5 x double]** %6
%350 = getelementptr inbounds [5 x double], [5 x double]* %349, i64 1
%351 = getelementptr inbounds [5 x double], [5 x double]* %350, i64 0, i64 1
%352 = load double, double* %351
%353 = load [5 x double]*, [5 x double]** %4
%354 = getelementptr inbounds [5 x double], [5 x double]* %353, i64 0
%355 = getelementptr inbounds [5 x double], [5 x double]* %354, i64 0, i64 1
%356 = load double, double* %355
%357 = load [5 x double]*, [5 x double]** %5
%358 = getelementptr inbounds [5 x double], [5 x double]* %357, i64 1
%359 = getelementptr inbounds [5 x double], [5 x double]* %358, i64 0, i64 0
%360 = load double, double* %359
%361 = fneg double %356
%362 = call double @llvm.fmuladd.f64(double %361, double %360, double %352)
%363 = load [5 x double]*, [5 x double]** %4
%364 = getelementptr inbounds [5 x double], [5 x double]* %363, i64 1
%365 = getelementptr inbounds [5 x double], [5 x double]* %364, i64 0, i64 1
%366 = load double, double* %365
%367 = load [5 x double]*, [5 x double]** %5
%368 = getelementptr inbounds [5 x double], [5 x double]* %367, i64 1
%369 = getelementptr inbounds [5 x double], [5 x double]* %368, i64 0, i64 1
%370 = load double, double* %369
%371 = fneg double %366
%372 = call double @llvm.fmuladd.f64(double %371, double %370, double %362)
%373 = load [5 x double]*, [5 x double]** %4
%374 = getelementptr inbounds [5 x double], [5 x double]* %373, i64 2
%375 = getelementptr inbounds [5 x double], [5 x double]* %374, i64 0, i64 1
%376 = load double, double* %375
%377 = load [5 x double]*, [5 x double]** %5
%378 = getelementptr inbounds [5 x double], [5 x double]* %377, i64 1
%379 = getelementptr inbounds [5 x double], [5 x double]* %378, i64 0, i64 2
%380 = load double, double* %379
%381 = fneg double %376
%382 = call double @llvm.fmuladd.f64(double %381, double %380, double %372)
%383 = load [5 x double]*, [5 x double]** %4
%384 = getelementptr inbounds [5 x double], [5 x double]* %383, i64 3
%385 = getelementptr inbounds [5 x double], [5 x double]* %384, i64 0, i64 1
%386 = load double, double* %385
%387 = load [5 x double]*, [5 x double]** %5
%388 = getelementptr inbounds [5 x double], [5 x double]* %387, i64 1
%389 = getelementptr inbounds [5 x double], [5 x double]* %388, i64 0, i64 3
%390 = load double, double* %389
%391 = fneg double %386
%392 = call double @llvm.fmuladd.f64(double %391, double %390, double %382)
%393 = load [5 x double]*, [5 x double]** %4
%394 = getelementptr inbounds [5 x double], [5 x double]* %393, i64 4
%395 = getelementptr inbounds [5 x double], [5 x double]* %394, i64 0, i64 1
%396 = load double, double* %395
%397 = load [5 x double]*, [5 x double]** %5
%398 = getelementptr inbounds [5 x double], [5 x double]* %397, i64 1
%399 = getelementptr inbounds [5 x double], [5 x double]* %398, i64 0, i64 4
%400 = load double, double* %399
%401 = fneg double %396
%402 = call double @llvm.fmuladd.f64(double %401, double %400, double %392)
%403 = load [5 x double]*, [5 x double]** %6
%404 = getelementptr inbounds [5 x double], [5 x double]* %403, i64 1
%405 = getelementptr inbounds [5 x double], [5 x double]* %404, i64 0, i64 1
store double %402, double* %405
%406 = load [5 x double]*, [5 x double]** %6
%407 = getelementptr inbounds [5 x double], [5 x double]* %406, i64 1
%408 = getelementptr inbounds [5 x double], [5 x double]* %407, i64 0, i64 2
%409 = load double, double* %408
%410 = load [5 x double]*, [5 x double]** %4
%411 = getelementptr inbounds [5 x double], [5 x double]* %410, i64 0
%412 = getelementptr inbounds [5 x double], [5 x double]* %411, i64 0, i64 2
%413 = load double, double* %412
%414 = load [5 x double]*, [5 x double]** %5
%415 = getelementptr inbounds [5 x double], [5 x double]* %414, i64 1
%416 = getelementptr inbounds [5 x double], [5 x double]* %415, i64 0, i64 0
%417 = load double, double* %416
%418 = fneg double %413
%419 = call double @llvm.fmuladd.f64(double %418, double %417, double %409)
%420 = load [5 x double]*, [5 x double]** %4
%421 = getelementptr inbounds [5 x double], [5 x double]* %420, i64 1
%422 = getelementptr inbounds [5 x double], [5 x double]* %421, i64 0, i64 2
%423 = load double, double* %422
%424 = load [5 x double]*, [5 x double]** %5
%425 = getelementptr inbounds [5 x double], [5 x double]* %424, i64 1
%426 = getelementptr inbounds [5 x double], [5 x double]* %425, i64 0, i64 1
%427 = load double, double* %426
%428 = fneg double %423
%429 = call double @llvm.fmuladd.f64(double %428, double %427, double %419)
%430 = load [5 x double]*, [5 x double]** %4
%431 = getelementptr inbounds [5 x double], [5 x double]* %430, i64 2
%432 = getelementptr inbounds [5 x double], [5 x double]* %431, i64 0, i64 2
%433 = load double, double* %432
%434 = load [5 x double]*, [5 x double]** %5
%435 = getelementptr inbounds [5 x double], [5 x double]* %434, i64 1
%436 = getelementptr inbounds [5 x double], [5 x double]* %435, i64 0, i64 2
%437 = load double, double* %436
%438 = fneg double %433
%439 = call double @llvm.fmuladd.f64(double %438, double %437, double %429)
%440 = load [5 x double]*, [5 x double]** %4
%441 = getelementptr inbounds [5 x double], [5 x double]* %440, i64 3
%442 = getelementptr inbounds [5 x double], [5 x double]* %441, i64 0, i64 2
%443 = load double, double* %442
%444 = load [5 x double]*, [5 x double]** %5
%445 = getelementptr inbounds [5 x double], [5 x double]* %444, i64 1
%446 = getelementptr inbounds [5 x double], [5 x double]* %445, i64 0, i64 3
%447 = load double, double* %446
%448 = fneg double %443
%449 = call double @llvm.fmuladd.f64(double %448, double %447, double %439)
%450 = load [5 x double]*, [5 x double]** %4
%451 = getelementptr inbounds [5 x double], [5 x double]* %450, i64 4
%452 = getelementptr inbounds [5 x double], [5 x double]* %451, i64 0, i64 2
%453 = load double, double* %452
%454 = load [5 x double]*, [5 x double]** %5
%455 = getelementptr inbounds [5 x double], [5 x double]* %454, i64 1
%456 = getelementptr inbounds [5 x double], [5 x double]* %455, i64 0, i64 4
%457 = load double, double* %456
%458 = fneg double %453
%459 = call double @llvm.fmuladd.f64(double %458, double %457, double %449)
%460 = load [5 x double]*, [5 x double]** %6
%461 = getelementptr inbounds [5 x double], [5 x double]* %460, i64 1
%462 = getelementptr inbounds [5 x double], [5 x double]* %461, i64 0, i64 2
store double %459, double* %462
%463 = load [5 x double]*, [5 x double]** %6
%464 = getelementptr inbounds [5 x double], [5 x double]* %463, i64 1
%465 = getelementptr inbounds [5 x double], [5 x double]* %464, i64 0, i64 3
%466 = load double, double* %465
%467 = load [5 x double]*, [5 x double]** %4
%468 = getelementptr inbounds [5 x double], [5 x double]* %467, i64 0
%469 = getelementptr inbounds [5 x double], [5 x double]* %468, i64 0, i64 3
%470 = load double, double* %469
%471 = load [5 x double]*, [5 x double]** %5
%472 = getelementptr inbounds [5 x double], [5 x double]* %471, i64 1
%473 = getelementptr inbounds [5 x double], [5 x double]* %472, i64 0, i64 0
%474 = load double, double* %473
%475 = fneg double %470
%476 = call double @llvm.fmuladd.f64(double %475, double %474, double %466)
%477 = load [5 x double]*, [5 x double]** %4
%478 = getelementptr inbounds [5 x double], [5 x double]* %477, i64 1
%479 = getelementptr inbounds [5 x double], [5 x double]* %478, i64 0, i64 3
%480 = load double, double* %479
%481 = load [5 x double]*, [5 x double]** %5
%482 = getelementptr inbounds [5 x double], [5 x double]* %481, i64 1
%483 = getelementptr inbounds [5 x double], [5 x double]* %482, i64 0, i64 1
%484 = load double, double* %483
%485 = fneg double %480
%486 = call double @llvm.fmuladd.f64(double %485, double %484, double %476)
%487 = load [5 x double]*, [5 x double]** %4
%488 = getelementptr inbounds [5 x double], [5 x double]* %487, i64 2
%489 = getelementptr inbounds [5 x double], [5 x double]* %488, i64 0, i64 3
%490 = load double, double* %489
%491 = load [5 x double]*, [5 x double]** %5
%492 = getelementptr inbounds [5 x double], [5 x double]* %491, i64 1
%493 = getelementptr inbounds [5 x double], [5 x double]* %492, i64 0, i64 2
%494 = load double, double* %493
%495 = fneg double %490
%496 = call double @llvm.fmuladd.f64(double %495, double %494, double %486)
%497 = load [5 x double]*, [5 x double]** %4
%498 = getelementptr inbounds [5 x double], [5 x double]* %497, i64 3
%499 = getelementptr inbounds [5 x double], [5 x double]* %498, i64 0, i64 3
%500 = load double, double* %499
%501 = load [5 x double]*, [5 x double]** %5
%502 = getelementptr inbounds [5 x double], [5 x double]* %501, i64 1
%503 = getelementptr inbounds [5 x double], [5 x double]* %502, i64 0, i64 3
%504 = load double, double* %503
%505 = fneg double %500
%506 = call double @llvm.fmuladd.f64(double %505, double %504, double %496)
%507 = load [5 x double]*, [5 x double]** %4
%508 = getelementptr inbounds [5 x double], [5 x double]* %507, i64 4
%509 = getelementptr inbounds [5 x double], [5 x double]* %508, i64 0, i64 3
%510 = load double, double* %509
%511 = load [5 x double]*, [5 x double]** %5
%512 = getelementptr inbounds [5 x double], [5 x double]* %511, i64 1
%513 = getelementptr inbounds [5 x double], [5 x double]* %512, i64 0, i64 4
%514 = load double, double* %513
%515 = fneg double %510
%516 = call double @llvm.fmuladd.f64(double %515, double %514, double %506)
%517 = load [5 x double]*, [5 x double]** %6
%518 = getelementptr inbounds [5 x double], [5 x double]* %517, i64 1
%519 = getelementptr inbounds [5 x double], [5 x double]* %518, i64 0, i64 3
store double %516, double* %519
%520 = load [5 x double]*, [5 x double]** %6
%521 = getelementptr inbounds [5 x double], [5 x double]* %520, i64 1
%522 = getelementptr inbounds [5 x double], [5 x double]* %521, i64 0, i64 4
%523 = load double, double* %522
%524 = load [5 x double]*, [5 x double]** %4
%525 = getelementptr inbounds [5 x double], [5 x double]* %524, i64 0
%526 = getelementptr inbounds [5 x double], [5 x double]* %525, i64 0, i64 4
%527 = load double, double* %526
%528 = load [5 x double]*, [5 x double]** %5
%529 = getelementptr inbounds [5 x double], [5 x double]* %528, i64 1
%530 = getelementptr inbounds [5 x double], [5 x double]* %529, i64 0, i64 0
%531 = load double, double* %530
%532 = fneg double %527
%533 = call double @llvm.fmuladd.f64(double %532, double %531, double %523)
%534 = load [5 x double]*, [5 x double]** %4
%535 = getelementptr inbounds [5 x double], [5 x double]* %534, i64 1
%536 = getelementptr inbounds [5 x double], [5 x double]* %535, i64 0, i64 4
%537 = load double, double* %536
%538 = load [5 x double]*, [5 x double]** %5
%539 = getelementptr inbounds [5 x double], [5 x double]* %538, i64 1
%540 = getelementptr inbounds [5 x double], [5 x double]* %539, i64 0, i64 1
%541 = load double, double* %540
%542 = fneg double %537
%543 = call double @llvm.fmuladd.f64(double %542, double %541, double %533)
%544 = load [5 x double]*, [5 x double]** %4
%545 = getelementptr inbounds [5 x double], [5 x double]* %544, i64 2
%546 = getelementptr inbounds [5 x double], [5 x double]* %545, i64 0, i64 4
%547 = load double, double* %546
%548 = load [5 x double]*, [5 x double]** %5
%549 = getelementptr inbounds [5 x double], [5 x double]* %548, i64 1
%550 = getelementptr inbounds [5 x double], [5 x double]* %549, i64 0, i64 2
%551 = load double, double* %550
%552 = fneg double %547
%553 = call double @llvm.fmuladd.f64(double %552, double %551, double %543)
%554 = load [5 x double]*, [5 x double]** %4
%555 = getelementptr inbounds [5 x double], [5 x double]* %554, i64 3
%556 = getelementptr inbounds [5 x double], [5 x double]* %555, i64 0, i64 4
%557 = load double, double* %556
%558 = load [5 x double]*, [5 x double]** %5
%559 = getelementptr inbounds [5 x double], [5 x double]* %558, i64 1
%560 = getelementptr inbounds [5 x double], [5 x double]* %559, i64 0, i64 3
%561 = load double, double* %560
%562 = fneg double %557
%563 = call double @llvm.fmuladd.f64(double %562, double %561, double %553)
%564 = load [5 x double]*, [5 x double]** %4
%565 = getelementptr inbounds [5 x double], [5 x double]* %564, i64 4
%566 = getelementptr inbounds [5 x double], [5 x double]* %565, i64 0, i64 4
%567 = load double, double* %566
%568 = load [5 x double]*, [5 x double]** %5
%569 = getelementptr inbounds [5 x double], [5 x double]* %568, i64 1
%570 = getelementptr inbounds [5 x double], [5 x double]* %569, i64 0, i64 4
%571 = load double, double* %570
%572 = fneg double %567
%573 = call double @llvm.fmuladd.f64(double %572, double %571, double %563)
%574 = load [5 x double]*, [5 x double]** %6
%575 = getelementptr inbounds [5 x double], [5 x double]* %574, i64 1
%576 = getelementptr inbounds [5 x double], [5 x double]* %575, i64 0, i64 4
store double %573, double* %576
%577 = load [5 x double]*, [5 x double]** %6
%578 = getelementptr inbounds [5 x double], [5 x double]* %577, i64 2
%579 = getelementptr inbounds [5 x double], [5 x double]* %578, i64 0, i64 0
%580 = load double, double* %579
%581 = load [5 x double]*, [5 x double]** %4
%582 = getelementptr inbounds [5 x double], [5 x double]* %581, i64 0
%583 = getelementptr inbounds [5 x double], [5 x double]* %582, i64 0, i64 0
%584 = load double, double* %583
%585 = load [5 x double]*, [5 x double]** %5
%586 = getelementptr inbounds [5 x double], [5 x double]* %585, i64 2
%587 = getelementptr inbounds [5 x double], [5 x double]* %586, i64 0, i64 0
%588 = load double, double* %587
%589 = fneg double %584
%590 = call double @llvm.fmuladd.f64(double %589, double %588, double %580)
%591 = load [5 x double]*, [5 x double]** %4
%592 = getelementptr inbounds [5 x double], [5 x double]* %591, i64 1
%593 = getelementptr inbounds [5 x double], [5 x double]* %592, i64 0, i64 0
%594 = load double, double* %593
%595 = load [5 x double]*, [5 x double]** %5
%596 = getelementptr inbounds [5 x double], [5 x double]* %595, i64 2
%597 = getelementptr inbounds [5 x double], [5 x double]* %596, i64 0, i64 1
%598 = load double, double* %597
%599 = fneg double %594
%600 = call double @llvm.fmuladd.f64(double %599, double %598, double %590)
%601 = load [5 x double]*, [5 x double]** %4
%602 = getelementptr inbounds [5 x double], [5 x double]* %601, i64 2
%603 = getelementptr inbounds [5 x double], [5 x double]* %602, i64 0, i64 0
%604 = load double, double* %603
%605 = load [5 x double]*, [5 x double]** %5
%606 = getelementptr inbounds [5 x double], [5 x double]* %605, i64 2
%607 = getelementptr inbounds [5 x double], [5 x double]* %606, i64 0, i64 2
%608 = load double, double* %607
%609 = fneg double %604
%610 = call double @llvm.fmuladd.f64(double %609, double %608, double %600)
%611 = load [5 x double]*, [5 x double]** %4
%612 = getelementptr inbounds [5 x double], [5 x double]* %611, i64 3
%613 = getelementptr inbounds [5 x double], [5 x double]* %612, i64 0, i64 0
%614 = load double, double* %613
%615 = load [5 x double]*, [5 x double]** %5
%616 = getelementptr inbounds [5 x double], [5 x double]* %615, i64 2
%617 = getelementptr inbounds [5 x double], [5 x double]* %616, i64 0, i64 3
%618 = load double, double* %617
%619 = fneg double %614
%620 = call double @llvm.fmuladd.f64(double %619, double %618, double %610)
%621 = load [5 x double]*, [5 x double]** %4
%622 = getelementptr inbounds [5 x double], [5 x double]* %621, i64 4
%623 = getelementptr inbounds [5 x double], [5 x double]* %622, i64 0, i64 0
%624 = load double, double* %623
%625 = load [5 x double]*, [5 x double]** %5
%626 = getelementptr inbounds [5 x double], [5 x double]* %625, i64 2
%627 = getelementptr inbounds [5 x double], [5 x double]* %626, i64 0, i64 4
%628 = load double, double* %627
%629 = fneg double %624
%630 = call double @llvm.fmuladd.f64(double %629, double %628, double %620)
%631 = load [5 x double]*, [5 x double]** %6
%632 = getelementptr inbounds [5 x double], [5 x double]* %631, i64 2
%633 = getelementptr inbounds [5 x double], [5 x double]* %632, i64 0, i64 0
store double %630, double* %633
%634 = load [5 x double]*, [5 x double]** %6
%635 = getelementptr inbounds [5 x double], [5 x double]* %634, i64 2
%636 = getelementptr inbounds [5 x double], [5 x double]* %635, i64 0, i64 1
%637 = load double, double* %636
%638 = load [5 x double]*, [5 x double]** %4
%639 = getelementptr inbounds [5 x double], [5 x double]* %638, i64 0
%640 = getelementptr inbounds [5 x double], [5 x double]* %639, i64 0, i64 1
%641 = load double, double* %640
%642 = load [5 x double]*, [5 x double]** %5
%643 = getelementptr inbounds [5 x double], [5 x double]* %642, i64 2
%644 = getelementptr inbounds [5 x double], [5 x double]* %643, i64 0, i64 0
%645 = load double, double* %644
%646 = fneg double %641
%647 = call double @llvm.fmuladd.f64(double %646, double %645, double %637)
%648 = load [5 x double]*, [5 x double]** %4
%649 = getelementptr inbounds [5 x double], [5 x double]* %648, i64 1
%650 = getelementptr inbounds [5 x double], [5 x double]* %649, i64 0, i64 1
%651 = load double, double* %650
%652 = load [5 x double]*, [5 x double]** %5
%653 = getelementptr inbounds [5 x double], [5 x double]* %652, i64 2
%654 = getelementptr inbounds [5 x double], [5 x double]* %653, i64 0, i64 1
%655 = load double, double* %654
%656 = fneg double %651
%657 = call double @llvm.fmuladd.f64(double %656, double %655, double %647)
%658 = load [5 x double]*, [5 x double]** %4
%659 = getelementptr inbounds [5 x double], [5 x double]* %658, i64 2
%660 = getelementptr inbounds [5 x double], [5 x double]* %659, i64 0, i64 1
%661 = load double, double* %660
%662 = load [5 x double]*, [5 x double]** %5
%663 = getelementptr inbounds [5 x double], [5 x double]* %662, i64 2
%664 = getelementptr inbounds [5 x double], [5 x double]* %663, i64 0, i64 2
%665 = load double, double* %664
%666 = fneg double %661
%667 = call double @llvm.fmuladd.f64(double %666, double %665, double %657)
%668 = load [5 x double]*, [5 x double]** %4
%669 = getelementptr inbounds [5 x double], [5 x double]* %668, i64 3
%670 = getelementptr inbounds [5 x double], [5 x double]* %669, i64 0, i64 1
%671 = load double, double* %670
%672 = load [5 x double]*, [5 x double]** %5
%673 = getelementptr inbounds [5 x double], [5 x double]* %672, i64 2
%674 = getelementptr inbounds [5 x double], [5 x double]* %673, i64 0, i64 3
%675 = load double, double* %674
%676 = fneg double %671
%677 = call double @llvm.fmuladd.f64(double %676, double %675, double %667)
%678 = load [5 x double]*, [5 x double]** %4
%679 = getelementptr inbounds [5 x double], [5 x double]* %678, i64 4
%680 = getelementptr inbounds [5 x double], [5 x double]* %679, i64 0, i64 1
%681 = load double, double* %680
%682 = load [5 x double]*, [5 x double]** %5
%683 = getelementptr inbounds [5 x double], [5 x double]* %682, i64 2
%684 = getelementptr inbounds [5 x double], [5 x double]* %683, i64 0, i64 4
%685 = load double, double* %684
%686 = fneg double %681
%687 = call double @llvm.fmuladd.f64(double %686, double %685, double %677)
%688 = load [5 x double]*, [5 x double]** %6
%689 = getelementptr inbounds [5 x double], [5 x double]* %688, i64 2
%690 = getelementptr inbounds [5 x double], [5 x double]* %689, i64 0, i64 1
store double %687, double* %690
%691 = load [5 x double]*, [5 x double]** %6
%692 = getelementptr inbounds [5 x double], [5 x double]* %691, i64 2
%693 = getelementptr inbounds [5 x double], [5 x double]* %692, i64 0, i64 2
%694 = load double, double* %693
%695 = load [5 x double]*, [5 x double]** %4
%696 = getelementptr inbounds [5 x double], [5 x double]* %695, i64 0
%697 = getelementptr inbounds [5 x double], [5 x double]* %696, i64 0, i64 2
%698 = load double, double* %697
%699 = load [5 x double]*, [5 x double]** %5
%700 = getelementptr inbounds [5 x double], [5 x double]* %699, i64 2
%701 = getelementptr inbounds [5 x double], [5 x double]* %700, i64 0, i64 0
%702 = load double, double* %701
%703 = fneg double %698
%704 = call double @llvm.fmuladd.f64(double %703, double %702, double %694)
%705 = load [5 x double]*, [5 x double]** %4
%706 = getelementptr inbounds [5 x double], [5 x double]* %705, i64 1
%707 = getelementptr inbounds [5 x double], [5 x double]* %706, i64 0, i64 2
%708 = load double, double* %707
%709 = load [5 x double]*, [5 x double]** %5
%710 = getelementptr inbounds [5 x double], [5 x double]* %709, i64 2
%711 = getelementptr inbounds [5 x double], [5 x double]* %710, i64 0, i64 1
%712 = load double, double* %711
%713 = fneg double %708
%714 = call double @llvm.fmuladd.f64(double %713, double %712, double %704)
%715 = load [5 x double]*, [5 x double]** %4
%716 = getelementptr inbounds [5 x double], [5 x double]* %715, i64 2
%717 = getelementptr inbounds [5 x double], [5 x double]* %716, i64 0, i64 2
%718 = load double, double* %717
%719 = load [5 x double]*, [5 x double]** %5
%720 = getelementptr inbounds [5 x double], [5 x double]* %719, i64 2
%721 = getelementptr inbounds [5 x double], [5 x double]* %720, i64 0, i64 2
%722 = load double, double* %721
%723 = fneg double %718
%724 = call double @llvm.fmuladd.f64(double %723, double %722, double %714)
%725 = load [5 x double]*, [5 x double]** %4
%726 = getelementptr inbounds [5 x double], [5 x double]* %725, i64 3
%727 = getelementptr inbounds [5 x double], [5 x double]* %726, i64 0, i64 2
%728 = load double, double* %727
%729 = load [5 x double]*, [5 x double]** %5
%730 = getelementptr inbounds [5 x double], [5 x double]* %729, i64 2
%731 = getelementptr inbounds [5 x double], [5 x double]* %730, i64 0, i64 3
%732 = load double, double* %731
%733 = fneg double %728
%734 = call double @llvm.fmuladd.f64(double %733, double %732, double %724)
%735 = load [5 x double]*, [5 x double]** %4
%736 = getelementptr inbounds [5 x double], [5 x double]* %735, i64 4
%737 = getelementptr inbounds [5 x double], [5 x double]* %736, i64 0, i64 2
%738 = load double, double* %737
%739 = load [5 x double]*, [5 x double]** %5
%740 = getelementptr inbounds [5 x double], [5 x double]* %739, i64 2
%741 = getelementptr inbounds [5 x double], [5 x double]* %740, i64 0, i64 4
%742 = load double, double* %741
%743 = fneg double %738
%744 = call double @llvm.fmuladd.f64(double %743, double %742, double %734)
%745 = load [5 x double]*, [5 x double]** %6
%746 = getelementptr inbounds [5 x double], [5 x double]* %745, i64 2
%747 = getelementptr inbounds [5 x double], [5 x double]* %746, i64 0, i64 2
store double %744, double* %747
%748 = load [5 x double]*, [5 x double]** %6
%749 = getelementptr inbounds [5 x double], [5 x double]* %748, i64 2
%750 = getelementptr inbounds [5 x double], [5 x double]* %749, i64 0, i64 3
%751 = load double, double* %750
%752 = load [5 x double]*, [5 x double]** %4
%753 = getelementptr inbounds [5 x double], [5 x double]* %752, i64 0
%754 = getelementptr inbounds [5 x double], [5 x double]* %753, i64 0, i64 3
%755 = load double, double* %754
%756 = load [5 x double]*, [5 x double]** %5
%757 = getelementptr inbounds [5 x double], [5 x double]* %756, i64 2
%758 = getelementptr inbounds [5 x double], [5 x double]* %757, i64 0, i64 0
%759 = load double, double* %758
%760 = fneg double %755
%761 = call double @llvm.fmuladd.f64(double %760, double %759, double %751)
%762 = load [5 x double]*, [5 x double]** %4
%763 = getelementptr inbounds [5 x double], [5 x double]* %762, i64 1
%764 = getelementptr inbounds [5 x double], [5 x double]* %763, i64 0, i64 3
%765 = load double, double* %764
%766 = load [5 x double]*, [5 x double]** %5
%767 = getelementptr inbounds [5 x double], [5 x double]* %766, i64 2
%768 = getelementptr inbounds [5 x double], [5 x double]* %767, i64 0, i64 1
%769 = load double, double* %768
%770 = fneg double %765
%771 = call double @llvm.fmuladd.f64(double %770, double %769, double %761)
%772 = load [5 x double]*, [5 x double]** %4
%773 = getelementptr inbounds [5 x double], [5 x double]* %772, i64 2
%774 = getelementptr inbounds [5 x double], [5 x double]* %773, i64 0, i64 3
%775 = load double, double* %774
%776 = load [5 x double]*, [5 x double]** %5
%777 = getelementptr inbounds [5 x double], [5 x double]* %776, i64 2
%778 = getelementptr inbounds [5 x double], [5 x double]* %777, i64 0, i64 2
%779 = load double, double* %778
%780 = fneg double %775
%781 = call double @llvm.fmuladd.f64(double %780, double %779, double %771)
%782 = load [5 x double]*, [5 x double]** %4
%783 = getelementptr inbounds [5 x double], [5 x double]* %782, i64 3
%784 = getelementptr inbounds [5 x double], [5 x double]* %783, i64 0, i64 3
%785 = load double, double* %784
%786 = load [5 x double]*, [5 x double]** %5
%787 = getelementptr inbounds [5 x double], [5 x double]* %786, i64 2
%788 = getelementptr inbounds [5 x double], [5 x double]* %787, i64 0, i64 3
%789 = load double, double* %788
%790 = fneg double %785
%791 = call double @llvm.fmuladd.f64(double %790, double %789, double %781)
%792 = load [5 x double]*, [5 x double]** %4
%793 = getelementptr inbounds [5 x double], [5 x double]* %792, i64 4
%794 = getelementptr inbounds [5 x double], [5 x double]* %793, i64 0, i64 3
%795 = load double, double* %794
%796 = load [5 x double]*, [5 x double]** %5
%797 = getelementptr inbounds [5 x double], [5 x double]* %796, i64 2
%798 = getelementptr inbounds [5 x double], [5 x double]* %797, i64 0, i64 4
%799 = load double, double* %798
%800 = fneg double %795
%801 = call double @llvm.fmuladd.f64(double %800, double %799, double %791)
%802 = load [5 x double]*, [5 x double]** %6
%803 = getelementptr inbounds [5 x double], [5 x double]* %802, i64 2
%804 = getelementptr inbounds [5 x double], [5 x double]* %803, i64 0, i64 3
store double %801, double* %804
%805 = load [5 x double]*, [5 x double]** %6
%806 = getelementptr inbounds [5 x double], [5 x double]* %805, i64 2
%807 = getelementptr inbounds [5 x double], [5 x double]* %806, i64 0, i64 4
%808 = load double, double* %807
%809 = load [5 x double]*, [5 x double]** %4
%810 = getelementptr inbounds [5 x double], [5 x double]* %809, i64 0
%811 = getelementptr inbounds [5 x double], [5 x double]* %810, i64 0, i64 4
%812 = load double, double* %811
%813 = load [5 x double]*, [5 x double]** %5
%814 = getelementptr inbounds [5 x double], [5 x double]* %813, i64 2
%815 = getelementptr inbounds [5 x double], [5 x double]* %814, i64 0, i64 0
%816 = load double, double* %815
%817 = fneg double %812
%818 = call double @llvm.fmuladd.f64(double %817, double %816, double %808)
%819 = load [5 x double]*, [5 x double]** %4
%820 = getelementptr inbounds [5 x double], [5 x double]* %819, i64 1
%821 = getelementptr inbounds [5 x double], [5 x double]* %820, i64 0, i64 4
%822 = load double, double* %821
%823 = load [5 x double]*, [5 x double]** %5
%824 = getelementptr inbounds [5 x double], [5 x double]* %823, i64 2
%825 = getelementptr inbounds [5 x double], [5 x double]* %824, i64 0, i64 1
%826 = load double, double* %825
%827 = fneg double %822
%828 = call double @llvm.fmuladd.f64(double %827, double %826, double %818)
%829 = load [5 x double]*, [5 x double]** %4
%830 = getelementptr inbounds [5 x double], [5 x double]* %829, i64 2
%831 = getelementptr inbounds [5 x double], [5 x double]* %830, i64 0, i64 4
%832 = load double, double* %831
%833 = load [5 x double]*, [5 x double]** %5
%834 = getelementptr inbounds [5 x double], [5 x double]* %833, i64 2
%835 = getelementptr inbounds [5 x double], [5 x double]* %834, i64 0, i64 2
%836 = load double, double* %835
%837 = fneg double %832
%838 = call double @llvm.fmuladd.f64(double %837, double %836, double %828)
%839 = load [5 x double]*, [5 x double]** %4
%840 = getelementptr inbounds [5 x double], [5 x double]* %839, i64 3
%841 = getelementptr inbounds [5 x double], [5 x double]* %840, i64 0, i64 4
%842 = load double, double* %841
%843 = load [5 x double]*, [5 x double]** %5
%844 = getelementptr inbounds [5 x double], [5 x double]* %843, i64 2
%845 = getelementptr inbounds [5 x double], [5 x double]* %844, i64 0, i64 3
%846 = load double, double* %845
%847 = fneg double %842
%848 = call double @llvm.fmuladd.f64(double %847, double %846, double %838)
%849 = load [5 x double]*, [5 x double]** %4
%850 = getelementptr inbounds [5 x double], [5 x double]* %849, i64 4
%851 = getelementptr inbounds [5 x double], [5 x double]* %850, i64 0, i64 4
%852 = load double, double* %851
%853 = load [5 x double]*, [5 x double]** %5
%854 = getelementptr inbounds [5 x double], [5 x double]* %853, i64 2
%855 = getelementptr inbounds [5 x double], [5 x double]* %854, i64 0, i64 4
%856 = load double, double* %855
%857 = fneg double %852
%858 = call double @llvm.fmuladd.f64(double %857, double %856, double %848)
%859 = load [5 x double]*, [5 x double]** %6
%860 = getelementptr inbounds [5 x double], [5 x double]* %859, i64 2
%861 = getelementptr inbounds [5 x double], [5 x double]* %860, i64 0, i64 4
store double %858, double* %861
%862 = load [5 x double]*, [5 x double]** %6
%863 = getelementptr inbounds [5 x double], [5 x double]* %862, i64 3
%864 = getelementptr inbounds [5 x double], [5 x double]* %863, i64 0, i64 0
%865 = load double, double* %864
%866 = load [5 x double]*, [5 x double]** %4
%867 = getelementptr inbounds [5 x double], [5 x double]* %866, i64 0
%868 = getelementptr inbounds [5 x double], [5 x double]* %867, i64 0, i64 0
%869 = load double, double* %868
%870 = load [5 x double]*, [5 x double]** %5
%871 = getelementptr inbounds [5 x double], [5 x double]* %870, i64 3
%872 = getelementptr inbounds [5 x double], [5 x double]* %871, i64 0, i64 0
%873 = load double, double* %872
%874 = fneg double %869
%875 = call double @llvm.fmuladd.f64(double %874, double %873, double %865)
%876 = load [5 x double]*, [5 x double]** %4
%877 = getelementptr inbounds [5 x double], [5 x double]* %876, i64 1
%878 = getelementptr inbounds [5 x double], [5 x double]* %877, i64 0, i64 0
%879 = load double, double* %878
%880 = load [5 x double]*, [5 x double]** %5
%881 = getelementptr inbounds [5 x double], [5 x double]* %880, i64 3
%882 = getelementptr inbounds [5 x double], [5 x double]* %881, i64 0, i64 1
%883 = load double, double* %882
%884 = fneg double %879
%885 = call double @llvm.fmuladd.f64(double %884, double %883, double %875)
%886 = load [5 x double]*, [5 x double]** %4
%887 = getelementptr inbounds [5 x double], [5 x double]* %886, i64 2
%888 = getelementptr inbounds [5 x double], [5 x double]* %887, i64 0, i64 0
%889 = load double, double* %888
%890 = load [5 x double]*, [5 x double]** %5
%891 = getelementptr inbounds [5 x double], [5 x double]* %890, i64 3
%892 = getelementptr inbounds [5 x double], [5 x double]* %891, i64 0, i64 2
%893 = load double, double* %892
%894 = fneg double %889
%895 = call double @llvm.fmuladd.f64(double %894, double %893, double %885)
%896 = load [5 x double]*, [5 x double]** %4
%897 = getelementptr inbounds [5 x double], [5 x double]* %896, i64 3
%898 = getelementptr inbounds [5 x double], [5 x double]* %897, i64 0, i64 0
%899 = load double, double* %898
%900 = load [5 x double]*, [5 x double]** %5
%901 = getelementptr inbounds [5 x double], [5 x double]* %900, i64 3
%902 = getelementptr inbounds [5 x double], [5 x double]* %901, i64 0, i64 3
%903 = load double, double* %902
%904 = fneg double %899
%905 = call double @llvm.fmuladd.f64(double %904, double %903, double %895)
%906 = load [5 x double]*, [5 x double]** %4
%907 = getelementptr inbounds [5 x double], [5 x double]* %906, i64 4
%908 = getelementptr inbounds [5 x double], [5 x double]* %907, i64 0, i64 0
%909 = load double, double* %908
%910 = load [5 x double]*, [5 x double]** %5
%911 = getelementptr inbounds [5 x double], [5 x double]* %910, i64 3
%912 = getelementptr inbounds [5 x double], [5 x double]* %911, i64 0, i64 4
%913 = load double, double* %912
%914 = fneg double %909
%915 = call double @llvm.fmuladd.f64(double %914, double %913, double %905)
%916 = load [5 x double]*, [5 x double]** %6
%917 = getelementptr inbounds [5 x double], [5 x double]* %916, i64 3
%918 = getelementptr inbounds [5 x double], [5 x double]* %917, i64 0, i64 0
store double %915, double* %918
%919 = load [5 x double]*, [5 x double]** %6
%920 = getelementptr inbounds [5 x double], [5 x double]* %919, i64 3
%921 = getelementptr inbounds [5 x double], [5 x double]* %920, i64 0, i64 1
%922 = load double, double* %921
%923 = load [5 x double]*, [5 x double]** %4
%924 = getelementptr inbounds [5 x double], [5 x double]* %923, i64 0
%925 = getelementptr inbounds [5 x double], [5 x double]* %924, i64 0, i64 1
%926 = load double, double* %925
%927 = load [5 x double]*, [5 x double]** %5
%928 = getelementptr inbounds [5 x double], [5 x double]* %927, i64 3
%929 = getelementptr inbounds [5 x double], [5 x double]* %928, i64 0, i64 0
%930 = load double, double* %929
%931 = fneg double %926
%932 = call double @llvm.fmuladd.f64(double %931, double %930, double %922)
%933 = load [5 x double]*, [5 x double]** %4
%934 = getelementptr inbounds [5 x double], [5 x double]* %933, i64 1
%935 = getelementptr inbounds [5 x double], [5 x double]* %934, i64 0, i64 1
%936 = load double, double* %935
%937 = load [5 x double]*, [5 x double]** %5
%938 = getelementptr inbounds [5 x double], [5 x double]* %937, i64 3
%939 = getelementptr inbounds [5 x double], [5 x double]* %938, i64 0, i64 1
%940 = load double, double* %939
%941 = fneg double %936
%942 = call double @llvm.fmuladd.f64(double %941, double %940, double %932)
%943 = load [5 x double]*, [5 x double]** %4
%944 = getelementptr inbounds [5 x double], [5 x double]* %943, i64 2
%945 = getelementptr inbounds [5 x double], [5 x double]* %944, i64 0, i64 1
%946 = load double, double* %945
%947 = load [5 x double]*, [5 x double]** %5
%948 = getelementptr inbounds [5 x double], [5 x double]* %947, i64 3
%949 = getelementptr inbounds [5 x double], [5 x double]* %948, i64 0, i64 2
%950 = load double, double* %949
%951 = fneg double %946
%952 = call double @llvm.fmuladd.f64(double %951, double %950, double %942)
%953 = load [5 x double]*, [5 x double]** %4
%954 = getelementptr inbounds [5 x double], [5 x double]* %953, i64 3
%955 = getelementptr inbounds [5 x double], [5 x double]* %954, i64 0, i64 1
%956 = load double, double* %955
%957 = load [5 x double]*, [5 x double]** %5
%958 = getelementptr inbounds [5 x double], [5 x double]* %957, i64 3
%959 = getelementptr inbounds [5 x double], [5 x double]* %958, i64 0, i64 3
%960 = load double, double* %959
%961 = fneg double %956
%962 = call double @llvm.fmuladd.f64(double %961, double %960, double %952)
%963 = load [5 x double]*, [5 x double]** %4
%964 = getelementptr inbounds [5 x double], [5 x double]* %963, i64 4
%965 = getelementptr inbounds [5 x double], [5 x double]* %964, i64 0, i64 1
%966 = load double, double* %965
%967 = load [5 x double]*, [5 x double]** %5
%968 = getelementptr inbounds [5 x double], [5 x double]* %967, i64 3
%969 = getelementptr inbounds [5 x double], [5 x double]* %968, i64 0, i64 4
%970 = load double, double* %969
%971 = fneg double %966
%972 = call double @llvm.fmuladd.f64(double %971, double %970, double %962)
%973 = load [5 x double]*, [5 x double]** %6
%974 = getelementptr inbounds [5 x double], [5 x double]* %973, i64 3
%975 = getelementptr inbounds [5 x double], [5 x double]* %974, i64 0, i64 1
store double %972, double* %975
%976 = load [5 x double]*, [5 x double]** %6
%977 = getelementptr inbounds [5 x double], [5 x double]* %976, i64 3
%978 = getelementptr inbounds [5 x double], [5 x double]* %977, i64 0, i64 2
%979 = load double, double* %978
%980 = load [5 x double]*, [5 x double]** %4
%981 = getelementptr inbounds [5 x double], [5 x double]* %980, i64 0
%982 = getelementptr inbounds [5 x double], [5 x double]* %981, i64 0, i64 2
%983 = load double, double* %982
%984 = load [5 x double]*, [5 x double]** %5
%985 = getelementptr inbounds [5 x double], [5 x double]* %984, i64 3
%986 = getelementptr inbounds [5 x double], [5 x double]* %985, i64 0, i64 0
%987 = load double, double* %986
%988 = fneg double %983
%989 = call double @llvm.fmuladd.f64(double %988, double %987, double %979)
%990 = load [5 x double]*, [5 x double]** %4
%991 = getelementptr inbounds [5 x double], [5 x double]* %990, i64 1
%992 = getelementptr inbounds [5 x double], [5 x double]* %991, i64 0, i64 2
%993 = load double, double* %992
%994 = load [5 x double]*, [5 x double]** %5
%995 = getelementptr inbounds [5 x double], [5 x double]* %994, i64 3
%996 = getelementptr inbounds [5 x double], [5 x double]* %995, i64 0, i64 1
%997 = load double, double* %996
%998 = fneg double %993
%999 = call double @llvm.fmuladd.f64(double %998, double %997, double %989)
%1000 = load [5 x double]*, [5 x double]** %4
%1001 = getelementptr inbounds [5 x double], [5 x double]* %1000, i64 2
%1002 = getelementptr inbounds [5 x double], [5 x double]* %1001, i64 0, i64 2
%1003 = load double, double* %1002
%1004 = load [5 x double]*, [5 x double]** %5
%1005 = getelementptr inbounds [5 x double], [5 x double]* %1004, i64 3
%1006 = getelementptr inbounds [5 x double], [5 x double]* %1005, i64 0, i64 2
%1007 = load double, double* %1006
%1008 = fneg double %1003
%1009 = call double @llvm.fmuladd.f64(double %1008, double %1007, double %999)
%1010 = load [5 x double]*, [5 x double]** %4
%1011 = getelementptr inbounds [5 x double], [5 x double]* %1010, i64 3
%1012 = getelementptr inbounds [5 x double], [5 x double]* %1011, i64 0, i64 2
%1013 = load double, double* %1012
%1014 = load [5 x double]*, [5 x double]** %5
%1015 = getelementptr inbounds [5 x double], [5 x double]* %1014, i64 3
%1016 = getelementptr inbounds [5 x double], [5 x double]* %1015, i64 0, i64 3
%1017 = load double, double* %1016
%1018 = fneg double %1013
%1019 = call double @llvm.fmuladd.f64(double %1018, double %1017, double %1009)
%1020 = load [5 x double]*, [5 x double]** %4
%1021 = getelementptr inbounds [5 x double], [5 x double]* %1020, i64 4
%1022 = getelementptr inbounds [5 x double], [5 x double]* %1021, i64 0, i64 2
%1023 = load double, double* %1022
%1024 = load [5 x double]*, [5 x double]** %5
%1025 = getelementptr inbounds [5 x double], [5 x double]* %1024, i64 3
%1026 = getelementptr inbounds [5 x double], [5 x double]* %1025, i64 0, i64 4
%1027 = load double, double* %1026
%1028 = fneg double %1023
%1029 = call double @llvm.fmuladd.f64(double %1028, double %1027, double %1019)
%1030 = load [5 x double]*, [5 x double]** %6
%1031 = getelementptr inbounds [5 x double], [5 x double]* %1030, i64 3
%1032 = getelementptr inbounds [5 x double], [5 x double]* %1031, i64 0, i64 2
store double %1029, double* %1032
%1033 = load [5 x double]*, [5 x double]** %6
%1034 = getelementptr inbounds [5 x double], [5 x double]* %1033, i64 3
%1035 = getelementptr inbounds [5 x double], [5 x double]* %1034, i64 0, i64 3
%1036 = load double, double* %1035
%1037 = load [5 x double]*, [5 x double]** %4
%1038 = getelementptr inbounds [5 x double], [5 x double]* %1037, i64 0
%1039 = getelementptr inbounds [5 x double], [5 x double]* %1038, i64 0, i64 3
%1040 = load double, double* %1039
%1041 = load [5 x double]*, [5 x double]** %5
%1042 = getelementptr inbounds [5 x double], [5 x double]* %1041, i64 3
%1043 = getelementptr inbounds [5 x double], [5 x double]* %1042, i64 0, i64 0
%1044 = load double, double* %1043
%1045 = fneg double %1040
%1046 = call double @llvm.fmuladd.f64(double %1045, double %1044, double %1036)
%1047 = load [5 x double]*, [5 x double]** %4
%1048 = getelementptr inbounds [5 x double], [5 x double]* %1047, i64 1
%1049 = getelementptr inbounds [5 x double], [5 x double]* %1048, i64 0, i64 3
%1050 = load double, double* %1049
%1051 = load [5 x double]*, [5 x double]** %5
%1052 = getelementptr inbounds [5 x double], [5 x double]* %1051, i64 3
%1053 = getelementptr inbounds [5 x double], [5 x double]* %1052, i64 0, i64 1
%1054 = load double, double* %1053
%1055 = fneg double %1050
%1056 = call double @llvm.fmuladd.f64(double %1055, double %1054, double %1046)
%1057 = load [5 x double]*, [5 x double]** %4
%1058 = getelementptr inbounds [5 x double], [5 x double]* %1057, i64 2
%1059 = getelementptr inbounds [5 x double], [5 x double]* %1058, i64 0, i64 3
%1060 = load double, double* %1059
%1061 = load [5 x double]*, [5 x double]** %5
%1062 = getelementptr inbounds [5 x double], [5 x double]* %1061, i64 3
%1063 = getelementptr inbounds [5 x double], [5 x double]* %1062, i64 0, i64 2
%1064 = load double, double* %1063
%1065 = fneg double %1060
%1066 = call double @llvm.fmuladd.f64(double %1065, double %1064, double %1056)
%1067 = load [5 x double]*, [5 x double]** %4
%1068 = getelementptr inbounds [5 x double], [5 x double]* %1067, i64 3
%1069 = getelementptr inbounds [5 x double], [5 x double]* %1068, i64 0, i64 3
%1070 = load double, double* %1069
%1071 = load [5 x double]*, [5 x double]** %5
%1072 = getelementptr inbounds [5 x double], [5 x double]* %1071, i64 3
%1073 = getelementptr inbounds [5 x double], [5 x double]* %1072, i64 0, i64 3
%1074 = load double, double* %1073
%1075 = fneg double %1070
%1076 = call double @llvm.fmuladd.f64(double %1075, double %1074, double %1066)
%1077 = load [5 x double]*, [5 x double]** %4
%1078 = getelementptr inbounds [5 x double], [5 x double]* %1077, i64 4
%1079 = getelementptr inbounds [5 x double], [5 x double]* %1078, i64 0, i64 3
%1080 = load double, double* %1079
%1081 = load [5 x double]*, [5 x double]** %5
%1082 = getelementptr inbounds [5 x double], [5 x double]* %1081, i64 3
%1083 = getelementptr inbounds [5 x double], [5 x double]* %1082, i64 0, i64 4
%1084 = load double, double* %1083
%1085 = fneg double %1080
%1086 = call double @llvm.fmuladd.f64(double %1085, double %1084, double %1076)
%1087 = load [5 x double]*, [5 x double]** %6
%1088 = getelementptr inbounds [5 x double], [5 x double]* %1087, i64 3
%1089 = getelementptr inbounds [5 x double], [5 x double]* %1088, i64 0, i64 3
store double %1086, double* %1089
%1090 = load [5 x double]*, [5 x double]** %6
%1091 = getelementptr inbounds [5 x double], [5 x double]* %1090, i64 3
%1092 = getelementptr inbounds [5 x double], [5 x double]* %1091, i64 0, i64 4
%1093 = load double, double* %1092
%1094 = load [5 x double]*, [5 x double]** %4
%1095 = getelementptr inbounds [5 x double], [5 x double]* %1094, i64 0
%1096 = getelementptr inbounds [5 x double], [5 x double]* %1095, i64 0, i64 4
%1097 = load double, double* %1096
%1098 = load [5 x double]*, [5 x double]** %5
%1099 = getelementptr inbounds [5 x double], [5 x double]* %1098, i64 3
%1100 = getelementptr inbounds [5 x double], [5 x double]* %1099, i64 0, i64 0
%1101 = load double, double* %1100
%1102 = fneg double %1097
%1103 = call double @llvm.fmuladd.f64(double %1102, double %1101, double %1093)
%1104 = load [5 x double]*, [5 x double]** %4
%1105 = getelementptr inbounds [5 x double], [5 x double]* %1104, i64 1
%1106 = getelementptr inbounds [5 x double], [5 x double]* %1105, i64 0, i64 4
%1107 = load double, double* %1106
%1108 = load [5 x double]*, [5 x double]** %5
%1109 = getelementptr inbounds [5 x double], [5 x double]* %1108, i64 3
%1110 = getelementptr inbounds [5 x double], [5 x double]* %1109, i64 0, i64 1
%1111 = load double, double* %1110
%1112 = fneg double %1107
%1113 = call double @llvm.fmuladd.f64(double %1112, double %1111, double %1103)
%1114 = load [5 x double]*, [5 x double]** %4
%1115 = getelementptr inbounds [5 x double], [5 x double]* %1114, i64 2
%1116 = getelementptr inbounds [5 x double], [5 x double]* %1115, i64 0, i64 4
%1117 = load double, double* %1116
%1118 = load [5 x double]*, [5 x double]** %5
%1119 = getelementptr inbounds [5 x double], [5 x double]* %1118, i64 3
%1120 = getelementptr inbounds [5 x double], [5 x double]* %1119, i64 0, i64 2
%1121 = load double, double* %1120
%1122 = fneg double %1117
%1123 = call double @llvm.fmuladd.f64(double %1122, double %1121, double %1113)
%1124 = load [5 x double]*, [5 x double]** %4
%1125 = getelementptr inbounds [5 x double], [5 x double]* %1124, i64 3
%1126 = getelementptr inbounds [5 x double], [5 x double]* %1125, i64 0, i64 4
%1127 = load double, double* %1126
%1128 = load [5 x double]*, [5 x double]** %5
%1129 = getelementptr inbounds [5 x double], [5 x double]* %1128, i64 3
%1130 = getelementptr inbounds [5 x double], [5 x double]* %1129, i64 0, i64 3
%1131 = load double, double* %1130
%1132 = fneg double %1127
%1133 = call double @llvm.fmuladd.f64(double %1132, double %1131, double %1123)
%1134 = load [5 x double]*, [5 x double]** %4
%1135 = getelementptr inbounds [5 x double], [5 x double]* %1134, i64 4
%1136 = getelementptr inbounds [5 x double], [5 x double]* %1135, i64 0, i64 4
%1137 = load double, double* %1136
%1138 = load [5 x double]*, [5 x double]** %5
%1139 = getelementptr inbounds [5 x double], [5 x double]* %1138, i64 3
%1140 = getelementptr inbounds [5 x double], [5 x double]* %1139, i64 0, i64 4
%1141 = load double, double* %1140
%1142 = fneg double %1137
%1143 = call double @llvm.fmuladd.f64(double %1142, double %1141, double %1133)
%1144 = load [5 x double]*, [5 x double]** %6
%1145 = getelementptr inbounds [5 x double], [5 x double]* %1144, i64 3
%1146 = getelementptr inbounds [5 x double], [5 x double]* %1145, i64 0, i64 4
store double %1143, double* %1146
%1147 = load [5 x double]*, [5 x double]** %6
%1148 = getelementptr inbounds [5 x double], [5 x double]* %1147, i64 4
%1149 = getelementptr inbounds [5 x double], [5 x double]* %1148, i64 0, i64 0
%1150 = load double, double* %1149
%1151 = load [5 x double]*, [5 x double]** %4
%1152 = getelementptr inbounds [5 x double], [5 x double]* %1151, i64 0
%1153 = getelementptr inbounds [5 x double], [5 x double]* %1152, i64 0, i64 0
%1154 = load double, double* %1153
%1155 = load [5 x double]*, [5 x double]** %5
%1156 = getelementptr inbounds [5 x double], [5 x double]* %1155, i64 4
%1157 = getelementptr inbounds [5 x double], [5 x double]* %1156, i64 0, i64 0
%1158 = load double, double* %1157
%1159 = fneg double %1154
%1160 = call double @llvm.fmuladd.f64(double %1159, double %1158, double %1150)
%1161 = load [5 x double]*, [5 x double]** %4
%1162 = getelementptr inbounds [5 x double], [5 x double]* %1161, i64 1
%1163 = getelementptr inbounds [5 x double], [5 x double]* %1162, i64 0, i64 0
%1164 = load double, double* %1163
%1165 = load [5 x double]*, [5 x double]** %5
%1166 = getelementptr inbounds [5 x double], [5 x double]* %1165, i64 4
%1167 = getelementptr inbounds [5 x double], [5 x double]* %1166, i64 0, i64 1
%1168 = load double, double* %1167
%1169 = fneg double %1164
%1170 = call double @llvm.fmuladd.f64(double %1169, double %1168, double %1160)
%1171 = load [5 x double]*, [5 x double]** %4
%1172 = getelementptr inbounds [5 x double], [5 x double]* %1171, i64 2
%1173 = getelementptr inbounds [5 x double], [5 x double]* %1172, i64 0, i64 0
%1174 = load double, double* %1173
%1175 = load [5 x double]*, [5 x double]** %5
%1176 = getelementptr inbounds [5 x double], [5 x double]* %1175, i64 4
%1177 = getelementptr inbounds [5 x double], [5 x double]* %1176, i64 0, i64 2
%1178 = load double, double* %1177
%1179 = fneg double %1174
%1180 = call double @llvm.fmuladd.f64(double %1179, double %1178, double %1170)
%1181 = load [5 x double]*, [5 x double]** %4
%1182 = getelementptr inbounds [5 x double], [5 x double]* %1181, i64 3
%1183 = getelementptr inbounds [5 x double], [5 x double]* %1182, i64 0, i64 0
%1184 = load double, double* %1183
%1185 = load [5 x double]*, [5 x double]** %5
%1186 = getelementptr inbounds [5 x double], [5 x double]* %1185, i64 4
%1187 = getelementptr inbounds [5 x double], [5 x double]* %1186, i64 0, i64 3
%1188 = load double, double* %1187
%1189 = fneg double %1184
%1190 = call double @llvm.fmuladd.f64(double %1189, double %1188, double %1180)
%1191 = load [5 x double]*, [5 x double]** %4
%1192 = getelementptr inbounds [5 x double], [5 x double]* %1191, i64 4
%1193 = getelementptr inbounds [5 x double], [5 x double]* %1192, i64 0, i64 0
%1194 = load double, double* %1193
%1195 = load [5 x double]*, [5 x double]** %5
%1196 = getelementptr inbounds [5 x double], [5 x double]* %1195, i64 4
%1197 = getelementptr inbounds [5 x double], [5 x double]* %1196, i64 0, i64 4
%1198 = load double, double* %1197
%1199 = fneg double %1194
%1200 = call double @llvm.fmuladd.f64(double %1199, double %1198, double %1190)
%1201 = load [5 x double]*, [5 x double]** %6
%1202 = getelementptr inbounds [5 x double], [5 x double]* %1201, i64 4
%1203 = getelementptr inbounds [5 x double], [5 x double]* %1202, i64 0, i64 0
store double %1200, double* %1203
%1204 = load [5 x double]*, [5 x double]** %6
%1205 = getelementptr inbounds [5 x double], [5 x double]* %1204, i64 4
%1206 = getelementptr inbounds [5 x double], [5 x double]* %1205, i64 0, i64 1
%1207 = load double, double* %1206
%1208 = load [5 x double]*, [5 x double]** %4
%1209 = getelementptr inbounds [5 x double], [5 x double]* %1208, i64 0
%1210 = getelementptr inbounds [5 x double], [5 x double]* %1209, i64 0, i64 1
%1211 = load double, double* %1210
%1212 = load [5 x double]*, [5 x double]** %5
%1213 = getelementptr inbounds [5 x double], [5 x double]* %1212, i64 4
%1214 = getelementptr inbounds [5 x double], [5 x double]* %1213, i64 0, i64 0
%1215 = load double, double* %1214
%1216 = fneg double %1211
%1217 = call double @llvm.fmuladd.f64(double %1216, double %1215, double %1207)
%1218 = load [5 x double]*, [5 x double]** %4
%1219 = getelementptr inbounds [5 x double], [5 x double]* %1218, i64 1
%1220 = getelementptr inbounds [5 x double], [5 x double]* %1219, i64 0, i64 1
%1221 = load double, double* %1220
%1222 = load [5 x double]*, [5 x double]** %5
%1223 = getelementptr inbounds [5 x double], [5 x double]* %1222, i64 4
%1224 = getelementptr inbounds [5 x double], [5 x double]* %1223, i64 0, i64 1
%1225 = load double, double* %1224
%1226 = fneg double %1221
%1227 = call double @llvm.fmuladd.f64(double %1226, double %1225, double %1217)
%1228 = load [5 x double]*, [5 x double]** %4
%1229 = getelementptr inbounds [5 x double], [5 x double]* %1228, i64 2
%1230 = getelementptr inbounds [5 x double], [5 x double]* %1229, i64 0, i64 1
%1231 = load double, double* %1230
%1232 = load [5 x double]*, [5 x double]** %5
%1233 = getelementptr inbounds [5 x double], [5 x double]* %1232, i64 4
%1234 = getelementptr inbounds [5 x double], [5 x double]* %1233, i64 0, i64 2
%1235 = load double, double* %1234
%1236 = fneg double %1231
%1237 = call double @llvm.fmuladd.f64(double %1236, double %1235, double %1227)
%1238 = load [5 x double]*, [5 x double]** %4
%1239 = getelementptr inbounds [5 x double], [5 x double]* %1238, i64 3
%1240 = getelementptr inbounds [5 x double], [5 x double]* %1239, i64 0, i64 1
%1241 = load double, double* %1240
%1242 = load [5 x double]*, [5 x double]** %5
%1243 = getelementptr inbounds [5 x double], [5 x double]* %1242, i64 4
%1244 = getelementptr inbounds [5 x double], [5 x double]* %1243, i64 0, i64 3
%1245 = load double, double* %1244
%1246 = fneg double %1241
%1247 = call double @llvm.fmuladd.f64(double %1246, double %1245, double %1237)
%1248 = load [5 x double]*, [5 x double]** %4
%1249 = getelementptr inbounds [5 x double], [5 x double]* %1248, i64 4
%1250 = getelementptr inbounds [5 x double], [5 x double]* %1249, i64 0, i64 1
%1251 = load double, double* %1250
%1252 = load [5 x double]*, [5 x double]** %5
%1253 = getelementptr inbounds [5 x double], [5 x double]* %1252, i64 4
%1254 = getelementptr inbounds [5 x double], [5 x double]* %1253, i64 0, i64 4
%1255 = load double, double* %1254
%1256 = fneg double %1251
%1257 = call double @llvm.fmuladd.f64(double %1256, double %1255, double %1247)
%1258 = load [5 x double]*, [5 x double]** %6
%1259 = getelementptr inbounds [5 x double], [5 x double]* %1258, i64 4
%1260 = getelementptr inbounds [5 x double], [5 x double]* %1259, i64 0, i64 1
store double %1257, double* %1260
%1261 = load [5 x double]*, [5 x double]** %6
%1262 = getelementptr inbounds [5 x double], [5 x double]* %1261, i64 4
%1263 = getelementptr inbounds [5 x double], [5 x double]* %1262, i64 0, i64 2
%1264 = load double, double* %1263
%1265 = load [5 x double]*, [5 x double]** %4
%1266 = getelementptr inbounds [5 x double], [5 x double]* %1265, i64 0
%1267 = getelementptr inbounds [5 x double], [5 x double]* %1266, i64 0, i64 2
%1268 = load double, double* %1267
%1269 = load [5 x double]*, [5 x double]** %5
%1270 = getelementptr inbounds [5 x double], [5 x double]* %1269, i64 4
%1271 = getelementptr inbounds [5 x double], [5 x double]* %1270, i64 0, i64 0
%1272 = load double, double* %1271
%1273 = fneg double %1268
%1274 = call double @llvm.fmuladd.f64(double %1273, double %1272, double %1264)
%1275 = load [5 x double]*, [5 x double]** %4
%1276 = getelementptr inbounds [5 x double], [5 x double]* %1275, i64 1
%1277 = getelementptr inbounds [5 x double], [5 x double]* %1276, i64 0, i64 2
%1278 = load double, double* %1277
%1279 = load [5 x double]*, [5 x double]** %5
%1280 = getelementptr inbounds [5 x double], [5 x double]* %1279, i64 4
%1281 = getelementptr inbounds [5 x double], [5 x double]* %1280, i64 0, i64 1
%1282 = load double, double* %1281
%1283 = fneg double %1278
%1284 = call double @llvm.fmuladd.f64(double %1283, double %1282, double %1274)
%1285 = load [5 x double]*, [5 x double]** %4
%1286 = getelementptr inbounds [5 x double], [5 x double]* %1285, i64 2
%1287 = getelementptr inbounds [5 x double], [5 x double]* %1286, i64 0, i64 2
%1288 = load double, double* %1287
%1289 = load [5 x double]*, [5 x double]** %5
%1290 = getelementptr inbounds [5 x double], [5 x double]* %1289, i64 4
%1291 = getelementptr inbounds [5 x double], [5 x double]* %1290, i64 0, i64 2
%1292 = load double, double* %1291
%1293 = fneg double %1288
%1294 = call double @llvm.fmuladd.f64(double %1293, double %1292, double %1284)
%1295 = load [5 x double]*, [5 x double]** %4
%1296 = getelementptr inbounds [5 x double], [5 x double]* %1295, i64 3
%1297 = getelementptr inbounds [5 x double], [5 x double]* %1296, i64 0, i64 2
%1298 = load double, double* %1297
%1299 = load [5 x double]*, [5 x double]** %5
%1300 = getelementptr inbounds [5 x double], [5 x double]* %1299, i64 4
%1301 = getelementptr inbounds [5 x double], [5 x double]* %1300, i64 0, i64 3
%1302 = load double, double* %1301
%1303 = fneg double %1298
%1304 = call double @llvm.fmuladd.f64(double %1303, double %1302, double %1294)
%1305 = load [5 x double]*, [5 x double]** %4
%1306 = getelementptr inbounds [5 x double], [5 x double]* %1305, i64 4
%1307 = getelementptr inbounds [5 x double], [5 x double]* %1306, i64 0, i64 2
%1308 = load double, double* %1307
%1309 = load [5 x double]*, [5 x double]** %5
%1310 = getelementptr inbounds [5 x double], [5 x double]* %1309, i64 4
%1311 = getelementptr inbounds [5 x double], [5 x double]* %1310, i64 0, i64 4
%1312 = load double, double* %1311
%1313 = fneg double %1308
%1314 = call double @llvm.fmuladd.f64(double %1313, double %1312, double %1304)
%1315 = load [5 x double]*, [5 x double]** %6
%1316 = getelementptr inbounds [5 x double], [5 x double]* %1315, i64 4
%1317 = getelementptr inbounds [5 x double], [5 x double]* %1316, i64 0, i64 2
store double %1314, double* %1317
%1318 = load [5 x double]*, [5 x double]** %6
%1319 = getelementptr inbounds [5 x double], [5 x double]* %1318, i64 4
%1320 = getelementptr inbounds [5 x double], [5 x double]* %1319, i64 0, i64 3
%1321 = load double, double* %1320
%1322 = load [5 x double]*, [5 x double]** %4
%1323 = getelementptr inbounds [5 x double], [5 x double]* %1322, i64 0
%1324 = getelementptr inbounds [5 x double], [5 x double]* %1323, i64 0, i64 3
%1325 = load double, double* %1324
%1326 = load [5 x double]*, [5 x double]** %5
%1327 = getelementptr inbounds [5 x double], [5 x double]* %1326, i64 4
%1328 = getelementptr inbounds [5 x double], [5 x double]* %1327, i64 0, i64 0
%1329 = load double, double* %1328
%1330 = fneg double %1325
%1331 = call double @llvm.fmuladd.f64(double %1330, double %1329, double %1321)
%1332 = load [5 x double]*, [5 x double]** %4
%1333 = getelementptr inbounds [5 x double], [5 x double]* %1332, i64 1
%1334 = getelementptr inbounds [5 x double], [5 x double]* %1333, i64 0, i64 3
%1335 = load double, double* %1334
%1336 = load [5 x double]*, [5 x double]** %5
%1337 = getelementptr inbounds [5 x double], [5 x double]* %1336, i64 4
%1338 = getelementptr inbounds [5 x double], [5 x double]* %1337, i64 0, i64 1
%1339 = load double, double* %1338
%1340 = fneg double %1335
%1341 = call double @llvm.fmuladd.f64(double %1340, double %1339, double %1331)
%1342 = load [5 x double]*, [5 x double]** %4
%1343 = getelementptr inbounds [5 x double], [5 x double]* %1342, i64 2
%1344 = getelementptr inbounds [5 x double], [5 x double]* %1343, i64 0, i64 3
%1345 = load double, double* %1344
%1346 = load [5 x double]*, [5 x double]** %5
%1347 = getelementptr inbounds [5 x double], [5 x double]* %1346, i64 4
%1348 = getelementptr inbounds [5 x double], [5 x double]* %1347, i64 0, i64 2
%1349 = load double, double* %1348
%1350 = fneg double %1345
%1351 = call double @llvm.fmuladd.f64(double %1350, double %1349, double %1341)
%1352 = load [5 x double]*, [5 x double]** %4
%1353 = getelementptr inbounds [5 x double], [5 x double]* %1352, i64 3
%1354 = getelementptr inbounds [5 x double], [5 x double]* %1353, i64 0, i64 3
%1355 = load double, double* %1354
%1356 = load [5 x double]*, [5 x double]** %5
%1357 = getelementptr inbounds [5 x double], [5 x double]* %1356, i64 4
%1358 = getelementptr inbounds [5 x double], [5 x double]* %1357, i64 0, i64 3
%1359 = load double, double* %1358
%1360 = fneg double %1355
%1361 = call double @llvm.fmuladd.f64(double %1360, double %1359, double %1351)
%1362 = load [5 x double]*, [5 x double]** %4
%1363 = getelementptr inbounds [5 x double], [5 x double]* %1362, i64 4
%1364 = getelementptr inbounds [5 x double], [5 x double]* %1363, i64 0, i64 3
%1365 = load double, double* %1364
%1366 = load [5 x double]*, [5 x double]** %5
%1367 = getelementptr inbounds [5 x double], [5 x double]* %1366, i64 4
%1368 = getelementptr inbounds [5 x double], [5 x double]* %1367, i64 0, i64 4
%1369 = load double, double* %1368
%1370 = fneg double %1365
%1371 = call double @llvm.fmuladd.f64(double %1370, double %1369, double %1361)
%1372 = load [5 x double]*, [5 x double]** %6
%1373 = getelementptr inbounds [5 x double], [5 x double]* %1372, i64 4
%1374 = getelementptr inbounds [5 x double], [5 x double]* %1373, i64 0, i64 3
store double %1371, double* %1374
%1375 = load [5 x double]*, [5 x double]** %6
%1376 = getelementptr inbounds [5 x double], [5 x double]* %1375, i64 4
%1377 = getelementptr inbounds [5 x double], [5 x double]* %1376, i64 0, i64 4
%1378 = load double, double* %1377
%1379 = load [5 x double]*, [5 x double]** %4
%1380 = getelementptr inbounds [5 x double], [5 x double]* %1379, i64 0
%1381 = getelementptr inbounds [5 x double], [5 x double]* %1380, i64 0, i64 4
%1382 = load double, double* %1381
%1383 = load [5 x double]*, [5 x double]** %5
%1384 = getelementptr inbounds [5 x double], [5 x double]* %1383, i64 4
%1385 = getelementptr inbounds [5 x double], [5 x double]* %1384, i64 0, i64 0
%1386 = load double, double* %1385
%1387 = fneg double %1382
%1388 = call double @llvm.fmuladd.f64(double %1387, double %1386, double %1378)
%1389 = load [5 x double]*, [5 x double]** %4
%1390 = getelementptr inbounds [5 x double], [5 x double]* %1389, i64 1
%1391 = getelementptr inbounds [5 x double], [5 x double]* %1390, i64 0, i64 4
%1392 = load double, double* %1391
%1393 = load [5 x double]*, [5 x double]** %5
%1394 = getelementptr inbounds [5 x double], [5 x double]* %1393, i64 4
%1395 = getelementptr inbounds [5 x double], [5 x double]* %1394, i64 0, i64 1
%1396 = load double, double* %1395
%1397 = fneg double %1392
%1398 = call double @llvm.fmuladd.f64(double %1397, double %1396, double %1388)
%1399 = load [5 x double]*, [5 x double]** %4
%1400 = getelementptr inbounds [5 x double], [5 x double]* %1399, i64 2
%1401 = getelementptr inbounds [5 x double], [5 x double]* %1400, i64 0, i64 4
%1402 = load double, double* %1401
%1403 = load [5 x double]*, [5 x double]** %5
%1404 = getelementptr inbounds [5 x double], [5 x double]* %1403, i64 4
%1405 = getelementptr inbounds [5 x double], [5 x double]* %1404, i64 0, i64 2
%1406 = load double, double* %1405
%1407 = fneg double %1402
%1408 = call double @llvm.fmuladd.f64(double %1407, double %1406, double %1398)
%1409 = load [5 x double]*, [5 x double]** %4
%1410 = getelementptr inbounds [5 x double], [5 x double]* %1409, i64 3
%1411 = getelementptr inbounds [5 x double], [5 x double]* %1410, i64 0, i64 4
%1412 = load double, double* %1411
%1413 = load [5 x double]*, [5 x double]** %5
%1414 = getelementptr inbounds [5 x double], [5 x double]* %1413, i64 4
%1415 = getelementptr inbounds [5 x double], [5 x double]* %1414, i64 0, i64 3
%1416 = load double, double* %1415
%1417 = fneg double %1412
%1418 = call double @llvm.fmuladd.f64(double %1417, double %1416, double %1408)
%1419 = load [5 x double]*, [5 x double]** %4
%1420 = getelementptr inbounds [5 x double], [5 x double]* %1419, i64 4
%1421 = getelementptr inbounds [5 x double], [5 x double]* %1420, i64 0, i64 4
%1422 = load double, double* %1421
%1423 = load [5 x double]*, [5 x double]** %5
%1424 = getelementptr inbounds [5 x double], [5 x double]* %1423, i64 4
%1425 = getelementptr inbounds [5 x double], [5 x double]* %1424, i64 0, i64 4
%1426 = load double, double* %1425
%1427 = fneg double %1422
%1428 = call double @llvm.fmuladd.f64(double %1427, double %1426, double %1418)
%1429 = load [5 x double]*, [5 x double]** %6
%1430 = getelementptr inbounds [5 x double], [5 x double]* %1429, i64 4
%1431 = getelementptr inbounds [5 x double], [5 x double]* %1430, i64 0, i64 4
store double %1428, double* %1431
ret void
}

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