void hFuncRefC(float *packedPoints, float *H) {
  float x0 = *packedPoints++;
  float y0 = *packedPoints++;
  float x1 = *packedPoints++;
  float y1 = *packedPoints++;
  float x2 = *packedPoints++;
  float y2 = *packedPoints++;
  float x3 = *packedPoints++;
  float y3 = *packedPoints++;
  float X0 = *packedPoints++;
  float Y0 = *packedPoints++;
  float X1 = *packedPoints++;
  float Y1 = *packedPoints++;
  float X2 = *packedPoints++;
  float Y2 = *packedPoints++;
  float X3 = *packedPoints++;
  float Y3 = *packedPoints++;
  float x0X0 = x0 * X0, x1X1 = x1 * X1, x2X2 = x2 * X2, x3X3 = x3 * X3;
  float x0Y0 = x0 * Y0, x1Y1 = x1 * Y1, x2Y2 = x2 * Y2, x3Y3 = x3 * Y3;
  float y0X0 = y0 * X0, y1X1 = y1 * X1, y2X2 = y2 * X2, y3X3 = y3 * X3;
  float y0Y0 = y0 * Y0, y1Y1 = y1 * Y1, y2Y2 = y2 * Y2, y3Y3 = y3 * Y3;
  float minor[4][2] = {
      {x0 - x2, y0 - y2}, {x1 - x2, y1 - y2}, {x2, y2}, {x3 - x2, y3 - y2}};
  float major[8][3] = {{x2X2 - x0X0, y2X2 - y0X0, (X0 - X2)},
                       {x2X2 - x1X1, y2X2 - y1X1, (X1 - X2)},
                       {-x2X2, -y2X2, (X2)},
                       {x2X2 - x3X3, y2X2 - y3X3, (X3 - X2)},
                       {x2Y2 - x0Y0, y2Y2 - y0Y0, (Y0 - Y2)},
                       {x2Y2 - x1Y1, y2Y2 - y1Y1, (Y1 - Y2)},
                       {-x2Y2, -y2Y2, (Y2)},
                       {x2Y2 - x3Y3, y2Y2 - y3Y3, (Y3 - Y2)}};
  float scalar1 = minor[0][0], scalar2 = minor[1][0];
  minor[1][1] = minor[1][1] * scalar1 - minor[0][1] * scalar2;
  major[1][0] = major[1][0] * scalar1 - major[0][0] * scalar2;
  major[1][1] = major[1][1] * scalar1 - major[0][1] * scalar2;
  major[1][2] = major[1][2] * scalar1 - major[0][2] * scalar2;
  major[5][0] = major[5][0] * scalar1 - major[4][0] * scalar2;
  major[5][1] = major[5][1] * scalar1 - major[4][1] * scalar2;
  major[5][2] = major[5][2] * scalar1 - major[4][2] * scalar2;
  scalar2 = minor[3][0];
  minor[3][1] = minor[3][1] * scalar1 - minor[0][1] * scalar2;
  major[3][0] = major[3][0] * scalar1 - major[0][0] * scalar2;
  major[3][1] = major[3][1] * scalar1 - major[0][1] * scalar2;
  major[3][2] = major[3][2] * scalar1 - major[0][2] * scalar2;
  major[7][0] = major[7][0] * scalar1 - major[4][0] * scalar2;
  major[7][1] = major[7][1] * scalar1 - major[4][1] * scalar2;
  major[7][2] = major[7][2] * scalar1 - major[4][2] * scalar2;
  scalar1 = minor[1][1];
  scalar2 = minor[3][1];
  major[3][0] = major[3][0] * scalar1 - major[1][0] * scalar2;
  major[3][1] = major[3][1] * scalar1 - major[1][1] * scalar2;
  major[3][2] = major[3][2] * scalar1 - major[1][2] * scalar2;
  major[7][0] = major[7][0] * scalar1 - major[5][0] * scalar2;
  major[7][1] = major[7][1] * scalar1 - major[5][1] * scalar2;
  major[7][2] = major[7][2] * scalar1 - major[5][2] * scalar2;
  scalar2 = minor[0][1];
  minor[0][0] = minor[0][0] * scalar1 - minor[1][0] * scalar2;
  major[0][0] = major[0][0] * scalar1 - major[1][0] * scalar2;
  major[0][1] = major[0][1] * scalar1 - major[1][1] * scalar2;
  major[0][2] = major[0][2] * scalar1 - major[1][2] * scalar2;
  major[4][0] = major[4][0] * scalar1 - major[5][0] * scalar2;
  major[4][1] = major[4][1] * scalar1 - major[5][1] * scalar2;
  major[4][2] = major[4][2] * scalar1 - major[5][2] * scalar2;
  scalar1 = minor[0][0];
  major[0][0] /= scalar1;
  major[0][1] /= scalar1;
  major[0][2] /= scalar1;
  major[4][0] /= scalar1;
  major[4][1] /= scalar1;
  major[4][2] /= scalar1;
  scalar1 = minor[1][1];
  major[1][0] /= scalar1;
  major[1][1] /= scalar1;
  major[1][2] /= scalar1;
  major[5][0] /= scalar1;
  major[5][1] /= scalar1;
  major[5][2] /= scalar1;
  scalar1 = minor[2][0];
  scalar2 = minor[2][1];
  major[2][0] -= major[0][0] * scalar1 + major[1][0] * scalar2;
  major[2][1] -= major[0][1] * scalar1 + major[1][1] * scalar2;
  major[2][2] -= major[0][2] * scalar1 + major[1][2] * scalar2;
  major[6][0] -= major[4][0] * scalar1 + major[5][0] * scalar2;
  major[6][1] -= major[4][1] * scalar1 + major[5][1] * scalar2;
  major[6][2] -= major[4][2] * scalar1 + major[5][2] * scalar2;
  scalar1 = major[7][0];
  major[7][1] /= scalar1;
  major[7][2] /= scalar1;
  scalar1 = major[0][0];
  major[0][1] -= scalar1 * major[7][1];
  major[0][2] -= scalar1 * major[7][2];
  scalar1 = major[1][0];
  major[1][1] -= scalar1 * major[7][1];
  major[1][2] -= scalar1 * major[7][2];
  scalar1 = major[2][0];
  major[2][1] -= scalar1 * major[7][1];
  major[2][2] -= scalar1 * major[7][2];
  scalar1 = major[3][0];
  major[3][1] -= scalar1 * major[7][1];
  major[3][2] -= scalar1 * major[7][2];
  scalar1 = major[4][0];
  major[4][1] -= scalar1 * major[7][1];
  major[4][2] -= scalar1 * major[7][2];
  scalar1 = major[5][0];
  major[5][1] -= scalar1 * major[7][1];
  major[5][2] -= scalar1 * major[7][2];
  scalar1 = major[6][0];
  major[6][1] -= scalar1 * major[7][1];
  major[6][2] -= scalar1 * major[7][2];
  scalar1 = major[3][1];
  major[3][2] /= scalar1;
  scalar1 = major[0][1];
  major[0][2] -= scalar1 * major[3][2];
  scalar1 = major[1][1];
  major[1][2] -= scalar1 * major[3][2];
  scalar1 = major[2][1];
  major[2][2] -= scalar1 * major[3][2];
  scalar1 = major[4][1];
  major[4][2] -= scalar1 * major[3][2];
  scalar1 = major[5][1];
  major[5][2] -= scalar1 * major[3][2];
  scalar1 = major[6][1];
  major[6][2] -= scalar1 * major[3][2];
  scalar1 = major[7][1];
  major[7][2] -= scalar1 * major[3][2];
  H[0] = major[0][2];
  H[1] = major[1][2];
  H[2] = major[2][2];
  H[4] = major[4][2];
  H[5] = major[5][2];
  H[6] = major[6][2];
  H[8] = major[7][2];
  H[9] = major[3][2];
  H[10] = 1.0;
}


x86 assembly (clang, -O0):
<hFuncRefC>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x20(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x28(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x30(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x14(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x18(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x30(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x34(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x38(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x40(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x50(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xac(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x110(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x10c(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0xfc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x108(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xac(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x110(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x10c(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x108(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xe0(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x104(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd0(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xa8(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x104(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd0(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm1
ff
mulss  -0x118(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x110(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x10c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x108(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xe0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xdc(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xd8(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x104(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0x100(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xfc(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xd0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x110(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x104(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf8(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0x10c(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf4(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x108(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xf0(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xe0(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc8(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xdc(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xd0(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xd8(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0x118(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc0(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x110(%rbp),%xmm0
movss  %xmm0,-0x114(%rbp)
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0x10c(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0x108(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0x100(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xf8(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xf4(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xe8(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xe4(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xdc(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xd0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xc4(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm2
ff
movss  -0xc0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xe4(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0x108(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x100(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xf0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xc0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  -0xe4(%rbp),%xmm2
ff
movss  -0xb4(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xfc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0xe4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x10(%rbp),%rax
movss  0xa09(%rip),%xmm0
movss  %xmm0,0x28(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hFuncRefC>:
sub    $0xa8,%rsp
movss  (%rdi),%xmm6
movss  0x4(%rdi),%xmm8
movss  0x8(%rdi),%xmm5
movss  0xc(%rdi),%xmm9
movss  0x10(%rdi),%xmm2
movss  0x14(%rdi),%xmm13
movss  %xmm13,-0x5c(%rsp)
movss  0x20(%rdi),%xmm0
movss  0x28(%rdi),%xmm3
movss  0x30(%rdi),%xmm7
movaps %xmm6,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm0,-0x6c(%rsp)
movaps %xmm5,%xmm10
mulss  %xmm3,%xmm10
movss  %xmm3,-0x70(%rsp)
movaps %xmm2,%xmm12
movaps %xmm2,%xmm14
mulss  %xmm7,%xmm12
movaps %xmm7,%xmm4
movss  %xmm7,-0x64(%rsp)
movaps %xmm8,%xmm2
movaps %xmm8,%xmm11
movaps %xmm8,0x10(%rsp)
mulss  %xmm0,%xmm2
movaps %xmm9,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm13,%xmm7
mulss  %xmm4,%xmm7
movaps %xmm12,%xmm4
subss  %xmm1,%xmm4
movaps %xmm4,%xmm8
movaps %xmm4,0x90(%rsp)
movaps %xmm7,%xmm1
subss  %xmm2,%xmm1
movaps %xmm1,-0x50(%rsp)
movaps %xmm12,%xmm15
subss  %xmm10,%xmm15
movaps %xmm7,%xmm13
subss  %xmm0,%xmm13
movss  0x18(%rdi),%xmm4
movss  0x38(%rdi),%xmm2
movss  %xmm2,-0x60(%rsp)
movaps %xmm4,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm12,-0x40(%rsp)
subss  %xmm0,%xmm12
movaps %xmm12,0x70(%rsp)
movss  0x1c(%rdi),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm7,0x80(%rsp)
subss  %xmm1,%xmm7
movaps %xmm7,0x60(%rsp)
movss  0x24(%rdi),%xmm0
movss  %xmm0,-0x68(%rsp)
movaps %xmm6,%xmm1
mulss  %xmm0,%xmm1
movss  0x34(%rdi),%xmm10
movss  %xmm10,-0x58(%rsp)
movaps %xmm14,%xmm12
mulss  %xmm10,%xmm14
movaps %xmm14,%xmm2
subss  %xmm1,%xmm2
movaps %xmm2,0x50(%rsp)
movaps %xmm11,%xmm1
mulss  %xmm0,%xmm1
movss  -0x5c(%rsp),%xmm7
mulss  %xmm10,%xmm7
movaps %xmm7,%xmm0
subss  %xmm1,%xmm0
movaps %xmm0,0x40(%rsp)
movss  0x2c(%rdi),%xmm0
movss  %xmm0,-0x74(%rsp)
movaps %xmm5,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm14,%xmm10
subss  %xmm1,%xmm10
movaps %xmm9,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm7,%xmm2
subss  %xmm1,%xmm2
movss  0x3c(%rdi),%xmm11
movaps %xmm4,%xmm1
mulss  %xmm11,%xmm1
movaps %xmm14,-0x20(%rsp)
subss  %xmm1,%xmm14
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
movaps %xmm7,-0x30(%rsp)
subss  %xmm1,%xmm7
movss  %xmm12,-0x54(%rsp)
subss  %xmm12,%xmm6
subss  %xmm12,%xmm5
movaps %xmm5,%xmm1
mulss  %xmm8,%xmm1
mulss  %xmm6,%xmm15
subss  %xmm1,%xmm15
movaps %xmm15,(%rsp)
movaps %xmm5,%xmm1
movaps -0x50(%rsp),%xmm8
mulss  %xmm8,%xmm1
mulss  %xmm6,%xmm13
subss  %xmm1,%xmm13
movaps %xmm13,-0x10(%rsp)
movss  -0x64(%rsp),%xmm13
movss  -0x6c(%rsp),%xmm1
subss  %xmm13,%xmm1
movss  %xmm1,-0x6c(%rsp)
movss  -0x70(%rsp),%xmm0
subss  %xmm13,%xmm0
movaps %xmm5,%xmm13
mulss  %xmm1,%xmm13
mulss  %xmm6,%xmm0
subss  %xmm13,%xmm0
movss  %xmm0,-0x70(%rsp)
movaps %xmm5,%xmm1
mulss  0x50(%rsp),%xmm1
mulss  %xmm6,%xmm10
subss  %xmm1,%xmm10
movaps %xmm10,0x30(%rsp)
movaps %xmm5,%xmm1
mulss  0x40(%rsp),%xmm1
mulss  %xmm6,%xmm2
subss  %xmm1,%xmm2
movaps %xmm2,0x20(%rsp)
movss  -0x5c(%rsp),%xmm10
movaps 0x10(%rsp),%xmm12
subss  %xmm10,%xmm12
movaps %xmm12,0x10(%rsp)
movaps 0xc80(%rip),%xmm13
movaps -0x40(%rsp),%xmm0
xorps  %xmm13,%xmm0
movaps %xmm0,-0x40(%rsp)
movaps 0x80(%rsp),%xmm0
xorps  %xmm13,%xmm0
movaps %xmm0,0x80(%rsp)
movss  -0x58(%rsp),%xmm0
movss  -0x68(%rsp),%xmm2
subss  %xmm0,%xmm2
movss  -0x74(%rsp),%xmm1
subss  %xmm0,%xmm1
movaps -0x20(%rsp),%xmm0
xorps  %xmm13,%xmm0
movaps %xmm0,-0x20(%rsp)
movaps -0x30(%rsp),%xmm0
xorps  %xmm13,%xmm0
movaps %xmm0,-0x30(%rsp)
xorps  %xmm12,%xmm13
mulss  %xmm5,%xmm13
mulss  %xmm2,%xmm5
movss  %xmm2,-0x68(%rsp)
mulss  %xmm6,%xmm1
subss  %xmm5,%xmm1
movss  %xmm1,-0x74(%rsp)
subss  -0x54(%rsp),%xmm4
subss  %xmm10,%xmm3
movaps %xmm4,%xmm5
mulss  %xmm12,%xmm5
mulss  %xmm6,%xmm3
subss  %xmm5,%xmm3
movaps %xmm4,%xmm5
mulss  0x90(%rsp),%xmm5
movaps 0x70(%rsp),%xmm1
mulss  %xmm6,%xmm1
subss  %xmm5,%xmm1
movaps %xmm4,%xmm5
mulss  %xmm8,%xmm5
movaps 0x60(%rsp),%xmm15
mulss  %xmm6,%xmm15
subss  %xmm5,%xmm15
movaps %xmm15,%xmm8
movss  -0x60(%rsp),%xmm0
subss  -0x64(%rsp),%xmm0
movaps %xmm4,%xmm5
mulss  -0x6c(%rsp),%xmm5
mulss  %xmm6,%xmm0
subss  %xmm5,%xmm0
movaps %xmm0,%xmm12
movaps %xmm4,%xmm5
mulss  0x50(%rsp),%xmm5
mulss  %xmm6,%xmm14
subss  %xmm5,%xmm14
movaps %xmm4,%xmm5
mulss  0x40(%rsp),%xmm5
mulss  %xmm6,%xmm7
subss  %xmm5,%xmm7
subss  -0x58(%rsp),%xmm11
mulss  %xmm2,%xmm4
mulss  %xmm6,%xmm11
subss  %xmm4,%xmm11
subss  %xmm10,%xmm9
mulss  %xmm6,%xmm9
addss  %xmm13,%xmm9
movaps %xmm3,%xmm2
movaps (%rsp),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm9,%xmm1
subss  %xmm2,%xmm1
movaps %xmm1,0x70(%rsp)
movaps %xmm3,%xmm2
movaps -0x10(%rsp),%xmm15
mulss  %xmm15,%xmm2
movaps %xmm8,%xmm0
mulss  %xmm9,%xmm0
subss  %xmm2,%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm3,%xmm2
movss  -0x70(%rsp),%xmm1
mulss  %xmm1,%xmm2
mulss  %xmm9,%xmm12
subss  %xmm2,%xmm12
movss  %xmm12,-0x60(%rsp)
movaps %xmm3,%xmm2
movaps 0x30(%rsp),%xmm4
mulss  %xmm4,%xmm2
mulss  %xmm9,%xmm14
subss  %xmm2,%xmm14
movaps %xmm3,%xmm2
movaps 0x20(%rsp),%xmm8
mulss  %xmm8,%xmm2
mulss  %xmm9,%xmm7
subss  %xmm2,%xmm7
mulss  -0x74(%rsp),%xmm3
mulss  %xmm9,%xmm11
subss  %xmm3,%xmm11
mulss  %xmm9,%xmm6
addss  %xmm13,%xmm6
movaps 0x10(%rsp),%xmm3
movaps %xmm3,%xmm0
mulss  %xmm5,%xmm0
movaps 0x90(%rsp),%xmm10
mulss  %xmm9,%xmm10
subss  %xmm0,%xmm10
movaps %xmm3,%xmm0
mulss  %xmm15,%xmm0
movaps -0x50(%rsp),%xmm2
mulss  %xmm9,%xmm2
subss  %xmm0,%xmm2
movaps %xmm2,-0x50(%rsp)
movaps %xmm3,%xmm0
mulss  %xmm1,%xmm0
movss  -0x6c(%rsp),%xmm12
mulss  %xmm9,%xmm12
subss  %xmm0,%xmm12
movaps %xmm3,%xmm0
mulss  %xmm4,%xmm0
movaps 0x50(%rsp),%xmm13
mulss  %xmm9,%xmm13
subss  %xmm0,%xmm13
movaps %xmm3,%xmm0
movaps %xmm8,%xmm1
mulss  %xmm8,%xmm0
movaps 0x40(%rsp),%xmm15
mulss  %xmm9,%xmm15
subss  %xmm0,%xmm15
movss  -0x74(%rsp),%xmm0
mulss  %xmm0,%xmm3
movaps %xmm3,%xmm2
movss  -0x68(%rsp),%xmm3
mulss  %xmm9,%xmm3
subss  %xmm2,%xmm3
divss  %xmm6,%xmm10
movaps -0x50(%rsp),%xmm5
divss  %xmm6,%xmm5
divss  %xmm6,%xmm12
divss  %xmm6,%xmm13
divss  %xmm6,%xmm15
divss  %xmm6,%xmm3
movss  %xmm3,-0x68(%rsp)
movaps (%rsp),%xmm3
divss  %xmm9,%xmm3
movaps %xmm3,(%rsp)
movaps -0x10(%rsp),%xmm6
divss  %xmm9,%xmm6
movaps %xmm6,-0x10(%rsp)
movss  -0x70(%rsp),%xmm2
divss  %xmm9,%xmm2
movss  %xmm2,-0x70(%rsp)
movaps %xmm4,%xmm8
divss  %xmm9,%xmm8
movaps %xmm8,0x30(%rsp)
divss  %xmm9,%xmm1
movaps %xmm1,0x20(%rsp)
divss  %xmm9,%xmm0
movss  %xmm0,-0x74(%rsp)
movss  -0x5c(%rsp),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm10,%xmm1
movss  -0x54(%rsp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps -0x40(%rsp),%xmm0
subss  %xmm1,%xmm0
movaps %xmm0,-0x40(%rsp)
movaps %xmm4,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm5,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps 0x80(%rsp),%xmm6
subss  %xmm1,%xmm6
movaps %xmm4,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm12,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rsp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rsp)
movaps %xmm4,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm13,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps -0x20(%rsp),%xmm0
subss  %xmm1,%xmm0
movaps %xmm0,-0x20(%rsp)
movaps %xmm4,%xmm0
movaps 0x20(%rsp),%xmm8
mulss  %xmm8,%xmm0
movaps %xmm15,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps -0x30(%rsp),%xmm0
subss  %xmm1,%xmm0
movaps %xmm0,-0x30(%rsp)
mulss  -0x74(%rsp),%xmm4
movss  -0x68(%rsp),%xmm2
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movaps %xmm3,%xmm0
movss  -0x58(%rsp),%xmm3
subss  %xmm0,%xmm3
divss  %xmm14,%xmm7
divss  %xmm14,%xmm11
movaps %xmm10,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm5
movaps %xmm5,-0x50(%rsp)
mulss  %xmm11,%xmm10
subss  %xmm10,%xmm12
movss  %xmm12,-0x6c(%rsp)
movaps (%rsp),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm7,%xmm0
movaps -0x10(%rsp),%xmm9
subss  %xmm0,%xmm9
mulss  %xmm11,%xmm1
movss  -0x70(%rsp),%xmm5
subss  %xmm1,%xmm5
movaps -0x40(%rsp),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm6
movaps %xmm6,%xmm10
mulss  %xmm11,%xmm4
movss  -0x64(%rsp),%xmm1
subss  %xmm4,%xmm1
movaps 0x70(%rsp),%xmm6
movaps %xmm6,%xmm0
mulss  %xmm7,%xmm0
movaps 0x60(%rsp),%xmm4
subss  %xmm0,%xmm4
mulss  %xmm11,%xmm6
movss  -0x60(%rsp),%xmm12
subss  %xmm6,%xmm12
divss  %xmm4,%xmm12
movaps %xmm12,%xmm14
movaps %xmm13,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm15
mulss  %xmm11,%xmm13
movaps %xmm2,%xmm12
subss  %xmm13,%xmm12
movaps 0x30(%rsp),%xmm2
movaps %xmm2,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm8
movaps %xmm8,%xmm13
mulss  %xmm11,%xmm2
movss  -0x74(%rsp),%xmm8
subss  %xmm2,%xmm8
movaps -0x20(%rsp),%xmm6
movaps %xmm6,%xmm0
mulss  %xmm7,%xmm0
movaps -0x30(%rsp),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm11,%xmm6
movaps %xmm3,%xmm4
subss  %xmm6,%xmm4
movaps -0x50(%rsp),%xmm0
movaps %xmm14,%xmm6
mulss  %xmm14,%xmm0
movss  -0x6c(%rsp),%xmm14
subss  %xmm0,%xmm14
mulss  %xmm6,%xmm9
subss  %xmm9,%xmm5
movaps %xmm10,%xmm0
mulss  %xmm6,%xmm0
subss  %xmm0,%xmm1
mulss  %xmm6,%xmm15
subss  %xmm15,%xmm12
mulss  %xmm6,%xmm13
subss  %xmm13,%xmm8
movaps %xmm2,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm4,%xmm2
subss  %xmm0,%xmm2
mulss  %xmm6,%xmm7
subss  %xmm7,%xmm11
movss  %xmm14,(%rsi)
movss  %xmm5,0x4(%rsi)
movss  %xmm1,0x8(%rsi)
movss  %xmm12,0x10(%rsi)
movss  %xmm8,0x14(%rsi)
movss  %xmm2,0x18(%rsi)
movss  %xmm11,0x20(%rsi)
movss  %xmm6,0x24(%rsi)
movl   $0x3f800000,0x28(%rsi)
add    $0xa8,%rsp
ret

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

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