void binvrhs(double lhs[5][5], double r[5]) {
  double pivot, coeff;
  pivot = 1.00 / lhs[0][0];
  lhs[1][0] = lhs[1][0] * pivot;
  lhs[2][0] = lhs[2][0] * pivot;
  lhs[3][0] = lhs[3][0] * pivot;
  lhs[4][0] = lhs[4][0] * pivot;
  r[0] = r[0] * pivot;
  coeff = lhs[0][1];
  lhs[1][1] = lhs[1][1] - coeff * lhs[1][0];
  lhs[2][1] = lhs[2][1] - coeff * lhs[2][0];
  lhs[3][1] = lhs[3][1] - coeff * lhs[3][0];
  lhs[4][1] = lhs[4][1] - coeff * lhs[4][0];
  r[1] = r[1] - coeff * r[0];
  coeff = lhs[0][2];
  lhs[1][2] = lhs[1][2] - coeff * lhs[1][0];
  lhs[2][2] = lhs[2][2] - coeff * lhs[2][0];
  lhs[3][2] = lhs[3][2] - coeff * lhs[3][0];
  lhs[4][2] = lhs[4][2] - coeff * lhs[4][0];
  r[2] = r[2] - coeff * r[0];
  coeff = lhs[0][3];
  lhs[1][3] = lhs[1][3] - coeff * lhs[1][0];
  lhs[2][3] = lhs[2][3] - coeff * lhs[2][0];
  lhs[3][3] = lhs[3][3] - coeff * lhs[3][0];
  lhs[4][3] = lhs[4][3] - coeff * lhs[4][0];
  r[3] = r[3] - coeff * r[0];
  coeff = lhs[0][4];
  lhs[1][4] = lhs[1][4] - coeff * lhs[1][0];
  lhs[2][4] = lhs[2][4] - coeff * lhs[2][0];
  lhs[3][4] = lhs[3][4] - coeff * lhs[3][0];
  lhs[4][4] = lhs[4][4] - coeff * lhs[4][0];
  r[4] = r[4] - coeff * r[0];
  pivot = 1.00 / lhs[1][1];
  lhs[2][1] = lhs[2][1] * pivot;
  lhs[3][1] = lhs[3][1] * pivot;
  lhs[4][1] = lhs[4][1] * pivot;
  r[1] = r[1] * pivot;
  coeff = lhs[1][0];
  lhs[2][0] = lhs[2][0] - coeff * lhs[2][1];
  lhs[3][0] = lhs[3][0] - coeff * lhs[3][1];
  lhs[4][0] = lhs[4][0] - coeff * lhs[4][1];
  r[0] = r[0] - coeff * r[1];
  coeff = lhs[1][2];
  lhs[2][2] = lhs[2][2] - coeff * lhs[2][1];
  lhs[3][2] = lhs[3][2] - coeff * lhs[3][1];
  lhs[4][2] = lhs[4][2] - coeff * lhs[4][1];
  r[2] = r[2] - coeff * r[1];
  coeff = lhs[1][3];
  lhs[2][3] = lhs[2][3] - coeff * lhs[2][1];
  lhs[3][3] = lhs[3][3] - coeff * lhs[3][1];
  lhs[4][3] = lhs[4][3] - coeff * lhs[4][1];
  r[3] = r[3] - coeff * r[1];
  coeff = lhs[1][4];
  lhs[2][4] = lhs[2][4] - coeff * lhs[2][1];
  lhs[3][4] = lhs[3][4] - coeff * lhs[3][1];
  lhs[4][4] = lhs[4][4] - coeff * lhs[4][1];
  r[4] = r[4] - coeff * r[1];
  pivot = 1.00 / lhs[2][2];
  lhs[3][2] = lhs[3][2] * pivot;
  lhs[4][2] = lhs[4][2] * pivot;
  r[2] = r[2] * pivot;
  coeff = lhs[2][0];
  lhs[3][0] = lhs[3][0] - coeff * lhs[3][2];
  lhs[4][0] = lhs[4][0] - coeff * lhs[4][2];
  r[0] = r[0] - coeff * r[2];
  coeff = lhs[2][1];
  lhs[3][1] = lhs[3][1] - coeff * lhs[3][2];
  lhs[4][1] = lhs[4][1] - coeff * lhs[4][2];
  r[1] = r[1] - coeff * r[2];
  coeff = lhs[2][3];
  lhs[3][3] = lhs[3][3] - coeff * lhs[3][2];
  lhs[4][3] = lhs[4][3] - coeff * lhs[4][2];
  r[3] = r[3] - coeff * r[2];
  coeff = lhs[2][4];
  lhs[3][4] = lhs[3][4] - coeff * lhs[3][2];
  lhs[4][4] = lhs[4][4] - coeff * lhs[4][2];
  r[4] = r[4] - coeff * r[2];
  pivot = 1.00 / lhs[3][3];
  lhs[4][3] = lhs[4][3] * pivot;
  r[3] = r[3] * pivot;
  coeff = lhs[3][0];
  lhs[4][0] = lhs[4][0] - coeff * lhs[4][3];
  r[0] = r[0] - coeff * r[3];
  coeff = lhs[3][1];
  lhs[4][1] = lhs[4][1] - coeff * lhs[4][3];
  r[1] = r[1] - coeff * r[3];
  coeff = lhs[3][2];
  lhs[4][2] = lhs[4][2] - coeff * lhs[4][3];
  r[2] = r[2] - coeff * r[3];
  coeff = lhs[3][4];
  lhs[4][4] = lhs[4][4] - coeff * lhs[4][3];
  r[4] = r[4] - coeff * r[3];
  pivot = 1.00 / lhs[4][4];
  r[4] = r[4] * pivot;
  coeff = lhs[4][0];
  r[0] = r[0] - coeff * r[4];
  coeff = lhs[4][1];
  r[1] = r[1] - coeff * r[4];
  coeff = lhs[4][2];
  r[2] = r[2] - coeff * r[4];
  coeff = lhs[4][3];
  r[3] = r[3] - coeff * r[4];
}


x86 assembly (clang, -O0):
<binvrhs>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x1ee8(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0xa0(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x58(%rax)
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x80(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xa8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x60(%rax)
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x88(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xb0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x40(%rax)
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x68(%rax)
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x90(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xb8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x48(%rax)
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x70(%rax)
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x98(%rax)
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xc0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1900(%rip),%xmm0
divsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x80(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0xa8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%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  %xmm0,0x78(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xa8(%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  %xmm0,0xa0(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x60(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%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  %xmm0,0x88(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xa8(%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  %xmm0,0xb0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%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  %xmm0,0x90(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xa8(%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  %xmm0,0xb8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x70(%rax)
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x80(%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  %xmm0,0x98(%rax)
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xa8(%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  %xmm0,0xc0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x141a(%rip),%xmm0
divsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x88(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0xb0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x78(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xa0(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x80(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xa8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x90(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x90(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xb8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0x98(%rax)
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%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  %xmm0,0xc0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x1047(%rip),%xmm0
divsd  0x90(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0xb8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xb8(%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  %xmm0,0xa0(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x80(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xb8(%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  %xmm0,0xa8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x88(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xb8(%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  %xmm0,0xb0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x98(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xc0(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  0xb8(%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  %xmm0,0xc0(%rax)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0xd9f(%rip),%xmm0
divsd  0xc0(%rax),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa0(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa8(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb0(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0xb8(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  -0x20(%rbp),%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    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
pop    %rbp
ret

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

LLVM IR (-O0):
define void @binvrhs([5 x double]* %0, double* %1) {
%3 = alloca [5 x double]*
%4 = alloca double*
%5 = alloca double
%6 = alloca double
store [5 x double]* %0, [5 x double]** %3
store double* %1, double** %4
%7 = load [5 x double]*, [5 x double]** %3
%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 = fdiv double 1.000000e+00, %10
store double %11, double* %5
%12 = load [5 x double]*, [5 x double]** %3
%13 = getelementptr inbounds [5 x double], [5 x double]* %12, i64 1
%14 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
%15 = load double, double* %14
%16 = load double, double* %5
%17 = fmul double %15, %16
%18 = load [5 x double]*, [5 x double]** %3
%19 = getelementptr inbounds [5 x double], [5 x double]* %18, i64 1
%20 = getelementptr inbounds [5 x double], [5 x double]* %19, i64 0, i64 0
store double %17, double* %20
%21 = load [5 x double]*, [5 x double]** %3
%22 = getelementptr inbounds [5 x double], [5 x double]* %21, i64 2
%23 = getelementptr inbounds [5 x double], [5 x double]* %22, i64 0, i64 0
%24 = load double, double* %23
%25 = load double, double* %5
%26 = fmul double %24, %25
%27 = load [5 x double]*, [5 x double]** %3
%28 = getelementptr inbounds [5 x double], [5 x double]* %27, i64 2
%29 = getelementptr inbounds [5 x double], [5 x double]* %28, i64 0, i64 0
store double %26, double* %29
%30 = load [5 x double]*, [5 x double]** %3
%31 = getelementptr inbounds [5 x double], [5 x double]* %30, i64 3
%32 = getelementptr inbounds [5 x double], [5 x double]* %31, i64 0, i64 0
%33 = load double, double* %32
%34 = load double, double* %5
%35 = fmul double %33, %34
%36 = load [5 x double]*, [5 x double]** %3
%37 = getelementptr inbounds [5 x double], [5 x double]* %36, i64 3
%38 = getelementptr inbounds [5 x double], [5 x double]* %37, i64 0, i64 0
store double %35, double* %38
%39 = load [5 x double]*, [5 x double]** %3
%40 = getelementptr inbounds [5 x double], [5 x double]* %39, i64 4
%41 = getelementptr inbounds [5 x double], [5 x double]* %40, i64 0, i64 0
%42 = load double, double* %41
%43 = load double, double* %5
%44 = fmul double %42, %43
%45 = load [5 x double]*, [5 x double]** %3
%46 = getelementptr inbounds [5 x double], [5 x double]* %45, i64 4
%47 = getelementptr inbounds [5 x double], [5 x double]* %46, i64 0, i64 0
store double %44, double* %47
%48 = load double*, double** %4
%49 = getelementptr inbounds double, double* %48, i64 0
%50 = load double, double* %49
%51 = load double, double* %5
%52 = fmul double %50, %51
%53 = load double*, double** %4
%54 = getelementptr inbounds double, double* %53, i64 0
store double %52, double* %54
%55 = load [5 x double]*, [5 x double]** %3
%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 1
%58 = load double, double* %57
store double %58, double* %6
%59 = load [5 x double]*, [5 x double]** %3
%60 = getelementptr inbounds [5 x double], [5 x double]* %59, i64 1
%61 = getelementptr inbounds [5 x double], [5 x double]* %60, i64 0, i64 1
%62 = load double, double* %61
%63 = load double, double* %6
%64 = load [5 x double]*, [5 x double]** %3
%65 = getelementptr inbounds [5 x double], [5 x double]* %64, i64 1
%66 = getelementptr inbounds [5 x double], [5 x double]* %65, i64 0, i64 0
%67 = load double, double* %66
%68 = fneg double %63
%69 = call double @llvm.fmuladd.f64(double %68, double %67, double %62)
%70 = load [5 x double]*, [5 x double]** %3
%71 = getelementptr inbounds [5 x double], [5 x double]* %70, i64 1
%72 = getelementptr inbounds [5 x double], [5 x double]* %71, i64 0, i64 1
store double %69, double* %72
%73 = load [5 x double]*, [5 x double]** %3
%74 = getelementptr inbounds [5 x double], [5 x double]* %73, i64 2
%75 = getelementptr inbounds [5 x double], [5 x double]* %74, i64 0, i64 1
%76 = load double, double* %75
%77 = load double, double* %6
%78 = load [5 x double]*, [5 x double]** %3
%79 = getelementptr inbounds [5 x double], [5 x double]* %78, i64 2
%80 = getelementptr inbounds [5 x double], [5 x double]* %79, i64 0, i64 0
%81 = load double, double* %80
%82 = fneg double %77
%83 = call double @llvm.fmuladd.f64(double %82, double %81, double %76)
%84 = load [5 x double]*, [5 x double]** %3
%85 = getelementptr inbounds [5 x double], [5 x double]* %84, i64 2
%86 = getelementptr inbounds [5 x double], [5 x double]* %85, i64 0, i64 1
store double %83, double* %86
%87 = load [5 x double]*, [5 x double]** %3
%88 = getelementptr inbounds [5 x double], [5 x double]* %87, i64 3
%89 = getelementptr inbounds [5 x double], [5 x double]* %88, i64 0, i64 1
%90 = load double, double* %89
%91 = load double, double* %6
%92 = load [5 x double]*, [5 x double]** %3
%93 = getelementptr inbounds [5 x double], [5 x double]* %92, i64 3
%94 = getelementptr inbounds [5 x double], [5 x double]* %93, i64 0, i64 0
%95 = load double, double* %94
%96 = fneg double %91
%97 = call double @llvm.fmuladd.f64(double %96, double %95, double %90)
%98 = load [5 x double]*, [5 x double]** %3
%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
store double %97, double* %100
%101 = load [5 x double]*, [5 x double]** %3
%102 = getelementptr inbounds [5 x double], [5 x double]* %101, i64 4
%103 = getelementptr inbounds [5 x double], [5 x double]* %102, i64 0, i64 1
%104 = load double, double* %103
%105 = load double, double* %6
%106 = load [5 x double]*, [5 x double]** %3
%107 = getelementptr inbounds [5 x double], [5 x double]* %106, i64 4
%108 = getelementptr inbounds [5 x double], [5 x double]* %107, i64 0, i64 0
%109 = load double, double* %108
%110 = fneg double %105
%111 = call double @llvm.fmuladd.f64(double %110, double %109, double %104)
%112 = load [5 x double]*, [5 x double]** %3
%113 = getelementptr inbounds [5 x double], [5 x double]* %112, i64 4
%114 = getelementptr inbounds [5 x double], [5 x double]* %113, i64 0, i64 1
store double %111, double* %114
%115 = load double*, double** %4
%116 = getelementptr inbounds double, double* %115, i64 1
%117 = load double, double* %116
%118 = load double, double* %6
%119 = load double*, double** %4
%120 = getelementptr inbounds double, double* %119, i64 0
%121 = load double, double* %120
%122 = fneg double %118
%123 = call double @llvm.fmuladd.f64(double %122, double %121, double %117)
%124 = load double*, double** %4
%125 = getelementptr inbounds double, double* %124, i64 1
store double %123, double* %125
%126 = load [5 x double]*, [5 x double]** %3
%127 = getelementptr inbounds [5 x double], [5 x double]* %126, i64 0
%128 = getelementptr inbounds [5 x double], [5 x double]* %127, i64 0, i64 2
%129 = load double, double* %128
store double %129, double* %6
%130 = load [5 x double]*, [5 x double]** %3
%131 = getelementptr inbounds [5 x double], [5 x double]* %130, i64 1
%132 = getelementptr inbounds [5 x double], [5 x double]* %131, i64 0, i64 2
%133 = load double, double* %132
%134 = load double, double* %6
%135 = load [5 x double]*, [5 x double]** %3
%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 0
%138 = load double, double* %137
%139 = fneg double %134
%140 = call double @llvm.fmuladd.f64(double %139, double %138, double %133)
%141 = load [5 x double]*, [5 x double]** %3
%142 = getelementptr inbounds [5 x double], [5 x double]* %141, i64 1
%143 = getelementptr inbounds [5 x double], [5 x double]* %142, i64 0, i64 2
store double %140, double* %143
%144 = load [5 x double]*, [5 x double]** %3
%145 = getelementptr inbounds [5 x double], [5 x double]* %144, i64 2
%146 = getelementptr inbounds [5 x double], [5 x double]* %145, i64 0, i64 2
%147 = load double, double* %146
%148 = load double, double* %6
%149 = load [5 x double]*, [5 x double]** %3
%150 = getelementptr inbounds [5 x double], [5 x double]* %149, i64 2
%151 = getelementptr inbounds [5 x double], [5 x double]* %150, i64 0, i64 0
%152 = load double, double* %151
%153 = fneg double %148
%154 = call double @llvm.fmuladd.f64(double %153, double %152, double %147)
%155 = load [5 x double]*, [5 x double]** %3
%156 = getelementptr inbounds [5 x double], [5 x double]* %155, i64 2
%157 = getelementptr inbounds [5 x double], [5 x double]* %156, i64 0, i64 2
store double %154, double* %157
%158 = load [5 x double]*, [5 x double]** %3
%159 = getelementptr inbounds [5 x double], [5 x double]* %158, i64 3
%160 = getelementptr inbounds [5 x double], [5 x double]* %159, i64 0, i64 2
%161 = load double, double* %160
%162 = load double, double* %6
%163 = load [5 x double]*, [5 x double]** %3
%164 = getelementptr inbounds [5 x double], [5 x double]* %163, i64 3
%165 = getelementptr inbounds [5 x double], [5 x double]* %164, i64 0, i64 0
%166 = load double, double* %165
%167 = fneg double %162
%168 = call double @llvm.fmuladd.f64(double %167, double %166, double %161)
%169 = load [5 x double]*, [5 x double]** %3
%170 = getelementptr inbounds [5 x double], [5 x double]* %169, i64 3
%171 = getelementptr inbounds [5 x double], [5 x double]* %170, i64 0, i64 2
store double %168, double* %171
%172 = load [5 x double]*, [5 x double]** %3
%173 = getelementptr inbounds [5 x double], [5 x double]* %172, i64 4
%174 = getelementptr inbounds [5 x double], [5 x double]* %173, i64 0, i64 2
%175 = load double, double* %174
%176 = load double, double* %6
%177 = load [5 x double]*, [5 x double]** %3
%178 = getelementptr inbounds [5 x double], [5 x double]* %177, i64 4
%179 = getelementptr inbounds [5 x double], [5 x double]* %178, i64 0, i64 0
%180 = load double, double* %179
%181 = fneg double %176
%182 = call double @llvm.fmuladd.f64(double %181, double %180, double %175)
%183 = load [5 x double]*, [5 x double]** %3
%184 = getelementptr inbounds [5 x double], [5 x double]* %183, i64 4
%185 = getelementptr inbounds [5 x double], [5 x double]* %184, i64 0, i64 2
store double %182, double* %185
%186 = load double*, double** %4
%187 = getelementptr inbounds double, double* %186, i64 2
%188 = load double, double* %187
%189 = load double, double* %6
%190 = load double*, double** %4
%191 = getelementptr inbounds double, double* %190, i64 0
%192 = load double, double* %191
%193 = fneg double %189
%194 = call double @llvm.fmuladd.f64(double %193, double %192, double %188)
%195 = load double*, double** %4
%196 = getelementptr inbounds double, double* %195, i64 2
store double %194, double* %196
%197 = load [5 x double]*, [5 x double]** %3
%198 = getelementptr inbounds [5 x double], [5 x double]* %197, i64 0
%199 = getelementptr inbounds [5 x double], [5 x double]* %198, i64 0, i64 3
%200 = load double, double* %199
store double %200, double* %6
%201 = load [5 x double]*, [5 x double]** %3
%202 = getelementptr inbounds [5 x double], [5 x double]* %201, i64 1
%203 = getelementptr inbounds [5 x double], [5 x double]* %202, i64 0, i64 3
%204 = load double, double* %203
%205 = load double, double* %6
%206 = load [5 x double]*, [5 x double]** %3
%207 = getelementptr inbounds [5 x double], [5 x double]* %206, i64 1
%208 = getelementptr inbounds [5 x double], [5 x double]* %207, i64 0, i64 0
%209 = load double, double* %208
%210 = fneg double %205
%211 = call double @llvm.fmuladd.f64(double %210, double %209, double %204)
%212 = load [5 x double]*, [5 x double]** %3
%213 = getelementptr inbounds [5 x double], [5 x double]* %212, i64 1
%214 = getelementptr inbounds [5 x double], [5 x double]* %213, i64 0, i64 3
store double %211, double* %214
%215 = load [5 x double]*, [5 x double]** %3
%216 = getelementptr inbounds [5 x double], [5 x double]* %215, i64 2
%217 = getelementptr inbounds [5 x double], [5 x double]* %216, i64 0, i64 3
%218 = load double, double* %217
%219 = load double, double* %6
%220 = load [5 x double]*, [5 x double]** %3
%221 = getelementptr inbounds [5 x double], [5 x double]* %220, i64 2
%222 = getelementptr inbounds [5 x double], [5 x double]* %221, i64 0, i64 0
%223 = load double, double* %222
%224 = fneg double %219
%225 = call double @llvm.fmuladd.f64(double %224, double %223, double %218)
%226 = load [5 x double]*, [5 x double]** %3
%227 = getelementptr inbounds [5 x double], [5 x double]* %226, i64 2
%228 = getelementptr inbounds [5 x double], [5 x double]* %227, i64 0, i64 3
store double %225, double* %228
%229 = load [5 x double]*, [5 x double]** %3
%230 = getelementptr inbounds [5 x double], [5 x double]* %229, i64 3
%231 = getelementptr inbounds [5 x double], [5 x double]* %230, i64 0, i64 3
%232 = load double, double* %231
%233 = load double, double* %6
%234 = load [5 x double]*, [5 x double]** %3
%235 = getelementptr inbounds [5 x double], [5 x double]* %234, i64 3
%236 = getelementptr inbounds [5 x double], [5 x double]* %235, i64 0, i64 0
%237 = load double, double* %236
%238 = fneg double %233
%239 = call double @llvm.fmuladd.f64(double %238, double %237, double %232)
%240 = load [5 x double]*, [5 x double]** %3
%241 = getelementptr inbounds [5 x double], [5 x double]* %240, i64 3
%242 = getelementptr inbounds [5 x double], [5 x double]* %241, i64 0, i64 3
store double %239, double* %242
%243 = load [5 x double]*, [5 x double]** %3
%244 = getelementptr inbounds [5 x double], [5 x double]* %243, i64 4
%245 = getelementptr inbounds [5 x double], [5 x double]* %244, i64 0, i64 3
%246 = load double, double* %245
%247 = load double, double* %6
%248 = load [5 x double]*, [5 x double]** %3
%249 = getelementptr inbounds [5 x double], [5 x double]* %248, i64 4
%250 = getelementptr inbounds [5 x double], [5 x double]* %249, i64 0, i64 0
%251 = load double, double* %250
%252 = fneg double %247
%253 = call double @llvm.fmuladd.f64(double %252, double %251, double %246)
%254 = load [5 x double]*, [5 x double]** %3
%255 = getelementptr inbounds [5 x double], [5 x double]* %254, i64 4
%256 = getelementptr inbounds [5 x double], [5 x double]* %255, i64 0, i64 3
store double %253, double* %256
%257 = load double*, double** %4
%258 = getelementptr inbounds double, double* %257, i64 3
%259 = load double, double* %258
%260 = load double, double* %6
%261 = load double*, double** %4
%262 = getelementptr inbounds double, double* %261, i64 0
%263 = load double, double* %262
%264 = fneg double %260
%265 = call double @llvm.fmuladd.f64(double %264, double %263, double %259)
%266 = load double*, double** %4
%267 = getelementptr inbounds double, double* %266, i64 3
store double %265, double* %267
%268 = load [5 x double]*, [5 x double]** %3
%269 = getelementptr inbounds [5 x double], [5 x double]* %268, i64 0
%270 = getelementptr inbounds [5 x double], [5 x double]* %269, i64 0, i64 4
%271 = load double, double* %270
store double %271, double* %6
%272 = load [5 x double]*, [5 x double]** %3
%273 = getelementptr inbounds [5 x double], [5 x double]* %272, i64 1
%274 = getelementptr inbounds [5 x double], [5 x double]* %273, i64 0, i64 4
%275 = load double, double* %274
%276 = load double, double* %6
%277 = load [5 x double]*, [5 x double]** %3
%278 = getelementptr inbounds [5 x double], [5 x double]* %277, i64 1
%279 = getelementptr inbounds [5 x double], [5 x double]* %278, i64 0, i64 0
%280 = load double, double* %279
%281 = fneg double %276
%282 = call double @llvm.fmuladd.f64(double %281, double %280, double %275)
%283 = load [5 x double]*, [5 x double]** %3
%284 = getelementptr inbounds [5 x double], [5 x double]* %283, i64 1
%285 = getelementptr inbounds [5 x double], [5 x double]* %284, i64 0, i64 4
store double %282, double* %285
%286 = load [5 x double]*, [5 x double]** %3
%287 = getelementptr inbounds [5 x double], [5 x double]* %286, i64 2
%288 = getelementptr inbounds [5 x double], [5 x double]* %287, i64 0, i64 4
%289 = load double, double* %288
%290 = load double, double* %6
%291 = load [5 x double]*, [5 x double]** %3
%292 = getelementptr inbounds [5 x double], [5 x double]* %291, i64 2
%293 = getelementptr inbounds [5 x double], [5 x double]* %292, i64 0, i64 0
%294 = load double, double* %293
%295 = fneg double %290
%296 = call double @llvm.fmuladd.f64(double %295, double %294, double %289)
%297 = load [5 x double]*, [5 x double]** %3
%298 = getelementptr inbounds [5 x double], [5 x double]* %297, i64 2
%299 = getelementptr inbounds [5 x double], [5 x double]* %298, i64 0, i64 4
store double %296, double* %299
%300 = load [5 x double]*, [5 x double]** %3
%301 = getelementptr inbounds [5 x double], [5 x double]* %300, i64 3
%302 = getelementptr inbounds [5 x double], [5 x double]* %301, i64 0, i64 4
%303 = load double, double* %302
%304 = load double, double* %6
%305 = load [5 x double]*, [5 x double]** %3
%306 = getelementptr inbounds [5 x double], [5 x double]* %305, i64 3
%307 = getelementptr inbounds [5 x double], [5 x double]* %306, i64 0, i64 0
%308 = load double, double* %307
%309 = fneg double %304
%310 = call double @llvm.fmuladd.f64(double %309, double %308, double %303)
%311 = load [5 x double]*, [5 x double]** %3
%312 = getelementptr inbounds [5 x double], [5 x double]* %311, i64 3
%313 = getelementptr inbounds [5 x double], [5 x double]* %312, i64 0, i64 4
store double %310, double* %313
%314 = load [5 x double]*, [5 x double]** %3
%315 = getelementptr inbounds [5 x double], [5 x double]* %314, i64 4
%316 = getelementptr inbounds [5 x double], [5 x double]* %315, i64 0, i64 4
%317 = load double, double* %316
%318 = load double, double* %6
%319 = load [5 x double]*, [5 x double]** %3
%320 = getelementptr inbounds [5 x double], [5 x double]* %319, i64 4
%321 = getelementptr inbounds [5 x double], [5 x double]* %320, i64 0, i64 0
%322 = load double, double* %321
%323 = fneg double %318
%324 = call double @llvm.fmuladd.f64(double %323, double %322, double %317)
%325 = load [5 x double]*, [5 x double]** %3
%326 = getelementptr inbounds [5 x double], [5 x double]* %325, i64 4
%327 = getelementptr inbounds [5 x double], [5 x double]* %326, i64 0, i64 4
store double %324, double* %327
%328 = load double*, double** %4
%329 = getelementptr inbounds double, double* %328, i64 4
%330 = load double, double* %329
%331 = load double, double* %6
%332 = load double*, double** %4
%333 = getelementptr inbounds double, double* %332, i64 0
%334 = load double, double* %333
%335 = fneg double %331
%336 = call double @llvm.fmuladd.f64(double %335, double %334, double %330)
%337 = load double*, double** %4
%338 = getelementptr inbounds double, double* %337, i64 4
store double %336, double* %338
%339 = load [5 x double]*, [5 x double]** %3
%340 = getelementptr inbounds [5 x double], [5 x double]* %339, i64 1
%341 = getelementptr inbounds [5 x double], [5 x double]* %340, i64 0, i64 1
%342 = load double, double* %341
%343 = fdiv double 1.000000e+00, %342
store double %343, double* %5
%344 = load [5 x double]*, [5 x double]** %3
%345 = getelementptr inbounds [5 x double], [5 x double]* %344, i64 2
%346 = getelementptr inbounds [5 x double], [5 x double]* %345, i64 0, i64 1
%347 = load double, double* %346
%348 = load double, double* %5
%349 = fmul double %347, %348
%350 = load [5 x double]*, [5 x double]** %3
%351 = getelementptr inbounds [5 x double], [5 x double]* %350, i64 2
%352 = getelementptr inbounds [5 x double], [5 x double]* %351, i64 0, i64 1
store double %349, double* %352
%353 = load [5 x double]*, [5 x double]** %3
%354 = getelementptr inbounds [5 x double], [5 x double]* %353, i64 3
%355 = getelementptr inbounds [5 x double], [5 x double]* %354, i64 0, i64 1
%356 = load double, double* %355
%357 = load double, double* %5
%358 = fmul double %356, %357
%359 = load [5 x double]*, [5 x double]** %3
%360 = getelementptr inbounds [5 x double], [5 x double]* %359, i64 3
%361 = getelementptr inbounds [5 x double], [5 x double]* %360, i64 0, i64 1
store double %358, double* %361
%362 = load [5 x double]*, [5 x double]** %3
%363 = getelementptr inbounds [5 x double], [5 x double]* %362, i64 4
%364 = getelementptr inbounds [5 x double], [5 x double]* %363, i64 0, i64 1
%365 = load double, double* %364
%366 = load double, double* %5
%367 = fmul double %365, %366
%368 = load [5 x double]*, [5 x double]** %3
%369 = getelementptr inbounds [5 x double], [5 x double]* %368, i64 4
%370 = getelementptr inbounds [5 x double], [5 x double]* %369, i64 0, i64 1
store double %367, double* %370
%371 = load double*, double** %4
%372 = getelementptr inbounds double, double* %371, i64 1
%373 = load double, double* %372
%374 = load double, double* %5
%375 = fmul double %373, %374
%376 = load double*, double** %4
%377 = getelementptr inbounds double, double* %376, i64 1
store double %375, double* %377
%378 = load [5 x double]*, [5 x double]** %3
%379 = getelementptr inbounds [5 x double], [5 x double]* %378, i64 1
%380 = getelementptr inbounds [5 x double], [5 x double]* %379, i64 0, i64 0
%381 = load double, double* %380
store double %381, double* %6
%382 = load [5 x double]*, [5 x double]** %3
%383 = getelementptr inbounds [5 x double], [5 x double]* %382, i64 2
%384 = getelementptr inbounds [5 x double], [5 x double]* %383, i64 0, i64 0
%385 = load double, double* %384
%386 = load double, double* %6
%387 = load [5 x double]*, [5 x double]** %3
%388 = getelementptr inbounds [5 x double], [5 x double]* %387, i64 2
%389 = getelementptr inbounds [5 x double], [5 x double]* %388, i64 0, i64 1
%390 = load double, double* %389
%391 = fneg double %386
%392 = call double @llvm.fmuladd.f64(double %391, double %390, double %385)
%393 = load [5 x double]*, [5 x double]** %3
%394 = getelementptr inbounds [5 x double], [5 x double]* %393, i64 2
%395 = getelementptr inbounds [5 x double], [5 x double]* %394, i64 0, i64 0
store double %392, double* %395
%396 = load [5 x double]*, [5 x double]** %3
%397 = getelementptr inbounds [5 x double], [5 x double]* %396, i64 3
%398 = getelementptr inbounds [5 x double], [5 x double]* %397, i64 0, i64 0
%399 = load double, double* %398
%400 = load double, double* %6
%401 = load [5 x double]*, [5 x double]** %3
%402 = getelementptr inbounds [5 x double], [5 x double]* %401, i64 3
%403 = getelementptr inbounds [5 x double], [5 x double]* %402, i64 0, i64 1
%404 = load double, double* %403
%405 = fneg double %400
%406 = call double @llvm.fmuladd.f64(double %405, double %404, double %399)
%407 = load [5 x double]*, [5 x double]** %3
%408 = getelementptr inbounds [5 x double], [5 x double]* %407, i64 3
%409 = getelementptr inbounds [5 x double], [5 x double]* %408, i64 0, i64 0
store double %406, double* %409
%410 = load [5 x double]*, [5 x double]** %3
%411 = getelementptr inbounds [5 x double], [5 x double]* %410, i64 4
%412 = getelementptr inbounds [5 x double], [5 x double]* %411, i64 0, i64 0
%413 = load double, double* %412
%414 = load double, double* %6
%415 = load [5 x double]*, [5 x double]** %3
%416 = getelementptr inbounds [5 x double], [5 x double]* %415, i64 4
%417 = getelementptr inbounds [5 x double], [5 x double]* %416, i64 0, i64 1
%418 = load double, double* %417
%419 = fneg double %414
%420 = call double @llvm.fmuladd.f64(double %419, double %418, double %413)
%421 = load [5 x double]*, [5 x double]** %3
%422 = getelementptr inbounds [5 x double], [5 x double]* %421, i64 4
%423 = getelementptr inbounds [5 x double], [5 x double]* %422, i64 0, i64 0
store double %420, double* %423
%424 = load double*, double** %4
%425 = getelementptr inbounds double, double* %424, i64 0
%426 = load double, double* %425
%427 = load double, double* %6
%428 = load double*, double** %4
%429 = getelementptr inbounds double, double* %428, i64 1
%430 = load double, double* %429
%431 = fneg double %427
%432 = call double @llvm.fmuladd.f64(double %431, double %430, double %426)
%433 = load double*, double** %4
%434 = getelementptr inbounds double, double* %433, i64 0
store double %432, double* %434
%435 = load [5 x double]*, [5 x double]** %3
%436 = getelementptr inbounds [5 x double], [5 x double]* %435, i64 1
%437 = getelementptr inbounds [5 x double], [5 x double]* %436, i64 0, i64 2
%438 = load double, double* %437
store double %438, double* %6
%439 = load [5 x double]*, [5 x double]** %3
%440 = getelementptr inbounds [5 x double], [5 x double]* %439, i64 2
%441 = getelementptr inbounds [5 x double], [5 x double]* %440, i64 0, i64 2
%442 = load double, double* %441
%443 = load double, double* %6
%444 = load [5 x double]*, [5 x double]** %3
%445 = getelementptr inbounds [5 x double], [5 x double]* %444, i64 2
%446 = getelementptr inbounds [5 x double], [5 x double]* %445, i64 0, i64 1
%447 = load double, double* %446
%448 = fneg double %443
%449 = call double @llvm.fmuladd.f64(double %448, double %447, double %442)
%450 = load [5 x double]*, [5 x double]** %3
%451 = getelementptr inbounds [5 x double], [5 x double]* %450, i64 2
%452 = getelementptr inbounds [5 x double], [5 x double]* %451, i64 0, i64 2
store double %449, double* %452
%453 = load [5 x double]*, [5 x double]** %3
%454 = getelementptr inbounds [5 x double], [5 x double]* %453, i64 3
%455 = getelementptr inbounds [5 x double], [5 x double]* %454, i64 0, i64 2
%456 = load double, double* %455
%457 = load double, double* %6
%458 = load [5 x double]*, [5 x double]** %3
%459 = getelementptr inbounds [5 x double], [5 x double]* %458, i64 3
%460 = getelementptr inbounds [5 x double], [5 x double]* %459, i64 0, i64 1
%461 = load double, double* %460
%462 = fneg double %457
%463 = call double @llvm.fmuladd.f64(double %462, double %461, double %456)
%464 = load [5 x double]*, [5 x double]** %3
%465 = getelementptr inbounds [5 x double], [5 x double]* %464, i64 3
%466 = getelementptr inbounds [5 x double], [5 x double]* %465, i64 0, i64 2
store double %463, double* %466
%467 = load [5 x double]*, [5 x double]** %3
%468 = getelementptr inbounds [5 x double], [5 x double]* %467, i64 4
%469 = getelementptr inbounds [5 x double], [5 x double]* %468, i64 0, i64 2
%470 = load double, double* %469
%471 = load double, double* %6
%472 = load [5 x double]*, [5 x double]** %3
%473 = getelementptr inbounds [5 x double], [5 x double]* %472, i64 4
%474 = getelementptr inbounds [5 x double], [5 x double]* %473, i64 0, i64 1
%475 = load double, double* %474
%476 = fneg double %471
%477 = call double @llvm.fmuladd.f64(double %476, double %475, double %470)
%478 = load [5 x double]*, [5 x double]** %3
%479 = getelementptr inbounds [5 x double], [5 x double]* %478, i64 4
%480 = getelementptr inbounds [5 x double], [5 x double]* %479, i64 0, i64 2
store double %477, double* %480
%481 = load double*, double** %4
%482 = getelementptr inbounds double, double* %481, i64 2
%483 = load double, double* %482
%484 = load double, double* %6
%485 = load double*, double** %4
%486 = getelementptr inbounds double, double* %485, i64 1
%487 = load double, double* %486
%488 = fneg double %484
%489 = call double @llvm.fmuladd.f64(double %488, double %487, double %483)
%490 = load double*, double** %4
%491 = getelementptr inbounds double, double* %490, i64 2
store double %489, double* %491
%492 = load [5 x double]*, [5 x double]** %3
%493 = getelementptr inbounds [5 x double], [5 x double]* %492, i64 1
%494 = getelementptr inbounds [5 x double], [5 x double]* %493, i64 0, i64 3
%495 = load double, double* %494
store double %495, double* %6
%496 = load [5 x double]*, [5 x double]** %3
%497 = getelementptr inbounds [5 x double], [5 x double]* %496, i64 2
%498 = getelementptr inbounds [5 x double], [5 x double]* %497, i64 0, i64 3
%499 = load double, double* %498
%500 = load double, double* %6
%501 = load [5 x double]*, [5 x double]** %3
%502 = getelementptr inbounds [5 x double], [5 x double]* %501, i64 2
%503 = getelementptr inbounds [5 x double], [5 x double]* %502, i64 0, i64 1
%504 = load double, double* %503
%505 = fneg double %500
%506 = call double @llvm.fmuladd.f64(double %505, double %504, double %499)
%507 = load [5 x double]*, [5 x double]** %3
%508 = getelementptr inbounds [5 x double], [5 x double]* %507, i64 2
%509 = getelementptr inbounds [5 x double], [5 x double]* %508, i64 0, i64 3
store double %506, double* %509
%510 = load [5 x double]*, [5 x double]** %3
%511 = getelementptr inbounds [5 x double], [5 x double]* %510, i64 3
%512 = getelementptr inbounds [5 x double], [5 x double]* %511, i64 0, i64 3
%513 = load double, double* %512
%514 = load double, double* %6
%515 = load [5 x double]*, [5 x double]** %3
%516 = getelementptr inbounds [5 x double], [5 x double]* %515, i64 3
%517 = getelementptr inbounds [5 x double], [5 x double]* %516, i64 0, i64 1
%518 = load double, double* %517
%519 = fneg double %514
%520 = call double @llvm.fmuladd.f64(double %519, double %518, double %513)
%521 = load [5 x double]*, [5 x double]** %3
%522 = getelementptr inbounds [5 x double], [5 x double]* %521, i64 3
%523 = getelementptr inbounds [5 x double], [5 x double]* %522, i64 0, i64 3
store double %520, double* %523
%524 = load [5 x double]*, [5 x double]** %3
%525 = getelementptr inbounds [5 x double], [5 x double]* %524, i64 4
%526 = getelementptr inbounds [5 x double], [5 x double]* %525, i64 0, i64 3
%527 = load double, double* %526
%528 = load double, double* %6
%529 = load [5 x double]*, [5 x double]** %3
%530 = getelementptr inbounds [5 x double], [5 x double]* %529, i64 4
%531 = getelementptr inbounds [5 x double], [5 x double]* %530, i64 0, i64 1
%532 = load double, double* %531
%533 = fneg double %528
%534 = call double @llvm.fmuladd.f64(double %533, double %532, double %527)
%535 = load [5 x double]*, [5 x double]** %3
%536 = getelementptr inbounds [5 x double], [5 x double]* %535, i64 4
%537 = getelementptr inbounds [5 x double], [5 x double]* %536, i64 0, i64 3
store double %534, double* %537
%538 = load double*, double** %4
%539 = getelementptr inbounds double, double* %538, i64 3
%540 = load double, double* %539
%541 = load double, double* %6
%542 = load double*, double** %4
%543 = getelementptr inbounds double, double* %542, i64 1
%544 = load double, double* %543
%545 = fneg double %541
%546 = call double @llvm.fmuladd.f64(double %545, double %544, double %540)
%547 = load double*, double** %4
%548 = getelementptr inbounds double, double* %547, i64 3
store double %546, double* %548
%549 = load [5 x double]*, [5 x double]** %3
%550 = getelementptr inbounds [5 x double], [5 x double]* %549, i64 1
%551 = getelementptr inbounds [5 x double], [5 x double]* %550, i64 0, i64 4
%552 = load double, double* %551
store double %552, double* %6
%553 = load [5 x double]*, [5 x double]** %3
%554 = getelementptr inbounds [5 x double], [5 x double]* %553, i64 2
%555 = getelementptr inbounds [5 x double], [5 x double]* %554, i64 0, i64 4
%556 = load double, double* %555
%557 = load double, double* %6
%558 = load [5 x double]*, [5 x double]** %3
%559 = getelementptr inbounds [5 x double], [5 x double]* %558, i64 2
%560 = getelementptr inbounds [5 x double], [5 x double]* %559, i64 0, i64 1
%561 = load double, double* %560
%562 = fneg double %557
%563 = call double @llvm.fmuladd.f64(double %562, double %561, double %556)
%564 = load [5 x double]*, [5 x double]** %3
%565 = getelementptr inbounds [5 x double], [5 x double]* %564, i64 2
%566 = getelementptr inbounds [5 x double], [5 x double]* %565, i64 0, i64 4
store double %563, double* %566
%567 = load [5 x double]*, [5 x double]** %3
%568 = getelementptr inbounds [5 x double], [5 x double]* %567, i64 3
%569 = getelementptr inbounds [5 x double], [5 x double]* %568, i64 0, i64 4
%570 = load double, double* %569
%571 = load double, double* %6
%572 = load [5 x double]*, [5 x double]** %3
%573 = getelementptr inbounds [5 x double], [5 x double]* %572, i64 3
%574 = getelementptr inbounds [5 x double], [5 x double]* %573, i64 0, i64 1
%575 = load double, double* %574
%576 = fneg double %571
%577 = call double @llvm.fmuladd.f64(double %576, double %575, double %570)
%578 = load [5 x double]*, [5 x double]** %3
%579 = getelementptr inbounds [5 x double], [5 x double]* %578, i64 3
%580 = getelementptr inbounds [5 x double], [5 x double]* %579, i64 0, i64 4
store double %577, double* %580
%581 = load [5 x double]*, [5 x double]** %3
%582 = getelementptr inbounds [5 x double], [5 x double]* %581, i64 4
%583 = getelementptr inbounds [5 x double], [5 x double]* %582, i64 0, i64 4
%584 = load double, double* %583
%585 = load double, double* %6
%586 = load [5 x double]*, [5 x double]** %3
%587 = getelementptr inbounds [5 x double], [5 x double]* %586, i64 4
%588 = getelementptr inbounds [5 x double], [5 x double]* %587, i64 0, i64 1
%589 = load double, double* %588
%590 = fneg double %585
%591 = call double @llvm.fmuladd.f64(double %590, double %589, double %584)
%592 = load [5 x double]*, [5 x double]** %3
%593 = getelementptr inbounds [5 x double], [5 x double]* %592, i64 4
%594 = getelementptr inbounds [5 x double], [5 x double]* %593, i64 0, i64 4
store double %591, double* %594
%595 = load double*, double** %4
%596 = getelementptr inbounds double, double* %595, i64 4
%597 = load double, double* %596
%598 = load double, double* %6
%599 = load double*, double** %4
%600 = getelementptr inbounds double, double* %599, i64 1
%601 = load double, double* %600
%602 = fneg double %598
%603 = call double @llvm.fmuladd.f64(double %602, double %601, double %597)
%604 = load double*, double** %4
%605 = getelementptr inbounds double, double* %604, i64 4
store double %603, double* %605
%606 = load [5 x double]*, [5 x double]** %3
%607 = getelementptr inbounds [5 x double], [5 x double]* %606, i64 2
%608 = getelementptr inbounds [5 x double], [5 x double]* %607, i64 0, i64 2
%609 = load double, double* %608
%610 = fdiv double 1.000000e+00, %609
store double %610, double* %5
%611 = load [5 x double]*, [5 x double]** %3
%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 2
%614 = load double, double* %613
%615 = load double, double* %5
%616 = fmul double %614, %615
%617 = load [5 x double]*, [5 x double]** %3
%618 = getelementptr inbounds [5 x double], [5 x double]* %617, i64 3
%619 = getelementptr inbounds [5 x double], [5 x double]* %618, i64 0, i64 2
store double %616, double* %619
%620 = load [5 x double]*, [5 x double]** %3
%621 = getelementptr inbounds [5 x double], [5 x double]* %620, i64 4
%622 = getelementptr inbounds [5 x double], [5 x double]* %621, i64 0, i64 2
%623 = load double, double* %622
%624 = load double, double* %5
%625 = fmul double %623, %624
%626 = load [5 x double]*, [5 x double]** %3
%627 = getelementptr inbounds [5 x double], [5 x double]* %626, i64 4
%628 = getelementptr inbounds [5 x double], [5 x double]* %627, i64 0, i64 2
store double %625, double* %628
%629 = load double*, double** %4
%630 = getelementptr inbounds double, double* %629, i64 2
%631 = load double, double* %630
%632 = load double, double* %5
%633 = fmul double %631, %632
%634 = load double*, double** %4
%635 = getelementptr inbounds double, double* %634, i64 2
store double %633, double* %635
%636 = load [5 x double]*, [5 x double]** %3
%637 = getelementptr inbounds [5 x double], [5 x double]* %636, i64 2
%638 = getelementptr inbounds [5 x double], [5 x double]* %637, i64 0, i64 0
%639 = load double, double* %638
store double %639, double* %6
%640 = load [5 x double]*, [5 x double]** %3
%641 = getelementptr inbounds [5 x double], [5 x double]* %640, i64 3
%642 = getelementptr inbounds [5 x double], [5 x double]* %641, i64 0, i64 0
%643 = load double, double* %642
%644 = load double, double* %6
%645 = load [5 x double]*, [5 x double]** %3
%646 = getelementptr inbounds [5 x double], [5 x double]* %645, i64 3
%647 = getelementptr inbounds [5 x double], [5 x double]* %646, i64 0, i64 2
%648 = load double, double* %647
%649 = fneg double %644
%650 = call double @llvm.fmuladd.f64(double %649, double %648, double %643)
%651 = load [5 x double]*, [5 x double]** %3
%652 = getelementptr inbounds [5 x double], [5 x double]* %651, i64 3
%653 = getelementptr inbounds [5 x double], [5 x double]* %652, i64 0, i64 0
store double %650, double* %653
%654 = load [5 x double]*, [5 x double]** %3
%655 = getelementptr inbounds [5 x double], [5 x double]* %654, i64 4
%656 = getelementptr inbounds [5 x double], [5 x double]* %655, i64 0, i64 0
%657 = load double, double* %656
%658 = load double, double* %6
%659 = load [5 x double]*, [5 x double]** %3
%660 = getelementptr inbounds [5 x double], [5 x double]* %659, i64 4
%661 = getelementptr inbounds [5 x double], [5 x double]* %660, i64 0, i64 2
%662 = load double, double* %661
%663 = fneg double %658
%664 = call double @llvm.fmuladd.f64(double %663, double %662, double %657)
%665 = load [5 x double]*, [5 x double]** %3
%666 = getelementptr inbounds [5 x double], [5 x double]* %665, i64 4
%667 = getelementptr inbounds [5 x double], [5 x double]* %666, i64 0, i64 0
store double %664, double* %667
%668 = load double*, double** %4
%669 = getelementptr inbounds double, double* %668, i64 0
%670 = load double, double* %669
%671 = load double, double* %6
%672 = load double*, double** %4
%673 = getelementptr inbounds double, double* %672, i64 2
%674 = load double, double* %673
%675 = fneg double %671
%676 = call double @llvm.fmuladd.f64(double %675, double %674, double %670)
%677 = load double*, double** %4
%678 = getelementptr inbounds double, double* %677, i64 0
store double %676, double* %678
%679 = load [5 x double]*, [5 x double]** %3
%680 = getelementptr inbounds [5 x double], [5 x double]* %679, i64 2
%681 = getelementptr inbounds [5 x double], [5 x double]* %680, i64 0, i64 1
%682 = load double, double* %681
store double %682, double* %6
%683 = load [5 x double]*, [5 x double]** %3
%684 = getelementptr inbounds [5 x double], [5 x double]* %683, i64 3
%685 = getelementptr inbounds [5 x double], [5 x double]* %684, i64 0, i64 1
%686 = load double, double* %685
%687 = load double, double* %6
%688 = load [5 x double]*, [5 x double]** %3
%689 = getelementptr inbounds [5 x double], [5 x double]* %688, i64 3
%690 = getelementptr inbounds [5 x double], [5 x double]* %689, i64 0, i64 2
%691 = load double, double* %690
%692 = fneg double %687
%693 = call double @llvm.fmuladd.f64(double %692, double %691, double %686)
%694 = load [5 x double]*, [5 x double]** %3
%695 = getelementptr inbounds [5 x double], [5 x double]* %694, i64 3
%696 = getelementptr inbounds [5 x double], [5 x double]* %695, i64 0, i64 1
store double %693, double* %696
%697 = load [5 x double]*, [5 x double]** %3
%698 = getelementptr inbounds [5 x double], [5 x double]* %697, i64 4
%699 = getelementptr inbounds [5 x double], [5 x double]* %698, i64 0, i64 1
%700 = load double, double* %699
%701 = load double, double* %6
%702 = load [5 x double]*, [5 x double]** %3
%703 = getelementptr inbounds [5 x double], [5 x double]* %702, i64 4
%704 = getelementptr inbounds [5 x double], [5 x double]* %703, i64 0, i64 2
%705 = load double, double* %704
%706 = fneg double %701
%707 = call double @llvm.fmuladd.f64(double %706, double %705, double %700)
%708 = load [5 x double]*, [5 x double]** %3
%709 = getelementptr inbounds [5 x double], [5 x double]* %708, i64 4
%710 = getelementptr inbounds [5 x double], [5 x double]* %709, i64 0, i64 1
store double %707, double* %710
%711 = load double*, double** %4
%712 = getelementptr inbounds double, double* %711, i64 1
%713 = load double, double* %712
%714 = load double, double* %6
%715 = load double*, double** %4
%716 = getelementptr inbounds double, double* %715, i64 2
%717 = load double, double* %716
%718 = fneg double %714
%719 = call double @llvm.fmuladd.f64(double %718, double %717, double %713)
%720 = load double*, double** %4
%721 = getelementptr inbounds double, double* %720, i64 1
store double %719, double* %721
%722 = load [5 x double]*, [5 x double]** %3
%723 = getelementptr inbounds [5 x double], [5 x double]* %722, i64 2
%724 = getelementptr inbounds [5 x double], [5 x double]* %723, i64 0, i64 3
%725 = load double, double* %724
store double %725, double* %6
%726 = load [5 x double]*, [5 x double]** %3
%727 = getelementptr inbounds [5 x double], [5 x double]* %726, i64 3
%728 = getelementptr inbounds [5 x double], [5 x double]* %727, i64 0, i64 3
%729 = load double, double* %728
%730 = load double, double* %6
%731 = load [5 x double]*, [5 x double]** %3
%732 = getelementptr inbounds [5 x double], [5 x double]* %731, i64 3
%733 = getelementptr inbounds [5 x double], [5 x double]* %732, i64 0, i64 2
%734 = load double, double* %733
%735 = fneg double %730
%736 = call double @llvm.fmuladd.f64(double %735, double %734, double %729)
%737 = load [5 x double]*, [5 x double]** %3
%738 = getelementptr inbounds [5 x double], [5 x double]* %737, i64 3
%739 = getelementptr inbounds [5 x double], [5 x double]* %738, i64 0, i64 3
store double %736, double* %739
%740 = load [5 x double]*, [5 x double]** %3
%741 = getelementptr inbounds [5 x double], [5 x double]* %740, i64 4
%742 = getelementptr inbounds [5 x double], [5 x double]* %741, i64 0, i64 3
%743 = load double, double* %742
%744 = load double, double* %6
%745 = load [5 x double]*, [5 x double]** %3
%746 = getelementptr inbounds [5 x double], [5 x double]* %745, i64 4
%747 = getelementptr inbounds [5 x double], [5 x double]* %746, i64 0, i64 2
%748 = load double, double* %747
%749 = fneg double %744
%750 = call double @llvm.fmuladd.f64(double %749, double %748, double %743)
%751 = load [5 x double]*, [5 x double]** %3
%752 = getelementptr inbounds [5 x double], [5 x double]* %751, i64 4
%753 = getelementptr inbounds [5 x double], [5 x double]* %752, i64 0, i64 3
store double %750, double* %753
%754 = load double*, double** %4
%755 = getelementptr inbounds double, double* %754, i64 3
%756 = load double, double* %755
%757 = load double, double* %6
%758 = load double*, double** %4
%759 = getelementptr inbounds double, double* %758, i64 2
%760 = load double, double* %759
%761 = fneg double %757
%762 = call double @llvm.fmuladd.f64(double %761, double %760, double %756)
%763 = load double*, double** %4
%764 = getelementptr inbounds double, double* %763, i64 3
store double %762, double* %764
%765 = load [5 x double]*, [5 x double]** %3
%766 = getelementptr inbounds [5 x double], [5 x double]* %765, i64 2
%767 = getelementptr inbounds [5 x double], [5 x double]* %766, i64 0, i64 4
%768 = load double, double* %767
store double %768, double* %6
%769 = load [5 x double]*, [5 x double]** %3
%770 = getelementptr inbounds [5 x double], [5 x double]* %769, i64 3
%771 = getelementptr inbounds [5 x double], [5 x double]* %770, i64 0, i64 4
%772 = load double, double* %771
%773 = load double, double* %6
%774 = load [5 x double]*, [5 x double]** %3
%775 = getelementptr inbounds [5 x double], [5 x double]* %774, i64 3
%776 = getelementptr inbounds [5 x double], [5 x double]* %775, i64 0, i64 2
%777 = load double, double* %776
%778 = fneg double %773
%779 = call double @llvm.fmuladd.f64(double %778, double %777, double %772)
%780 = load [5 x double]*, [5 x double]** %3
%781 = getelementptr inbounds [5 x double], [5 x double]* %780, i64 3
%782 = getelementptr inbounds [5 x double], [5 x double]* %781, i64 0, i64 4
store double %779, double* %782
%783 = load [5 x double]*, [5 x double]** %3
%784 = getelementptr inbounds [5 x double], [5 x double]* %783, i64 4
%785 = getelementptr inbounds [5 x double], [5 x double]* %784, i64 0, i64 4
%786 = load double, double* %785
%787 = load double, double* %6
%788 = load [5 x double]*, [5 x double]** %3
%789 = getelementptr inbounds [5 x double], [5 x double]* %788, i64 4
%790 = getelementptr inbounds [5 x double], [5 x double]* %789, i64 0, i64 2
%791 = load double, double* %790
%792 = fneg double %787
%793 = call double @llvm.fmuladd.f64(double %792, double %791, double %786)
%794 = load [5 x double]*, [5 x double]** %3
%795 = getelementptr inbounds [5 x double], [5 x double]* %794, i64 4
%796 = getelementptr inbounds [5 x double], [5 x double]* %795, i64 0, i64 4
store double %793, double* %796
%797 = load double*, double** %4
%798 = getelementptr inbounds double, double* %797, i64 4
%799 = load double, double* %798
%800 = load double, double* %6
%801 = load double*, double** %4
%802 = getelementptr inbounds double, double* %801, i64 2
%803 = load double, double* %802
%804 = fneg double %800
%805 = call double @llvm.fmuladd.f64(double %804, double %803, double %799)
%806 = load double*, double** %4
%807 = getelementptr inbounds double, double* %806, i64 4
store double %805, double* %807
%808 = load [5 x double]*, [5 x double]** %3
%809 = getelementptr inbounds [5 x double], [5 x double]* %808, i64 3
%810 = getelementptr inbounds [5 x double], [5 x double]* %809, i64 0, i64 3
%811 = load double, double* %810
%812 = fdiv double 1.000000e+00, %811
store double %812, double* %5
%813 = load [5 x double]*, [5 x double]** %3
%814 = getelementptr inbounds [5 x double], [5 x double]* %813, i64 4
%815 = getelementptr inbounds [5 x double], [5 x double]* %814, i64 0, i64 3
%816 = load double, double* %815
%817 = load double, double* %5
%818 = fmul double %816, %817
%819 = load [5 x double]*, [5 x double]** %3
%820 = getelementptr inbounds [5 x double], [5 x double]* %819, i64 4
%821 = getelementptr inbounds [5 x double], [5 x double]* %820, i64 0, i64 3
store double %818, double* %821
%822 = load double*, double** %4
%823 = getelementptr inbounds double, double* %822, i64 3
%824 = load double, double* %823
%825 = load double, double* %5
%826 = fmul double %824, %825
%827 = load double*, double** %4
%828 = getelementptr inbounds double, double* %827, i64 3
store double %826, double* %828
%829 = load [5 x double]*, [5 x double]** %3
%830 = getelementptr inbounds [5 x double], [5 x double]* %829, i64 3
%831 = getelementptr inbounds [5 x double], [5 x double]* %830, i64 0, i64 0
%832 = load double, double* %831
store double %832, double* %6
%833 = load [5 x double]*, [5 x double]** %3
%834 = getelementptr inbounds [5 x double], [5 x double]* %833, i64 4
%835 = getelementptr inbounds [5 x double], [5 x double]* %834, i64 0, i64 0
%836 = load double, double* %835
%837 = load double, double* %6
%838 = load [5 x double]*, [5 x double]** %3
%839 = getelementptr inbounds [5 x double], [5 x double]* %838, i64 4
%840 = getelementptr inbounds [5 x double], [5 x double]* %839, i64 0, i64 3
%841 = load double, double* %840
%842 = fneg double %837
%843 = call double @llvm.fmuladd.f64(double %842, double %841, double %836)
%844 = load [5 x double]*, [5 x double]** %3
%845 = getelementptr inbounds [5 x double], [5 x double]* %844, i64 4
%846 = getelementptr inbounds [5 x double], [5 x double]* %845, i64 0, i64 0
store double %843, double* %846
%847 = load double*, double** %4
%848 = getelementptr inbounds double, double* %847, i64 0
%849 = load double, double* %848
%850 = load double, double* %6
%851 = load double*, double** %4
%852 = getelementptr inbounds double, double* %851, i64 3
%853 = load double, double* %852
%854 = fneg double %850
%855 = call double @llvm.fmuladd.f64(double %854, double %853, double %849)
%856 = load double*, double** %4
%857 = getelementptr inbounds double, double* %856, i64 0
store double %855, double* %857
%858 = load [5 x double]*, [5 x double]** %3
%859 = getelementptr inbounds [5 x double], [5 x double]* %858, i64 3
%860 = getelementptr inbounds [5 x double], [5 x double]* %859, i64 0, i64 1
%861 = load double, double* %860
store double %861, double* %6
%862 = load [5 x double]*, [5 x double]** %3
%863 = getelementptr inbounds [5 x double], [5 x double]* %862, i64 4
%864 = getelementptr inbounds [5 x double], [5 x double]* %863, i64 0, i64 1
%865 = load double, double* %864
%866 = load double, double* %6
%867 = load [5 x double]*, [5 x double]** %3
%868 = getelementptr inbounds [5 x double], [5 x double]* %867, i64 4
%869 = getelementptr inbounds [5 x double], [5 x double]* %868, i64 0, i64 3
%870 = load double, double* %869
%871 = fneg double %866
%872 = call double @llvm.fmuladd.f64(double %871, double %870, double %865)
%873 = load [5 x double]*, [5 x double]** %3
%874 = getelementptr inbounds [5 x double], [5 x double]* %873, i64 4
%875 = getelementptr inbounds [5 x double], [5 x double]* %874, i64 0, i64 1
store double %872, double* %875
%876 = load double*, double** %4
%877 = getelementptr inbounds double, double* %876, i64 1
%878 = load double, double* %877
%879 = load double, double* %6
%880 = load double*, double** %4
%881 = getelementptr inbounds double, double* %880, i64 3
%882 = load double, double* %881
%883 = fneg double %879
%884 = call double @llvm.fmuladd.f64(double %883, double %882, double %878)
%885 = load double*, double** %4
%886 = getelementptr inbounds double, double* %885, i64 1
store double %884, double* %886
%887 = load [5 x double]*, [5 x double]** %3
%888 = getelementptr inbounds [5 x double], [5 x double]* %887, i64 3
%889 = getelementptr inbounds [5 x double], [5 x double]* %888, i64 0, i64 2
%890 = load double, double* %889
store double %890, double* %6
%891 = load [5 x double]*, [5 x double]** %3
%892 = getelementptr inbounds [5 x double], [5 x double]* %891, i64 4
%893 = getelementptr inbounds [5 x double], [5 x double]* %892, i64 0, i64 2
%894 = load double, double* %893
%895 = load double, double* %6
%896 = load [5 x double]*, [5 x double]** %3
%897 = getelementptr inbounds [5 x double], [5 x double]* %896, i64 4
%898 = getelementptr inbounds [5 x double], [5 x double]* %897, i64 0, i64 3
%899 = load double, double* %898
%900 = fneg double %895
%901 = call double @llvm.fmuladd.f64(double %900, double %899, double %894)
%902 = load [5 x double]*, [5 x double]** %3
%903 = getelementptr inbounds [5 x double], [5 x double]* %902, i64 4
%904 = getelementptr inbounds [5 x double], [5 x double]* %903, i64 0, i64 2
store double %901, double* %904
%905 = load double*, double** %4
%906 = getelementptr inbounds double, double* %905, i64 2
%907 = load double, double* %906
%908 = load double, double* %6
%909 = load double*, double** %4
%910 = getelementptr inbounds double, double* %909, i64 3
%911 = load double, double* %910
%912 = fneg double %908
%913 = call double @llvm.fmuladd.f64(double %912, double %911, double %907)
%914 = load double*, double** %4
%915 = getelementptr inbounds double, double* %914, i64 2
store double %913, double* %915
%916 = load [5 x double]*, [5 x double]** %3
%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 4
%919 = load double, double* %918
store double %919, double* %6
%920 = load [5 x double]*, [5 x double]** %3
%921 = getelementptr inbounds [5 x double], [5 x double]* %920, i64 4
%922 = getelementptr inbounds [5 x double], [5 x double]* %921, i64 0, i64 4
%923 = load double, double* %922
%924 = load double, double* %6
%925 = load [5 x double]*, [5 x double]** %3
%926 = getelementptr inbounds [5 x double], [5 x double]* %925, i64 4
%927 = getelementptr inbounds [5 x double], [5 x double]* %926, i64 0, i64 3
%928 = load double, double* %927
%929 = fneg double %924
%930 = call double @llvm.fmuladd.f64(double %929, double %928, double %923)
%931 = load [5 x double]*, [5 x double]** %3
%932 = getelementptr inbounds [5 x double], [5 x double]* %931, i64 4
%933 = getelementptr inbounds [5 x double], [5 x double]* %932, i64 0, i64 4
store double %930, double* %933
%934 = load double*, double** %4
%935 = getelementptr inbounds double, double* %934, i64 4
%936 = load double, double* %935
%937 = load double, double* %6
%938 = load double*, double** %4
%939 = getelementptr inbounds double, double* %938, i64 3
%940 = load double, double* %939
%941 = fneg double %937
%942 = call double @llvm.fmuladd.f64(double %941, double %940, double %936)
%943 = load double*, double** %4
%944 = getelementptr inbounds double, double* %943, i64 4
store double %942, double* %944
%945 = load [5 x double]*, [5 x double]** %3
%946 = getelementptr inbounds [5 x double], [5 x double]* %945, i64 4
%947 = getelementptr inbounds [5 x double], [5 x double]* %946, i64 0, i64 4
%948 = load double, double* %947
%949 = fdiv double 1.000000e+00, %948
store double %949, double* %5
%950 = load double*, double** %4
%951 = getelementptr inbounds double, double* %950, i64 4
%952 = load double, double* %951
%953 = load double, double* %5
%954 = fmul double %952, %953
%955 = load double*, double** %4
%956 = getelementptr inbounds double, double* %955, i64 4
store double %954, double* %956
%957 = load [5 x double]*, [5 x double]** %3
%958 = getelementptr inbounds [5 x double], [5 x double]* %957, i64 4
%959 = getelementptr inbounds [5 x double], [5 x double]* %958, i64 0, i64 0
%960 = load double, double* %959
store double %960, double* %6
%961 = load double*, double** %4
%962 = getelementptr inbounds double, double* %961, i64 0
%963 = load double, double* %962
%964 = load double, double* %6
%965 = load double*, double** %4
%966 = getelementptr inbounds double, double* %965, i64 4
%967 = load double, double* %966
%968 = fneg double %964
%969 = call double @llvm.fmuladd.f64(double %968, double %967, double %963)
%970 = load double*, double** %4
%971 = getelementptr inbounds double, double* %970, i64 0
store double %969, double* %971
%972 = load [5 x double]*, [5 x double]** %3
%973 = getelementptr inbounds [5 x double], [5 x double]* %972, i64 4
%974 = getelementptr inbounds [5 x double], [5 x double]* %973, i64 0, i64 1
%975 = load double, double* %974
store double %975, double* %6
%976 = load double*, double** %4
%977 = getelementptr inbounds double, double* %976, i64 1
%978 = load double, double* %977
%979 = load double, double* %6
%980 = load double*, double** %4
%981 = getelementptr inbounds double, double* %980, i64 4
%982 = load double, double* %981
%983 = fneg double %979
%984 = call double @llvm.fmuladd.f64(double %983, double %982, double %978)
%985 = load double*, double** %4
%986 = getelementptr inbounds double, double* %985, i64 1
store double %984, double* %986
%987 = load [5 x double]*, [5 x double]** %3
%988 = getelementptr inbounds [5 x double], [5 x double]* %987, i64 4
%989 = getelementptr inbounds [5 x double], [5 x double]* %988, i64 0, i64 2
%990 = load double, double* %989
store double %990, double* %6
%991 = load double*, double** %4
%992 = getelementptr inbounds double, double* %991, i64 2
%993 = load double, double* %992
%994 = load double, double* %6
%995 = load double*, double** %4
%996 = getelementptr inbounds double, double* %995, i64 4
%997 = load double, double* %996
%998 = fneg double %994
%999 = call double @llvm.fmuladd.f64(double %998, double %997, double %993)
%1000 = load double*, double** %4
%1001 = getelementptr inbounds double, double* %1000, i64 2
store double %999, double* %1001
%1002 = load [5 x double]*, [5 x double]** %3
%1003 = getelementptr inbounds [5 x double], [5 x double]* %1002, i64 4
%1004 = getelementptr inbounds [5 x double], [5 x double]* %1003, i64 0, i64 3
%1005 = load double, double* %1004
store double %1005, double* %6
%1006 = load double*, double** %4
%1007 = getelementptr inbounds double, double* %1006, i64 3
%1008 = load double, double* %1007
%1009 = load double, double* %6
%1010 = load double*, double** %4
%1011 = getelementptr inbounds double, double* %1010, i64 4
%1012 = load double, double* %1011
%1013 = fneg double %1009
%1014 = call double @llvm.fmuladd.f64(double %1013, double %1012, double %1008)
%1015 = load double*, double** %4
%1016 = getelementptr inbounds double, double* %1015, i64 3
store double %1014, double* %1016
ret void
}

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