void u3d_utilsBatchMatrixMultiplication(float *dst_vertex_raw_data,
                                        float *src_vertex_raw_data,
                                        unsigned src_vertex_len,
                                        float *matrix_raw_data,
                                        unsigned vertex_wide) {
  unsigned step = vertex_wide * 4;
  unsigned row00, row01, row02, row03;
  unsigned row10, row11, row12, row13;
  unsigned row20, row21, row22, row23;
  unsigned row30, row31, row32, row33;
  float dst[16];
  unsigned i;
  for (i = 0; i < src_vertex_len; i += step) {
    row00 = i + 0 * vertex_wide + 0;
    row01 = i + 0 * vertex_wide + 1;
    row02 = i + 0 * vertex_wide + 2;
    row03 = i + 0 * vertex_wide + 3;
    row10 = i + 1 * vertex_wide + 0;
    row11 = i + 1 * vertex_wide + 1;
    row12 = i + 1 * vertex_wide + 2;
    row13 = i + 1 * vertex_wide + 3;
    row20 = i + 2 * vertex_wide + 0;
    row21 = i + 2 * vertex_wide + 1;
    row22 = i + 2 * vertex_wide + 2;
    row23 = i + 2 * vertex_wide + 3;
    row30 = i + 3 * vertex_wide + 0;
    row31 = i + 3 * vertex_wide + 1;
    row32 = i + 3 * vertex_wide + 2;
    row33 = i + 3 * vertex_wide + 3;
    dst[0] = src_vertex_raw_data[row00] * matrix_raw_data[0] +
             src_vertex_raw_data[row01] * matrix_raw_data[4] +
             src_vertex_raw_data[row02] * matrix_raw_data[8] +
             src_vertex_raw_data[row03] * matrix_raw_data[12];
    dst[1] = src_vertex_raw_data[row00] * matrix_raw_data[1] +
             src_vertex_raw_data[row01] * matrix_raw_data[5] +
             src_vertex_raw_data[row02] * matrix_raw_data[9] +
             src_vertex_raw_data[row03] * matrix_raw_data[13];
    dst[2] = src_vertex_raw_data[row00] * matrix_raw_data[2] +
             src_vertex_raw_data[row01] * matrix_raw_data[6] +
             src_vertex_raw_data[row02] * matrix_raw_data[10] +
             src_vertex_raw_data[row03] * matrix_raw_data[14];
    dst[3] = src_vertex_raw_data[row00] * matrix_raw_data[3] +
             src_vertex_raw_data[row01] * matrix_raw_data[7] +
             src_vertex_raw_data[row02] * matrix_raw_data[11] +
             src_vertex_raw_data[row03] * matrix_raw_data[15];
    dst[4] = src_vertex_raw_data[row10] * matrix_raw_data[0] +
             src_vertex_raw_data[row11] * matrix_raw_data[4] +
             src_vertex_raw_data[row12] * matrix_raw_data[8] +
             src_vertex_raw_data[row13] * matrix_raw_data[12];
    dst[5] = src_vertex_raw_data[row10] * matrix_raw_data[1] +
             src_vertex_raw_data[row11] * matrix_raw_data[5] +
             src_vertex_raw_data[row12] * matrix_raw_data[9] +
             src_vertex_raw_data[row13] * matrix_raw_data[13];
    dst[6] = src_vertex_raw_data[row10] * matrix_raw_data[2] +
             src_vertex_raw_data[row11] * matrix_raw_data[6] +
             src_vertex_raw_data[row12] * matrix_raw_data[10] +
             src_vertex_raw_data[row13] * matrix_raw_data[14];
    dst[7] = src_vertex_raw_data[row10] * matrix_raw_data[3] +
             src_vertex_raw_data[row11] * matrix_raw_data[7] +
             src_vertex_raw_data[row12] * matrix_raw_data[11] +
             src_vertex_raw_data[row13] * matrix_raw_data[15];
    dst[8] = src_vertex_raw_data[row20] * matrix_raw_data[0] +
             src_vertex_raw_data[row21] * matrix_raw_data[4] +
             src_vertex_raw_data[row22] * matrix_raw_data[8] +
             src_vertex_raw_data[row23] * matrix_raw_data[12];
    dst[9] = src_vertex_raw_data[row20] * matrix_raw_data[1] +
             src_vertex_raw_data[row21] * matrix_raw_data[5] +
             src_vertex_raw_data[row22] * matrix_raw_data[9] +
             src_vertex_raw_data[row23] * matrix_raw_data[13];
    dst[10] = src_vertex_raw_data[row20] * matrix_raw_data[2] +
              src_vertex_raw_data[row21] * matrix_raw_data[6] +
              src_vertex_raw_data[row22] * matrix_raw_data[10] +
              src_vertex_raw_data[row23] * matrix_raw_data[14];
    dst[11] = src_vertex_raw_data[row20] * matrix_raw_data[3] +
              src_vertex_raw_data[row21] * matrix_raw_data[7] +
              src_vertex_raw_data[row22] * matrix_raw_data[11] +
              src_vertex_raw_data[row23] * matrix_raw_data[15];
    dst[12] = src_vertex_raw_data[row30] * matrix_raw_data[0] +
              src_vertex_raw_data[row31] * matrix_raw_data[4] +
              src_vertex_raw_data[row32] * matrix_raw_data[8] +
              src_vertex_raw_data[row33] * matrix_raw_data[12];
    dst[13] = src_vertex_raw_data[row30] * matrix_raw_data[1] +
              src_vertex_raw_data[row31] * matrix_raw_data[5] +
              src_vertex_raw_data[row32] * matrix_raw_data[9] +
              src_vertex_raw_data[row33] * matrix_raw_data[13];
    dst[14] = src_vertex_raw_data[row30] * matrix_raw_data[2] +
              src_vertex_raw_data[row31] * matrix_raw_data[6] +
              src_vertex_raw_data[row32] * matrix_raw_data[10] +
              src_vertex_raw_data[row33] * matrix_raw_data[14];
    dst[15] = src_vertex_raw_data[row30] * matrix_raw_data[3] +
              src_vertex_raw_data[row31] * matrix_raw_data[7] +
              src_vertex_raw_data[row32] * matrix_raw_data[11] +
              src_vertex_raw_data[row33] * matrix_raw_data[15];
    dst_vertex_raw_data[row00] = dst[0];
    dst_vertex_raw_data[row01] = dst[1];
    dst_vertex_raw_data[row02] = dst[2];
    dst_vertex_raw_data[row03] = dst[3];
    dst_vertex_raw_data[row10] = dst[4];
    dst_vertex_raw_data[row11] = dst[5];
    dst_vertex_raw_data[row12] = dst[6];
    dst_vertex_raw_data[row13] = dst[7];
    dst_vertex_raw_data[row20] = dst[8];
    dst_vertex_raw_data[row21] = dst[9];
    dst_vertex_raw_data[row22] = dst[10];
    dst_vertex_raw_data[row23] = dst[11];
    dst_vertex_raw_data[row30] = dst[12];
    dst_vertex_raw_data[row31] = dst[13];
    dst_vertex_raw_data[row32] = dst[14];
    dst_vertex_raw_data[row33] = dst[15];
  }
}


x86 assembly (clang, -O0):
<u3d_utilsBatchMatrixMultiplication>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1ae5 <u3d_utilsBatchMatrixMultiplication+0x9e5>
mov    -0xb4(%rbp),%eax
imul   $0x0,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x0,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x0,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x0,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x0,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x38(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
add    $0x0,%eax
mov    %eax,-0x3c(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x0,%eax
mov    %eax,-0x4c(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x3,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x0,%eax
mov    %eax,-0x5c(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x3,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x3,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0xb4(%rbp),%eax
imul   $0x3,-0x24(%rbp),%ecx
add    %ecx,%eax
add    $0x3,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x18(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xac(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x54(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    112e <u3d_utilsBatchMatrixMultiplication+0x2e>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<u3d_utilsBatchMatrixMultiplication>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
test   %edx,%edx
je     159e <u3d_utilsBatchMatrixMultiplication+0x49e>
lea    0x0(,%r8,4),%eax
mov    %eax,-0x80(%rsp)
lea    (%r8,%r8,1),%eax
mov    %rax,-0x60(%rsp)
lea    (%r8,%r8,2),%r11d
xor    %eax,%eax
mov    %edx,-0x7c(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rax),%r12d
lea    0x2(%rax),%r10d
lea    0x3(%rax),%r9d
lea    (%r8,%rax,1),%ebx
mov    %rbx,-0x40(%rsp)
lea    0x1(%r8,%rax,1),%ebp
mov    %rbp,-0x48(%rsp)
lea    0x2(%r8,%rax,1),%r14d
mov    %r14,-0x50(%rsp)
lea    0x3(%r8,%rax,1),%r15d
mov    %r15,-0x58(%rsp)
mov    %eax,%edx
mov    %rdx,-0x38(%rsp)
movss  (%rsi,%r12,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%rcx),%xmm10
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm7
mulps  %xmm1,%xmm0
movaps %xmm1,%xmm11
movss  (%rsi,%rdx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm10,%xmm1
addps  %xmm0,%xmm1
movss  (%rsi,%r10,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
movaps %xmm2,%xmm3
addps  %xmm1,%xmm0
movss  (%rsi,%r9,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm7,%xmm1
addps  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
movss  (%rsi,%rbx,4),%xmm8
movss  (%rsi,%rbp,4),%xmm6
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm8,%xmm1
mulss  %xmm10,%xmm1
addss  %xmm0,%xmm1
movss  (%rsi,%r14,4),%xmm0
movaps %xmm0,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm3,%xmm4
addss  %xmm1,%xmm2
movss  (%rsi,%r15,4),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm7,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,-0x64(%rsp)
movaps %xmm11,%xmm1
shufps $0x55,%xmm11,%xmm1
movaps %xmm1,0x10(%rsp)
mulss  %xmm6,%xmm1
movaps %xmm10,%xmm5
shufps $0x55,%xmm10,%xmm5
movaps %xmm5,0x40(%rsp)
movaps %xmm8,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm1,%xmm2
movaps %xmm4,%xmm15
movaps %xmm4,%xmm5
shufps $0x55,%xmm4,%xmm15
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  %xmm2,%xmm1
movaps %xmm7,%xmm4
shufps $0x55,%xmm7,%xmm4
movaps %xmm4,(%rsp)
movaps %xmm3,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x68(%rsp)
movaps %xmm11,%xmm1
unpckhpd %xmm11,%xmm1
movaps %xmm1,-0x10(%rsp)
mulss  %xmm6,%xmm1
movaps %xmm10,%xmm14
unpckhpd %xmm10,%xmm14
movaps %xmm8,%xmm2
mulss  %xmm14,%xmm2
addss  %xmm1,%xmm2
movaps %xmm5,%xmm12
unpckhpd %xmm5,%xmm12
movaps %xmm0,%xmm1
mulss  %xmm12,%xmm1
addss  %xmm2,%xmm1
movaps %xmm7,%xmm4
movhlps %xmm7,%xmm7
movaps %xmm7,-0x20(%rsp)
movaps %xmm3,%xmm2
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x6c(%rsp)
movaps %xmm11,0x30(%rsp)
movaps %xmm11,%xmm2
shufps $0xff,%xmm11,%xmm2
movaps %xmm2,-0x30(%rsp)
mulss  %xmm2,%xmm6
movaps %xmm10,%xmm7
shufps $0xff,%xmm10,%xmm7
mulss  %xmm7,%xmm8
addss  %xmm6,%xmm8
movaps %xmm5,%xmm6
movaps %xmm5,%xmm1
movaps %xmm5,0x20(%rsp)
shufps $0xff,%xmm5,%xmm6
mulss  %xmm6,%xmm0
addss  %xmm8,%xmm0
movaps %xmm4,%xmm8
movaps %xmm4,%xmm5
shufps $0xff,%xmm4,%xmm8
mulss  %xmm8,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,-0x70(%rsp)
mov    -0x60(%rsp),%rdx
lea    (%rdx,%rax,1),%r9d
lea    0x1(%rdx,%rax,1),%ebp
movss  (%rsi,%rbp,4),%xmm4
movaps %xmm11,%xmm0
mulss  %xmm4,%xmm0
movss  (%rsi,%r9,4),%xmm3
movaps %xmm3,%xmm11
mulss  %xmm10,%xmm11
addss  %xmm0,%xmm11
lea    0x2(%rdx,%rax,1),%r10d
movss  (%rsi,%r10,4),%xmm2
movaps %xmm2,%xmm13
mulss  %xmm1,%xmm13
addss  %xmm11,%xmm13
lea    0x3(%rdx,%rax,1),%r14d
movss  (%rsi,%r14,4),%xmm11
movaps %xmm11,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm5,%xmm9
addss  %xmm13,%xmm0
movss  %xmm0,-0x74(%rsp)
movaps 0x10(%rsp),%xmm13
mulss  %xmm4,%xmm13
movaps %xmm3,%xmm1
movaps 0x40(%rsp),%xmm5
mulss  %xmm5,%xmm1
addss  %xmm13,%xmm1
movaps %xmm2,%xmm13
mulss  %xmm15,%xmm13
addss  %xmm1,%xmm13
movaps %xmm11,%xmm0
mulss  (%rsp),%xmm0
addss  %xmm13,%xmm0
movss  %xmm0,-0x78(%rsp)
movaps -0x10(%rsp),%xmm13
mulss  %xmm4,%xmm13
movaps %xmm3,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm13,%xmm1
movaps %xmm2,%xmm0
mulss  %xmm12,%xmm0
addss  %xmm1,%xmm0
movaps %xmm11,%xmm13
mulss  -0x20(%rsp),%xmm13
addss  %xmm0,%xmm13
mulss  -0x30(%rsp),%xmm4
mulss  %xmm7,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm8,%xmm11
addss  %xmm2,%xmm11
lea    (%r11,%rax,1),%r15d
lea    0x1(%r11,%rax,1),%edx
movss  (%rsi,%rdx,4),%xmm0
movaps 0x30(%rsp),%xmm2
mulss  %xmm0,%xmm2
movss  (%rsi,%r15,4),%xmm1
mulss  %xmm1,%xmm10
addss  %xmm2,%xmm10
lea    0x2(%r11,%rax,1),%r12d
movss  (%rsi,%r12,4),%xmm2
movaps 0x20(%rsp),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm10,%xmm3
movaps %xmm3,%xmm4
lea    0x3(%r11,%rax,1),%r13d
movss  (%rsi,%r13,4),%xmm10
movaps %xmm9,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm4,%xmm3
movaps 0x10(%rsp),%xmm4
mulss  %xmm0,%xmm4
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm15
addss  %xmm5,%xmm15
movaps (%rsp),%xmm4
mulss  %xmm10,%xmm4
addss  %xmm15,%xmm4
movaps -0x10(%rsp),%xmm5
mulss  %xmm0,%xmm5
mulss  %xmm1,%xmm14
addss  %xmm5,%xmm14
mulss  %xmm2,%xmm12
addss  %xmm14,%xmm12
movaps -0x20(%rsp),%xmm5
mulss  %xmm10,%xmm5
addss  %xmm12,%xmm5
movaps -0x30(%rsp),%xmm9
mulss  %xmm0,%xmm9
mulss  %xmm1,%xmm7
addss  %xmm9,%xmm7
mulss  %xmm2,%xmm6
addss  %xmm7,%xmm6
mulss  %xmm10,%xmm8
addss  %xmm6,%xmm8
mov    -0x38(%rsp),%rbx
movaps 0x50(%rsp),%xmm0
movups %xmm0,(%rdi,%rbx,4)
mov    -0x40(%rsp),%rbx
movss  -0x64(%rsp),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
mov    -0x48(%rsp),%rbx
movss  -0x68(%rsp),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
mov    -0x50(%rsp),%rbx
movss  -0x6c(%rsp),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
mov    -0x58(%rsp),%rbx
movss  -0x70(%rsp),%xmm0
movss  %xmm0,(%rdi,%rbx,4)
movss  -0x74(%rsp),%xmm0
movss  %xmm0,(%rdi,%r9,4)
movss  -0x78(%rsp),%xmm0
movss  %xmm0,(%rdi,%rbp,4)
movss  %xmm13,(%rdi,%r10,4)
movss  %xmm11,(%rdi,%r14,4)
movss  %xmm3,(%rdi,%r15,4)
movss  %xmm4,(%rdi,%rdx,4)
mov    -0x7c(%rsp),%edx
movss  %xmm5,(%rdi,%r12,4)
movss  %xmm8,(%rdi,%r13,4)
add    -0x80(%rsp),%eax
cmp    %edx,%eax
jb     1140 <u3d_utilsBatchMatrixMultiplication+0x40>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @u3d_utilsBatchMatrixMultiplication(float* %0, float* %1, i32 %2, float* %3, i32 %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca [16 x float]
%29 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store i32 %2, i32* %8
store float* %3, float** %9
store i32 %4, i32* %10
%30 = load i32, i32* %10
%31 = mul i32 %30, 4
store i32 %31, i32* %11
store i32 0, i32* %29
br label %32
32: ; preds = %805, %5
%33 = load i32, i32* %29
%34 = load i32, i32* %8
%35 = icmp ult i32 %33, %34
br i1 %35, label %36, label %809
36: ; preds = %32
%37 = load i32, i32* %29
%38 = load i32, i32* %10
%39 = mul i32 0, %38
%40 = add i32 %37, %39
%41 = add i32 %40, 0
store i32 %41, i32* %12
%42 = load i32, i32* %29
%43 = load i32, i32* %10
%44 = mul i32 0, %43
%45 = add i32 %42, %44
%46 = add i32 %45, 1
store i32 %46, i32* %13
%47 = load i32, i32* %29
%48 = load i32, i32* %10
%49 = mul i32 0, %48
%50 = add i32 %47, %49
%51 = add i32 %50, 2
store i32 %51, i32* %14
%52 = load i32, i32* %29
%53 = load i32, i32* %10
%54 = mul i32 0, %53
%55 = add i32 %52, %54
%56 = add i32 %55, 3
store i32 %56, i32* %15
%57 = load i32, i32* %29
%58 = load i32, i32* %10
%59 = mul i32 1, %58
%60 = add i32 %57, %59
%61 = add i32 %60, 0
store i32 %61, i32* %16
%62 = load i32, i32* %29
%63 = load i32, i32* %10
%64 = mul i32 1, %63
%65 = add i32 %62, %64
%66 = add i32 %65, 1
store i32 %66, i32* %17
%67 = load i32, i32* %29
%68 = load i32, i32* %10
%69 = mul i32 1, %68
%70 = add i32 %67, %69
%71 = add i32 %70, 2
store i32 %71, i32* %18
%72 = load i32, i32* %29
%73 = load i32, i32* %10
%74 = mul i32 1, %73
%75 = add i32 %72, %74
%76 = add i32 %75, 3
store i32 %76, i32* %19
%77 = load i32, i32* %29
%78 = load i32, i32* %10
%79 = mul i32 2, %78
%80 = add i32 %77, %79
%81 = add i32 %80, 0
store i32 %81, i32* %20
%82 = load i32, i32* %29
%83 = load i32, i32* %10
%84 = mul i32 2, %83
%85 = add i32 %82, %84
%86 = add i32 %85, 1
store i32 %86, i32* %21
%87 = load i32, i32* %29
%88 = load i32, i32* %10
%89 = mul i32 2, %88
%90 = add i32 %87, %89
%91 = add i32 %90, 2
store i32 %91, i32* %22
%92 = load i32, i32* %29
%93 = load i32, i32* %10
%94 = mul i32 2, %93
%95 = add i32 %92, %94
%96 = add i32 %95, 3
store i32 %96, i32* %23
%97 = load i32, i32* %29
%98 = load i32, i32* %10
%99 = mul i32 3, %98
%100 = add i32 %97, %99
%101 = add i32 %100, 0
store i32 %101, i32* %24
%102 = load i32, i32* %29
%103 = load i32, i32* %10
%104 = mul i32 3, %103
%105 = add i32 %102, %104
%106 = add i32 %105, 1
store i32 %106, i32* %25
%107 = load i32, i32* %29
%108 = load i32, i32* %10
%109 = mul i32 3, %108
%110 = add i32 %107, %109
%111 = add i32 %110, 2
store i32 %111, i32* %26
%112 = load i32, i32* %29
%113 = load i32, i32* %10
%114 = mul i32 3, %113
%115 = add i32 %112, %114
%116 = add i32 %115, 3
store i32 %116, i32* %27
%117 = load float*, float** %7
%118 = load i32, i32* %12
%119 = zext i32 %118 to i64
%120 = getelementptr inbounds float, float* %117, i64 %119
%121 = load float, float* %120
%122 = load float*, float** %9
%123 = getelementptr inbounds float, float* %122, i64 0
%124 = load float, float* %123
%125 = load float*, float** %7
%126 = load i32, i32* %13
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
%129 = load float, float* %128
%130 = load float*, float** %9
%131 = getelementptr inbounds float, float* %130, i64 4
%132 = load float, float* %131
%133 = fmul float %129, %132
%134 = call float @llvm.fmuladd.f32(float %121, float %124, float %133)
%135 = load float*, float** %7
%136 = load i32, i32* %14
%137 = zext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
%140 = load float*, float** %9
%141 = getelementptr inbounds float, float* %140, i64 8
%142 = load float, float* %141
%143 = call float @llvm.fmuladd.f32(float %139, float %142, float %134)
%144 = load float*, float** %7
%145 = load i32, i32* %15
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %9
%150 = getelementptr inbounds float, float* %149, i64 12
%151 = load float, float* %150
%152 = call float @llvm.fmuladd.f32(float %148, float %151, float %143)
%153 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 0
store float %152, float* %153
%154 = load float*, float** %7
%155 = load i32, i32* %12
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds float, float* %154, i64 %156
%158 = load float, float* %157
%159 = load float*, float** %9
%160 = getelementptr inbounds float, float* %159, i64 1
%161 = load float, float* %160
%162 = load float*, float** %7
%163 = load i32, i32* %13
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
%166 = load float, float* %165
%167 = load float*, float** %9
%168 = getelementptr inbounds float, float* %167, i64 5
%169 = load float, float* %168
%170 = fmul float %166, %169
%171 = call float @llvm.fmuladd.f32(float %158, float %161, float %170)
%172 = load float*, float** %7
%173 = load i32, i32* %14
%174 = zext i32 %173 to i64
%175 = getelementptr inbounds float, float* %172, i64 %174
%176 = load float, float* %175
%177 = load float*, float** %9
%178 = getelementptr inbounds float, float* %177, i64 9
%179 = load float, float* %178
%180 = call float @llvm.fmuladd.f32(float %176, float %179, float %171)
%181 = load float*, float** %7
%182 = load i32, i32* %15
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds float, float* %181, i64 %183
%185 = load float, float* %184
%186 = load float*, float** %9
%187 = getelementptr inbounds float, float* %186, i64 13
%188 = load float, float* %187
%189 = call float @llvm.fmuladd.f32(float %185, float %188, float %180)
%190 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 1
store float %189, float* %190
%191 = load float*, float** %7
%192 = load i32, i32* %12
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds float, float* %191, i64 %193
%195 = load float, float* %194
%196 = load float*, float** %9
%197 = getelementptr inbounds float, float* %196, i64 2
%198 = load float, float* %197
%199 = load float*, float** %7
%200 = load i32, i32* %13
%201 = zext i32 %200 to i64
%202 = getelementptr inbounds float, float* %199, i64 %201
%203 = load float, float* %202
%204 = load float*, float** %9
%205 = getelementptr inbounds float, float* %204, i64 6
%206 = load float, float* %205
%207 = fmul float %203, %206
%208 = call float @llvm.fmuladd.f32(float %195, float %198, float %207)
%209 = load float*, float** %7
%210 = load i32, i32* %14
%211 = zext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
%214 = load float*, float** %9
%215 = getelementptr inbounds float, float* %214, i64 10
%216 = load float, float* %215
%217 = call float @llvm.fmuladd.f32(float %213, float %216, float %208)
%218 = load float*, float** %7
%219 = load i32, i32* %15
%220 = zext i32 %219 to i64
%221 = getelementptr inbounds float, float* %218, i64 %220
%222 = load float, float* %221
%223 = load float*, float** %9
%224 = getelementptr inbounds float, float* %223, i64 14
%225 = load float, float* %224
%226 = call float @llvm.fmuladd.f32(float %222, float %225, float %217)
%227 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 2
store float %226, float* %227
%228 = load float*, float** %7
%229 = load i32, i32* %12
%230 = zext i32 %229 to i64
%231 = getelementptr inbounds float, float* %228, i64 %230
%232 = load float, float* %231
%233 = load float*, float** %9
%234 = getelementptr inbounds float, float* %233, i64 3
%235 = load float, float* %234
%236 = load float*, float** %7
%237 = load i32, i32* %13
%238 = zext i32 %237 to i64
%239 = getelementptr inbounds float, float* %236, i64 %238
%240 = load float, float* %239
%241 = load float*, float** %9
%242 = getelementptr inbounds float, float* %241, i64 7
%243 = load float, float* %242
%244 = fmul float %240, %243
%245 = call float @llvm.fmuladd.f32(float %232, float %235, float %244)
%246 = load float*, float** %7
%247 = load i32, i32* %14
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds float, float* %246, i64 %248
%250 = load float, float* %249
%251 = load float*, float** %9
%252 = getelementptr inbounds float, float* %251, i64 11
%253 = load float, float* %252
%254 = call float @llvm.fmuladd.f32(float %250, float %253, float %245)
%255 = load float*, float** %7
%256 = load i32, i32* %15
%257 = zext i32 %256 to i64
%258 = getelementptr inbounds float, float* %255, i64 %257
%259 = load float, float* %258
%260 = load float*, float** %9
%261 = getelementptr inbounds float, float* %260, i64 15
%262 = load float, float* %261
%263 = call float @llvm.fmuladd.f32(float %259, float %262, float %254)
%264 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 3
store float %263, float* %264
%265 = load float*, float** %7
%266 = load i32, i32* %16
%267 = zext i32 %266 to i64
%268 = getelementptr inbounds float, float* %265, i64 %267
%269 = load float, float* %268
%270 = load float*, float** %9
%271 = getelementptr inbounds float, float* %270, i64 0
%272 = load float, float* %271
%273 = load float*, float** %7
%274 = load i32, i32* %17
%275 = zext i32 %274 to i64
%276 = getelementptr inbounds float, float* %273, i64 %275
%277 = load float, float* %276
%278 = load float*, float** %9
%279 = getelementptr inbounds float, float* %278, i64 4
%280 = load float, float* %279
%281 = fmul float %277, %280
%282 = call float @llvm.fmuladd.f32(float %269, float %272, float %281)
%283 = load float*, float** %7
%284 = load i32, i32* %18
%285 = zext i32 %284 to i64
%286 = getelementptr inbounds float, float* %283, i64 %285
%287 = load float, float* %286
%288 = load float*, float** %9
%289 = getelementptr inbounds float, float* %288, i64 8
%290 = load float, float* %289
%291 = call float @llvm.fmuladd.f32(float %287, float %290, float %282)
%292 = load float*, float** %7
%293 = load i32, i32* %19
%294 = zext i32 %293 to i64
%295 = getelementptr inbounds float, float* %292, i64 %294
%296 = load float, float* %295
%297 = load float*, float** %9
%298 = getelementptr inbounds float, float* %297, i64 12
%299 = load float, float* %298
%300 = call float @llvm.fmuladd.f32(float %296, float %299, float %291)
%301 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 4
store float %300, float* %301
%302 = load float*, float** %7
%303 = load i32, i32* %16
%304 = zext i32 %303 to i64
%305 = getelementptr inbounds float, float* %302, i64 %304
%306 = load float, float* %305
%307 = load float*, float** %9
%308 = getelementptr inbounds float, float* %307, i64 1
%309 = load float, float* %308
%310 = load float*, float** %7
%311 = load i32, i32* %17
%312 = zext i32 %311 to i64
%313 = getelementptr inbounds float, float* %310, i64 %312
%314 = load float, float* %313
%315 = load float*, float** %9
%316 = getelementptr inbounds float, float* %315, i64 5
%317 = load float, float* %316
%318 = fmul float %314, %317
%319 = call float @llvm.fmuladd.f32(float %306, float %309, float %318)
%320 = load float*, float** %7
%321 = load i32, i32* %18
%322 = zext i32 %321 to i64
%323 = getelementptr inbounds float, float* %320, i64 %322
%324 = load float, float* %323
%325 = load float*, float** %9
%326 = getelementptr inbounds float, float* %325, i64 9
%327 = load float, float* %326
%328 = call float @llvm.fmuladd.f32(float %324, float %327, float %319)
%329 = load float*, float** %7
%330 = load i32, i32* %19
%331 = zext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
%333 = load float, float* %332
%334 = load float*, float** %9
%335 = getelementptr inbounds float, float* %334, i64 13
%336 = load float, float* %335
%337 = call float @llvm.fmuladd.f32(float %333, float %336, float %328)
%338 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 5
store float %337, float* %338
%339 = load float*, float** %7
%340 = load i32, i32* %16
%341 = zext i32 %340 to i64
%342 = getelementptr inbounds float, float* %339, i64 %341
%343 = load float, float* %342
%344 = load float*, float** %9
%345 = getelementptr inbounds float, float* %344, i64 2
%346 = load float, float* %345
%347 = load float*, float** %7
%348 = load i32, i32* %17
%349 = zext i32 %348 to i64
%350 = getelementptr inbounds float, float* %347, i64 %349
%351 = load float, float* %350
%352 = load float*, float** %9
%353 = getelementptr inbounds float, float* %352, i64 6
%354 = load float, float* %353
%355 = fmul float %351, %354
%356 = call float @llvm.fmuladd.f32(float %343, float %346, float %355)
%357 = load float*, float** %7
%358 = load i32, i32* %18
%359 = zext i32 %358 to i64
%360 = getelementptr inbounds float, float* %357, i64 %359
%361 = load float, float* %360
%362 = load float*, float** %9
%363 = getelementptr inbounds float, float* %362, i64 10
%364 = load float, float* %363
%365 = call float @llvm.fmuladd.f32(float %361, float %364, float %356)
%366 = load float*, float** %7
%367 = load i32, i32* %19
%368 = zext i32 %367 to i64
%369 = getelementptr inbounds float, float* %366, i64 %368
%370 = load float, float* %369
%371 = load float*, float** %9
%372 = getelementptr inbounds float, float* %371, i64 14
%373 = load float, float* %372
%374 = call float @llvm.fmuladd.f32(float %370, float %373, float %365)
%375 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 6
store float %374, float* %375
%376 = load float*, float** %7
%377 = load i32, i32* %16
%378 = zext i32 %377 to i64
%379 = getelementptr inbounds float, float* %376, i64 %378
%380 = load float, float* %379
%381 = load float*, float** %9
%382 = getelementptr inbounds float, float* %381, i64 3
%383 = load float, float* %382
%384 = load float*, float** %7
%385 = load i32, i32* %17
%386 = zext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
%388 = load float, float* %387
%389 = load float*, float** %9
%390 = getelementptr inbounds float, float* %389, i64 7
%391 = load float, float* %390
%392 = fmul float %388, %391
%393 = call float @llvm.fmuladd.f32(float %380, float %383, float %392)
%394 = load float*, float** %7
%395 = load i32, i32* %18
%396 = zext i32 %395 to i64
%397 = getelementptr inbounds float, float* %394, i64 %396
%398 = load float, float* %397
%399 = load float*, float** %9
%400 = getelementptr inbounds float, float* %399, i64 11
%401 = load float, float* %400
%402 = call float @llvm.fmuladd.f32(float %398, float %401, float %393)
%403 = load float*, float** %7
%404 = load i32, i32* %19
%405 = zext i32 %404 to i64
%406 = getelementptr inbounds float, float* %403, i64 %405
%407 = load float, float* %406
%408 = load float*, float** %9
%409 = getelementptr inbounds float, float* %408, i64 15
%410 = load float, float* %409
%411 = call float @llvm.fmuladd.f32(float %407, float %410, float %402)
%412 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 7
store float %411, float* %412
%413 = load float*, float** %7
%414 = load i32, i32* %20
%415 = zext i32 %414 to i64
%416 = getelementptr inbounds float, float* %413, i64 %415
%417 = load float, float* %416
%418 = load float*, float** %9
%419 = getelementptr inbounds float, float* %418, i64 0
%420 = load float, float* %419
%421 = load float*, float** %7
%422 = load i32, i32* %21
%423 = zext i32 %422 to i64
%424 = getelementptr inbounds float, float* %421, i64 %423
%425 = load float, float* %424
%426 = load float*, float** %9
%427 = getelementptr inbounds float, float* %426, i64 4
%428 = load float, float* %427
%429 = fmul float %425, %428
%430 = call float @llvm.fmuladd.f32(float %417, float %420, float %429)
%431 = load float*, float** %7
%432 = load i32, i32* %22
%433 = zext i32 %432 to i64
%434 = getelementptr inbounds float, float* %431, i64 %433
%435 = load float, float* %434
%436 = load float*, float** %9
%437 = getelementptr inbounds float, float* %436, i64 8
%438 = load float, float* %437
%439 = call float @llvm.fmuladd.f32(float %435, float %438, float %430)
%440 = load float*, float** %7
%441 = load i32, i32* %23
%442 = zext i32 %441 to i64
%443 = getelementptr inbounds float, float* %440, i64 %442
%444 = load float, float* %443
%445 = load float*, float** %9
%446 = getelementptr inbounds float, float* %445, i64 12
%447 = load float, float* %446
%448 = call float @llvm.fmuladd.f32(float %444, float %447, float %439)
%449 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 8
store float %448, float* %449
%450 = load float*, float** %7
%451 = load i32, i32* %20
%452 = zext i32 %451 to i64
%453 = getelementptr inbounds float, float* %450, i64 %452
%454 = load float, float* %453
%455 = load float*, float** %9
%456 = getelementptr inbounds float, float* %455, i64 1
%457 = load float, float* %456
%458 = load float*, float** %7
%459 = load i32, i32* %21
%460 = zext i32 %459 to i64
%461 = getelementptr inbounds float, float* %458, i64 %460
%462 = load float, float* %461
%463 = load float*, float** %9
%464 = getelementptr inbounds float, float* %463, i64 5
%465 = load float, float* %464
%466 = fmul float %462, %465
%467 = call float @llvm.fmuladd.f32(float %454, float %457, float %466)
%468 = load float*, float** %7
%469 = load i32, i32* %22
%470 = zext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
%472 = load float, float* %471
%473 = load float*, float** %9
%474 = getelementptr inbounds float, float* %473, i64 9
%475 = load float, float* %474
%476 = call float @llvm.fmuladd.f32(float %472, float %475, float %467)
%477 = load float*, float** %7
%478 = load i32, i32* %23
%479 = zext i32 %478 to i64
%480 = getelementptr inbounds float, float* %477, i64 %479
%481 = load float, float* %480
%482 = load float*, float** %9
%483 = getelementptr inbounds float, float* %482, i64 13
%484 = load float, float* %483
%485 = call float @llvm.fmuladd.f32(float %481, float %484, float %476)
%486 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 9
store float %485, float* %486
%487 = load float*, float** %7
%488 = load i32, i32* %20
%489 = zext i32 %488 to i64
%490 = getelementptr inbounds float, float* %487, i64 %489
%491 = load float, float* %490
%492 = load float*, float** %9
%493 = getelementptr inbounds float, float* %492, i64 2
%494 = load float, float* %493
%495 = load float*, float** %7
%496 = load i32, i32* %21
%497 = zext i32 %496 to i64
%498 = getelementptr inbounds float, float* %495, i64 %497
%499 = load float, float* %498
%500 = load float*, float** %9
%501 = getelementptr inbounds float, float* %500, i64 6
%502 = load float, float* %501
%503 = fmul float %499, %502
%504 = call float @llvm.fmuladd.f32(float %491, float %494, float %503)
%505 = load float*, float** %7
%506 = load i32, i32* %22
%507 = zext i32 %506 to i64
%508 = getelementptr inbounds float, float* %505, i64 %507
%509 = load float, float* %508
%510 = load float*, float** %9
%511 = getelementptr inbounds float, float* %510, i64 10
%512 = load float, float* %511
%513 = call float @llvm.fmuladd.f32(float %509, float %512, float %504)
%514 = load float*, float** %7
%515 = load i32, i32* %23
%516 = zext i32 %515 to i64
%517 = getelementptr inbounds float, float* %514, i64 %516
%518 = load float, float* %517
%519 = load float*, float** %9
%520 = getelementptr inbounds float, float* %519, i64 14
%521 = load float, float* %520
%522 = call float @llvm.fmuladd.f32(float %518, float %521, float %513)
%523 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 10
store float %522, float* %523
%524 = load float*, float** %7
%525 = load i32, i32* %20
%526 = zext i32 %525 to i64
%527 = getelementptr inbounds float, float* %524, i64 %526
%528 = load float, float* %527
%529 = load float*, float** %9
%530 = getelementptr inbounds float, float* %529, i64 3
%531 = load float, float* %530
%532 = load float*, float** %7
%533 = load i32, i32* %21
%534 = zext i32 %533 to i64
%535 = getelementptr inbounds float, float* %532, i64 %534
%536 = load float, float* %535
%537 = load float*, float** %9
%538 = getelementptr inbounds float, float* %537, i64 7
%539 = load float, float* %538
%540 = fmul float %536, %539
%541 = call float @llvm.fmuladd.f32(float %528, float %531, float %540)
%542 = load float*, float** %7
%543 = load i32, i32* %22
%544 = zext i32 %543 to i64
%545 = getelementptr inbounds float, float* %542, i64 %544
%546 = load float, float* %545
%547 = load float*, float** %9
%548 = getelementptr inbounds float, float* %547, i64 11
%549 = load float, float* %548
%550 = call float @llvm.fmuladd.f32(float %546, float %549, float %541)
%551 = load float*, float** %7
%552 = load i32, i32* %23
%553 = zext i32 %552 to i64
%554 = getelementptr inbounds float, float* %551, i64 %553
%555 = load float, float* %554
%556 = load float*, float** %9
%557 = getelementptr inbounds float, float* %556, i64 15
%558 = load float, float* %557
%559 = call float @llvm.fmuladd.f32(float %555, float %558, float %550)
%560 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 11
store float %559, float* %560
%561 = load float*, float** %7
%562 = load i32, i32* %24
%563 = zext i32 %562 to i64
%564 = getelementptr inbounds float, float* %561, i64 %563
%565 = load float, float* %564
%566 = load float*, float** %9
%567 = getelementptr inbounds float, float* %566, i64 0
%568 = load float, float* %567
%569 = load float*, float** %7
%570 = load i32, i32* %25
%571 = zext i32 %570 to i64
%572 = getelementptr inbounds float, float* %569, i64 %571
%573 = load float, float* %572
%574 = load float*, float** %9
%575 = getelementptr inbounds float, float* %574, i64 4
%576 = load float, float* %575
%577 = fmul float %573, %576
%578 = call float @llvm.fmuladd.f32(float %565, float %568, float %577)
%579 = load float*, float** %7
%580 = load i32, i32* %26
%581 = zext i32 %580 to i64
%582 = getelementptr inbounds float, float* %579, i64 %581
%583 = load float, float* %582
%584 = load float*, float** %9
%585 = getelementptr inbounds float, float* %584, i64 8
%586 = load float, float* %585
%587 = call float @llvm.fmuladd.f32(float %583, float %586, float %578)
%588 = load float*, float** %7
%589 = load i32, i32* %27
%590 = zext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
%593 = load float*, float** %9
%594 = getelementptr inbounds float, float* %593, i64 12
%595 = load float, float* %594
%596 = call float @llvm.fmuladd.f32(float %592, float %595, float %587)
%597 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 12
store float %596, float* %597
%598 = load float*, float** %7
%599 = load i32, i32* %24
%600 = zext i32 %599 to i64
%601 = getelementptr inbounds float, float* %598, i64 %600
%602 = load float, float* %601
%603 = load float*, float** %9
%604 = getelementptr inbounds float, float* %603, i64 1
%605 = load float, float* %604
%606 = load float*, float** %7
%607 = load i32, i32* %25
%608 = zext i32 %607 to i64
%609 = getelementptr inbounds float, float* %606, i64 %608
%610 = load float, float* %609
%611 = load float*, float** %9
%612 = getelementptr inbounds float, float* %611, i64 5
%613 = load float, float* %612
%614 = fmul float %610, %613
%615 = call float @llvm.fmuladd.f32(float %602, float %605, float %614)
%616 = load float*, float** %7
%617 = load i32, i32* %26
%618 = zext i32 %617 to i64
%619 = getelementptr inbounds float, float* %616, i64 %618
%620 = load float, float* %619
%621 = load float*, float** %9
%622 = getelementptr inbounds float, float* %621, i64 9
%623 = load float, float* %622
%624 = call float @llvm.fmuladd.f32(float %620, float %623, float %615)
%625 = load float*, float** %7
%626 = load i32, i32* %27
%627 = zext i32 %626 to i64
%628 = getelementptr inbounds float, float* %625, i64 %627
%629 = load float, float* %628
%630 = load float*, float** %9
%631 = getelementptr inbounds float, float* %630, i64 13
%632 = load float, float* %631
%633 = call float @llvm.fmuladd.f32(float %629, float %632, float %624)
%634 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 13
store float %633, float* %634
%635 = load float*, float** %7
%636 = load i32, i32* %24
%637 = zext i32 %636 to i64
%638 = getelementptr inbounds float, float* %635, i64 %637
%639 = load float, float* %638
%640 = load float*, float** %9
%641 = getelementptr inbounds float, float* %640, i64 2
%642 = load float, float* %641
%643 = load float*, float** %7
%644 = load i32, i32* %25
%645 = zext i32 %644 to i64
%646 = getelementptr inbounds float, float* %643, i64 %645
%647 = load float, float* %646
%648 = load float*, float** %9
%649 = getelementptr inbounds float, float* %648, i64 6
%650 = load float, float* %649
%651 = fmul float %647, %650
%652 = call float @llvm.fmuladd.f32(float %639, float %642, float %651)
%653 = load float*, float** %7
%654 = load i32, i32* %26
%655 = zext i32 %654 to i64
%656 = getelementptr inbounds float, float* %653, i64 %655
%657 = load float, float* %656
%658 = load float*, float** %9
%659 = getelementptr inbounds float, float* %658, i64 10
%660 = load float, float* %659
%661 = call float @llvm.fmuladd.f32(float %657, float %660, float %652)
%662 = load float*, float** %7
%663 = load i32, i32* %27
%664 = zext i32 %663 to i64
%665 = getelementptr inbounds float, float* %662, i64 %664
%666 = load float, float* %665
%667 = load float*, float** %9
%668 = getelementptr inbounds float, float* %667, i64 14
%669 = load float, float* %668
%670 = call float @llvm.fmuladd.f32(float %666, float %669, float %661)
%671 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 14
store float %670, float* %671
%672 = load float*, float** %7
%673 = load i32, i32* %24
%674 = zext i32 %673 to i64
%675 = getelementptr inbounds float, float* %672, i64 %674
%676 = load float, float* %675
%677 = load float*, float** %9
%678 = getelementptr inbounds float, float* %677, i64 3
%679 = load float, float* %678
%680 = load float*, float** %7
%681 = load i32, i32* %25
%682 = zext i32 %681 to i64
%683 = getelementptr inbounds float, float* %680, i64 %682
%684 = load float, float* %683
%685 = load float*, float** %9
%686 = getelementptr inbounds float, float* %685, i64 7
%687 = load float, float* %686
%688 = fmul float %684, %687
%689 = call float @llvm.fmuladd.f32(float %676, float %679, float %688)
%690 = load float*, float** %7
%691 = load i32, i32* %26
%692 = zext i32 %691 to i64
%693 = getelementptr inbounds float, float* %690, i64 %692
%694 = load float, float* %693
%695 = load float*, float** %9
%696 = getelementptr inbounds float, float* %695, i64 11
%697 = load float, float* %696
%698 = call float @llvm.fmuladd.f32(float %694, float %697, float %689)
%699 = load float*, float** %7
%700 = load i32, i32* %27
%701 = zext i32 %700 to i64
%702 = getelementptr inbounds float, float* %699, i64 %701
%703 = load float, float* %702
%704 = load float*, float** %9
%705 = getelementptr inbounds float, float* %704, i64 15
%706 = load float, float* %705
%707 = call float @llvm.fmuladd.f32(float %703, float %706, float %698)
%708 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 15
store float %707, float* %708
%709 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 0
%710 = load float, float* %709
%711 = load float*, float** %6
%712 = load i32, i32* %12
%713 = zext i32 %712 to i64
%714 = getelementptr inbounds float, float* %711, i64 %713
store float %710, float* %714
%715 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 1
%716 = load float, float* %715
%717 = load float*, float** %6
%718 = load i32, i32* %13
%719 = zext i32 %718 to i64
%720 = getelementptr inbounds float, float* %717, i64 %719
store float %716, float* %720
%721 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 2
%722 = load float, float* %721
%723 = load float*, float** %6
%724 = load i32, i32* %14
%725 = zext i32 %724 to i64
%726 = getelementptr inbounds float, float* %723, i64 %725
store float %722, float* %726
%727 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 3
%728 = load float, float* %727
%729 = load float*, float** %6
%730 = load i32, i32* %15
%731 = zext i32 %730 to i64
%732 = getelementptr inbounds float, float* %729, i64 %731
store float %728, float* %732
%733 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 4
%734 = load float, float* %733
%735 = load float*, float** %6
%736 = load i32, i32* %16
%737 = zext i32 %736 to i64
%738 = getelementptr inbounds float, float* %735, i64 %737
store float %734, float* %738
%739 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 5
%740 = load float, float* %739
%741 = load float*, float** %6
%742 = load i32, i32* %17
%743 = zext i32 %742 to i64
%744 = getelementptr inbounds float, float* %741, i64 %743
store float %740, float* %744
%745 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 6
%746 = load float, float* %745
%747 = load float*, float** %6
%748 = load i32, i32* %18
%749 = zext i32 %748 to i64
%750 = getelementptr inbounds float, float* %747, i64 %749
store float %746, float* %750
%751 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 7
%752 = load float, float* %751
%753 = load float*, float** %6
%754 = load i32, i32* %19
%755 = zext i32 %754 to i64
%756 = getelementptr inbounds float, float* %753, i64 %755
store float %752, float* %756
%757 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 8
%758 = load float, float* %757
%759 = load float*, float** %6
%760 = load i32, i32* %20
%761 = zext i32 %760 to i64
%762 = getelementptr inbounds float, float* %759, i64 %761
store float %758, float* %762
%763 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 9
%764 = load float, float* %763
%765 = load float*, float** %6
%766 = load i32, i32* %21
%767 = zext i32 %766 to i64
%768 = getelementptr inbounds float, float* %765, i64 %767
store float %764, float* %768
%769 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 10
%770 = load float, float* %769
%771 = load float*, float** %6
%772 = load i32, i32* %22
%773 = zext i32 %772 to i64
%774 = getelementptr inbounds float, float* %771, i64 %773
store float %770, float* %774
%775 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 11
%776 = load float, float* %775
%777 = load float*, float** %6
%778 = load i32, i32* %23
%779 = zext i32 %778 to i64
%780 = getelementptr inbounds float, float* %777, i64 %779
store float %776, float* %780
%781 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 12
%782 = load float, float* %781
%783 = load float*, float** %6
%784 = load i32, i32* %24
%785 = zext i32 %784 to i64
%786 = getelementptr inbounds float, float* %783, i64 %785
store float %782, float* %786
%787 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 13
%788 = load float, float* %787
%789 = load float*, float** %6
%790 = load i32, i32* %25
%791 = zext i32 %790 to i64
%792 = getelementptr inbounds float, float* %789, i64 %791
store float %788, float* %792
%793 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 14
%794 = load float, float* %793
%795 = load float*, float** %6
%796 = load i32, i32* %26
%797 = zext i32 %796 to i64
%798 = getelementptr inbounds float, float* %795, i64 %797
store float %794, float* %798
%799 = getelementptr inbounds [16 x float], [16 x float]* %28, i64 0, i64 15
%800 = load float, float* %799
%801 = load float*, float** %6
%802 = load i32, i32* %27
%803 = zext i32 %802 to i64
%804 = getelementptr inbounds float, float* %801, i64 %803
store float %800, float* %804
br label %805
805: ; preds = %36
%806 = load i32, i32* %11
%807 = load i32, i32* %29
%808 = add i32 %807, %806
store i32 %808, i32* %29
br label %32
809: ; preds = %32
ret void
}

LLVM IR (-O2):
define void @u3d_utilsBatchMatrixMultiplication(float* nocapture writeonly %0, float* nocapture %1, i32 %2, float* nocapture %3, i32 %4) {
%6 = shl i32 %4, 2
%7 = icmp eq i32 %2, 0
br i1 %7, label %179, label %8
8: ; preds = %5
%9 = shl i32 %4, 1
%10 = mul i32 %4, 3
%11 = getelementptr inbounds float, float* %3, i64 4
%12 = getelementptr inbounds float, float* %3, i64 8
%13 = getelementptr inbounds float, float* %3, i64 12
%14 = bitcast float* %3 to <4 x float>*
%15 = bitcast float* %11 to <4 x float>*
%16 = bitcast float* %12 to <4 x float>*
%17 = bitcast float* %13 to <4 x float>*
br label %18
18: ; preds = %8, %18
%19 = phi i32 [ 0, %8 ], [ %177, %18 ]
%20 = or i32 %19, 1
%21 = or i32 %19, 2
%22 = or i32 %19, 3
%23 = add i32 %19, %4
%24 = add i32 %23, 1
%25 = add i32 %23, 2
%26 = add i32 %23, 3
%27 = add i32 %19, %9
%28 = or i32 %27, 1
%29 = add i32 %27, 2
%30 = add i32 %27, 3
%31 = add i32 %19, %10
%32 = add i32 %31, 1
%33 = add i32 %31, 2
%34 = add i32 %31, 3
%35 = zext i32 %19 to i64
%36 = getelementptr inbounds float, float* %1, i64 %35
%37 = load float, float* %36
%38 = zext i32 %20 to i64
%39 = getelementptr inbounds float, float* %1, i64 %38
%40 = load float, float* %39
%41 = zext i32 %21 to i64
%42 = getelementptr inbounds float, float* %1, i64 %41
%43 = load float, float* %42
%44 = zext i32 %22 to i64
%45 = getelementptr inbounds float, float* %1, i64 %44
%46 = load float, float* %45
%47 = load <4 x float>, <4 x float>* %14
%48 = load <4 x float>, <4 x float>* %15
%49 = insertelement <4 x float> poison, float %40, i64 0
%50 = shufflevector <4 x float> %49, <4 x float> poison, <4 x i32> zeroinitializer
%51 = fmul <4 x float> %50, %48
%52 = insertelement <4 x float> poison, float %37, i64 0
%53 = shufflevector <4 x float> %52, <4 x float> poison, <4 x i32> zeroinitializer
%54 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %53, <4 x float> %47, <4 x float> %51)
%55 = load <4 x float>, <4 x float>* %16
%56 = insertelement <4 x float> poison, float %43, i64 0
%57 = shufflevector <4 x float> %56, <4 x float> poison, <4 x i32> zeroinitializer
%58 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %57, <4 x float> %55, <4 x float> %54)
%59 = load <4 x float>, <4 x float>* %17
%60 = insertelement <4 x float> poison, float %46, i64 0
%61 = shufflevector <4 x float> %60, <4 x float> poison, <4 x i32> zeroinitializer
%62 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %61, <4 x float> %59, <4 x float> %58)
%63 = zext i32 %23 to i64
%64 = getelementptr inbounds float, float* %1, i64 %63
%65 = load float, float* %64
%66 = zext i32 %24 to i64
%67 = getelementptr inbounds float, float* %1, i64 %66
%68 = load float, float* %67
%69 = extractelement <4 x float> %48, i64 0
%70 = fmul float %69, %68
%71 = extractelement <4 x float> %47, i64 0
%72 = tail call float @llvm.fmuladd.f32(float %65, float %71, float %70)
%73 = zext i32 %25 to i64
%74 = getelementptr inbounds float, float* %1, i64 %73
%75 = load float, float* %74
%76 = extractelement <4 x float> %55, i64 0
%77 = tail call float @llvm.fmuladd.f32(float %75, float %76, float %72)
%78 = zext i32 %26 to i64
%79 = getelementptr inbounds float, float* %1, i64 %78
%80 = load float, float* %79
%81 = extractelement <4 x float> %59, i64 0
%82 = tail call float @llvm.fmuladd.f32(float %80, float %81, float %77)
%83 = extractelement <4 x float> %48, i64 1
%84 = fmul float %83, %68
%85 = extractelement <4 x float> %47, i64 1
%86 = tail call float @llvm.fmuladd.f32(float %65, float %85, float %84)
%87 = extractelement <4 x float> %55, i64 1
%88 = tail call float @llvm.fmuladd.f32(float %75, float %87, float %86)
%89 = extractelement <4 x float> %59, i64 1
%90 = tail call float @llvm.fmuladd.f32(float %80, float %89, float %88)
%91 = extractelement <4 x float> %48, i64 2
%92 = fmul float %91, %68
%93 = extractelement <4 x float> %47, i64 2
%94 = tail call float @llvm.fmuladd.f32(float %65, float %93, float %92)
%95 = extractelement <4 x float> %55, i64 2
%96 = tail call float @llvm.fmuladd.f32(float %75, float %95, float %94)
%97 = extractelement <4 x float> %59, i64 2
%98 = tail call float @llvm.fmuladd.f32(float %80, float %97, float %96)
%99 = extractelement <4 x float> %48, i64 3
%100 = fmul float %99, %68
%101 = extractelement <4 x float> %47, i64 3
%102 = tail call float @llvm.fmuladd.f32(float %65, float %101, float %100)
%103 = extractelement <4 x float> %55, i64 3
%104 = tail call float @llvm.fmuladd.f32(float %75, float %103, float %102)
%105 = extractelement <4 x float> %59, i64 3
%106 = tail call float @llvm.fmuladd.f32(float %80, float %105, float %104)
%107 = zext i32 %27 to i64
%108 = getelementptr inbounds float, float* %1, i64 %107
%109 = load float, float* %108
%110 = zext i32 %28 to i64
%111 = getelementptr inbounds float, float* %1, i64 %110
%112 = load float, float* %111
%113 = fmul float %69, %112
%114 = tail call float @llvm.fmuladd.f32(float %109, float %71, float %113)
%115 = zext i32 %29 to i64
%116 = getelementptr inbounds float, float* %1, i64 %115
%117 = load float, float* %116
%118 = tail call float @llvm.fmuladd.f32(float %117, float %76, float %114)
%119 = zext i32 %30 to i64
%120 = getelementptr inbounds float, float* %1, i64 %119
%121 = load float, float* %120
%122 = tail call float @llvm.fmuladd.f32(float %121, float %81, float %118)
%123 = fmul float %83, %112
%124 = tail call float @llvm.fmuladd.f32(float %109, float %85, float %123)
%125 = tail call float @llvm.fmuladd.f32(float %117, float %87, float %124)
%126 = tail call float @llvm.fmuladd.f32(float %121, float %89, float %125)
%127 = fmul float %91, %112
%128 = tail call float @llvm.fmuladd.f32(float %109, float %93, float %127)
%129 = tail call float @llvm.fmuladd.f32(float %117, float %95, float %128)
%130 = tail call float @llvm.fmuladd.f32(float %121, float %97, float %129)
%131 = fmul float %99, %112
%132 = tail call float @llvm.fmuladd.f32(float %109, float %101, float %131)
%133 = tail call float @llvm.fmuladd.f32(float %117, float %103, float %132)
%134 = tail call float @llvm.fmuladd.f32(float %121, float %105, float %133)
%135 = zext i32 %31 to i64
%136 = getelementptr inbounds float, float* %1, i64 %135
%137 = load float, float* %136
%138 = zext i32 %32 to i64
%139 = getelementptr inbounds float, float* %1, i64 %138
%140 = load float, float* %139
%141 = fmul float %69, %140
%142 = tail call float @llvm.fmuladd.f32(float %137, float %71, float %141)
%143 = zext i32 %33 to i64
%144 = getelementptr inbounds float, float* %1, i64 %143
%145 = load float, float* %144
%146 = tail call float @llvm.fmuladd.f32(float %145, float %76, float %142)
%147 = zext i32 %34 to i64
%148 = getelementptr inbounds float, float* %1, i64 %147
%149 = load float, float* %148
%150 = tail call float @llvm.fmuladd.f32(float %149, float %81, float %146)
%151 = fmul float %83, %140
%152 = tail call float @llvm.fmuladd.f32(float %137, float %85, float %151)
%153 = tail call float @llvm.fmuladd.f32(float %145, float %87, float %152)
%154 = tail call float @llvm.fmuladd.f32(float %149, float %89, float %153)
%155 = fmul float %91, %140
%156 = tail call float @llvm.fmuladd.f32(float %137, float %93, float %155)
%157 = tail call float @llvm.fmuladd.f32(float %145, float %95, float %156)
%158 = tail call float @llvm.fmuladd.f32(float %149, float %97, float %157)
%159 = fmul float %99, %140
%160 = tail call float @llvm.fmuladd.f32(float %137, float %101, float %159)
%161 = tail call float @llvm.fmuladd.f32(float %145, float %103, float %160)
%162 = tail call float @llvm.fmuladd.f32(float %149, float %105, float %161)
%163 = getelementptr inbounds float, float* %0, i64 %35
%164 = bitcast float* %163 to <4 x float>*
store <4 x float> %62, <4 x float>* %164
%165 = getelementptr inbounds float, float* %0, i64 %63
store float %82, float* %165
%166 = getelementptr inbounds float, float* %0, i64 %66
store float %90, float* %166
%167 = getelementptr inbounds float, float* %0, i64 %73
store float %98, float* %167
%168 = getelementptr inbounds float, float* %0, i64 %78
store float %106, float* %168
%169 = getelementptr inbounds float, float* %0, i64 %107
store float %122, float* %169
%170 = getelementptr inbounds float, float* %0, i64 %110
store float %126, float* %170
%171 = getelementptr inbounds float, float* %0, i64 %115
store float %130, float* %171
%172 = getelementptr inbounds float, float* %0, i64 %119
store float %134, float* %172
%173 = getelementptr inbounds float, float* %0, i64 %135
store float %150, float* %173
%174 = getelementptr inbounds float, float* %0, i64 %138
store float %154, float* %174
%175 = getelementptr inbounds float, float* %0, i64 %143
store float %158, float* %175
%176 = getelementptr inbounds float, float* %0, i64 %147
store float %162, float* %176
%177 = add i32 %19, %6
%178 = icmp ult i32 %177, %2
br i1 %178, label %18, label %179
179: ; preds = %18, %5
ret void
}