#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ t_res;

/* Variables and functions */
int /*<<< orphan*/ memcpy(float *, float *, int);
void Mat4_Mat4_mul(float result[16], const float src1[16],
                   const float src2[16]) {
  float t_res[16];
  t_res[0 * 4 + 0] =
      src1[0 * 4 + 0] * src2[0 * 4 + 0] + src1[1 * 4 + 0] * src2[0 * 4 + 1] +
      src1[2 * 4 + 0] * src2[0 * 4 + 2] + src1[3 * 4 + 0] * src2[0 * 4 + 3];
  t_res[0 * 4 + 1] =
      src1[0 * 4 + 1] * src2[0 * 4 + 0] + src1[1 * 4 + 1] * src2[0 * 4 + 1] +
      src1[2 * 4 + 1] * src2[0 * 4 + 2] + src1[3 * 4 + 1] * src2[0 * 4 + 3];
  t_res[0 * 4 + 2] =
      src1[0 * 4 + 2] * src2[0 * 4 + 0] + src1[1 * 4 + 2] * src2[0 * 4 + 1] +
      src1[2 * 4 + 2] * src2[0 * 4 + 2] + src1[3 * 4 + 2] * src2[0 * 4 + 3];
  t_res[0 * 4 + 3] =
      src1[0 * 4 + 3] * src2[0 * 4 + 0] + src1[1 * 4 + 3] * src2[0 * 4 + 1] +
      src1[2 * 4 + 3] * src2[0 * 4 + 2] + src1[3 * 4 + 3] * src2[0 * 4 + 3];
  t_res[1 * 4 + 0] =
      src1[0 * 4 + 0] * src2[1 * 4 + 0] + src1[1 * 4 + 0] * src2[1 * 4 + 1] +
      src1[2 * 4 + 0] * src2[1 * 4 + 2] + src1[3 * 4 + 0] * src2[1 * 4 + 3];
  t_res[1 * 4 + 1] =
      src1[0 * 4 + 1] * src2[1 * 4 + 0] + src1[1 * 4 + 1] * src2[1 * 4 + 1] +
      src1[2 * 4 + 1] * src2[1 * 4 + 2] + src1[3 * 4 + 1] * src2[1 * 4 + 3];
  t_res[1 * 4 + 2] =
      src1[0 * 4 + 2] * src2[1 * 4 + 0] + src1[1 * 4 + 2] * src2[1 * 4 + 1] +
      src1[2 * 4 + 2] * src2[1 * 4 + 2] + src1[3 * 4 + 2] * src2[1 * 4 + 3];
  t_res[1 * 4 + 3] =
      src1[0 * 4 + 3] * src2[1 * 4 + 0] + src1[1 * 4 + 3] * src2[1 * 4 + 1] +
      src1[2 * 4 + 3] * src2[1 * 4 + 2] + src1[3 * 4 + 3] * src2[1 * 4 + 3];
  t_res[2 * 4 + 0] =
      src1[0 * 4 + 0] * src2[2 * 4 + 0] + src1[1 * 4 + 0] * src2[2 * 4 + 1] +
      src1[2 * 4 + 0] * src2[2 * 4 + 2] + src1[3 * 4 + 0] * src2[2 * 4 + 3];
  t_res[2 * 4 + 1] =
      src1[0 * 4 + 1] * src2[2 * 4 + 0] + src1[1 * 4 + 1] * src2[2 * 4 + 1] +
      src1[2 * 4 + 1] * src2[2 * 4 + 2] + src1[3 * 4 + 1] * src2[2 * 4 + 3];
  t_res[2 * 4 + 2] =
      src1[0 * 4 + 2] * src2[2 * 4 + 0] + src1[1 * 4 + 2] * src2[2 * 4 + 1] +
      src1[2 * 4 + 2] * src2[2 * 4 + 2] + src1[3 * 4 + 2] * src2[2 * 4 + 3];
  t_res[2 * 4 + 3] =
      src1[0 * 4 + 3] * src2[2 * 4 + 0] + src1[1 * 4 + 3] * src2[2 * 4 + 1] +
      src1[2 * 4 + 3] * src2[2 * 4 + 2] + src1[3 * 4 + 3] * src2[2 * 4 + 3];
  t_res[3 * 4 + 0] =
      src1[0 * 4 + 0] * src2[3 * 4 + 0] + src1[1 * 4 + 0] * src2[3 * 4 + 1] +
      src1[2 * 4 + 0] * src2[3 * 4 + 2] + src1[3 * 4 + 0] * src2[3 * 4 + 3];
  t_res[3 * 4 + 1] =
      src1[0 * 4 + 1] * src2[3 * 4 + 0] + src1[1 * 4 + 1] * src2[3 * 4 + 1] +
      src1[2 * 4 + 1] * src2[3 * 4 + 2] + src1[3 * 4 + 1] * src2[3 * 4 + 3];
  t_res[3 * 4 + 2] =
      src1[0 * 4 + 2] * src2[3 * 4 + 0] + src1[1 * 4 + 2] * src2[3 * 4 + 1] +
      src1[2 * 4 + 2] * src2[3 * 4 + 2] + src1[3 * 4 + 2] * src2[3 * 4 + 3];
  t_res[3 * 4 + 3] =
      src1[0 * 4 + 3] * src2[3 * 4 + 0] + src1[1 * 4 + 3] * src2[3 * 4 + 1] +
      src1[2 * 4 + 3] * src2[3 * 4 + 2] + src1[3 * 4 + 3] * src2[3 * 4 + 3];
  memcpy(result, t_res, sizeof(t_res));
}


x86 assembly (clang, -O0):
<Mat4_Mat4_mul>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mat4_Mat4_mul>:
sub    $0x48,%rsp
movss  (%rdx),%xmm4
movss  0x4(%rdx),%xmm5
movss  0x8(%rdx),%xmm6
movss  0xc(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
movups (%rsi),%xmm2
movups 0x10(%rsi),%xmm3
movups 0x20(%rsi),%xmm1
movups 0x30(%rsi),%xmm0
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps %xmm7,(%rsp)
movss  0x10(%rdx),%xmm4
movss  0x14(%rdx),%xmm5
movss  0x18(%rdx),%xmm6
movss  0x1c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps %xmm7,0x10(%rsp)
movss  0x20(%rdx),%xmm4
movss  0x24(%rdx),%xmm5
movss  0x28(%rdx),%xmm6
movss  0x2c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps %xmm7,0x20(%rsp)
movss  0x30(%rdx),%xmm4
movss  0x34(%rdx),%xmm5
movss  0x38(%rdx),%xmm6
movss  0x3c(%rdx),%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm3,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm4,%xmm6
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps %xmm7,0x30(%rsp)
mov    %rsp,%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
add    $0x48,%rsp
ret

LLVM IR (-O0):
define void @Mat4_Mat4_mul(float* %0, float* %1, float* %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca [16 x float]
store float* %0, float** %4
store float* %1, float** %5
store float* %2, float** %6
%8 = load float*, float** %5
%9 = getelementptr inbounds float, float* %8, i64 0
%10 = load float, float* %9
%11 = load float*, float** %6
%12 = getelementptr inbounds float, float* %11, i64 0
%13 = load float, float* %12
%14 = load float*, float** %5
%15 = getelementptr inbounds float, float* %14, i64 4
%16 = load float, float* %15
%17 = load float*, float** %6
%18 = getelementptr inbounds float, float* %17, i64 1
%19 = load float, float* %18
%20 = fmul float %16, %19
%21 = call float @llvm.fmuladd.f32(float %10, float %13, float %20)
%22 = load float*, float** %5
%23 = getelementptr inbounds float, float* %22, i64 8
%24 = load float, float* %23
%25 = load float*, float** %6
%26 = getelementptr inbounds float, float* %25, i64 2
%27 = load float, float* %26
%28 = call float @llvm.fmuladd.f32(float %24, float %27, float %21)
%29 = load float*, float** %5
%30 = getelementptr inbounds float, float* %29, i64 12
%31 = load float, float* %30
%32 = load float*, float** %6
%33 = getelementptr inbounds float, float* %32, i64 3
%34 = load float, float* %33
%35 = call float @llvm.fmuladd.f32(float %31, float %34, float %28)
%36 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
store float %35, float* %36
%37 = load float*, float** %5
%38 = getelementptr inbounds float, float* %37, i64 1
%39 = load float, float* %38
%40 = load float*, float** %6
%41 = getelementptr inbounds float, float* %40, i64 0
%42 = load float, float* %41
%43 = load float*, float** %5
%44 = getelementptr inbounds float, float* %43, i64 5
%45 = load float, float* %44
%46 = load float*, float** %6
%47 = getelementptr inbounds float, float* %46, i64 1
%48 = load float, float* %47
%49 = fmul float %45, %48
%50 = call float @llvm.fmuladd.f32(float %39, float %42, float %49)
%51 = load float*, float** %5
%52 = getelementptr inbounds float, float* %51, i64 9
%53 = load float, float* %52
%54 = load float*, float** %6
%55 = getelementptr inbounds float, float* %54, i64 2
%56 = load float, float* %55
%57 = call float @llvm.fmuladd.f32(float %53, float %56, float %50)
%58 = load float*, float** %5
%59 = getelementptr inbounds float, float* %58, i64 13
%60 = load float, float* %59
%61 = load float*, float** %6
%62 = getelementptr inbounds float, float* %61, i64 3
%63 = load float, float* %62
%64 = call float @llvm.fmuladd.f32(float %60, float %63, float %57)
%65 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 1
store float %64, float* %65
%66 = load float*, float** %5
%67 = getelementptr inbounds float, float* %66, i64 2
%68 = load float, float* %67
%69 = load float*, float** %6
%70 = getelementptr inbounds float, float* %69, i64 0
%71 = load float, float* %70
%72 = load float*, float** %5
%73 = getelementptr inbounds float, float* %72, i64 6
%74 = load float, float* %73
%75 = load float*, float** %6
%76 = getelementptr inbounds float, float* %75, i64 1
%77 = load float, float* %76
%78 = fmul float %74, %77
%79 = call float @llvm.fmuladd.f32(float %68, float %71, float %78)
%80 = load float*, float** %5
%81 = getelementptr inbounds float, float* %80, i64 10
%82 = load float, float* %81
%83 = load float*, float** %6
%84 = getelementptr inbounds float, float* %83, i64 2
%85 = load float, float* %84
%86 = call float @llvm.fmuladd.f32(float %82, float %85, float %79)
%87 = load float*, float** %5
%88 = getelementptr inbounds float, float* %87, i64 14
%89 = load float, float* %88
%90 = load float*, float** %6
%91 = getelementptr inbounds float, float* %90, i64 3
%92 = load float, float* %91
%93 = call float @llvm.fmuladd.f32(float %89, float %92, float %86)
%94 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 2
store float %93, float* %94
%95 = load float*, float** %5
%96 = getelementptr inbounds float, float* %95, i64 3
%97 = load float, float* %96
%98 = load float*, float** %6
%99 = getelementptr inbounds float, float* %98, i64 0
%100 = load float, float* %99
%101 = load float*, float** %5
%102 = getelementptr inbounds float, float* %101, i64 7
%103 = load float, float* %102
%104 = load float*, float** %6
%105 = getelementptr inbounds float, float* %104, i64 1
%106 = load float, float* %105
%107 = fmul float %103, %106
%108 = call float @llvm.fmuladd.f32(float %97, float %100, float %107)
%109 = load float*, float** %5
%110 = getelementptr inbounds float, float* %109, i64 11
%111 = load float, float* %110
%112 = load float*, float** %6
%113 = getelementptr inbounds float, float* %112, i64 2
%114 = load float, float* %113
%115 = call float @llvm.fmuladd.f32(float %111, float %114, float %108)
%116 = load float*, float** %5
%117 = getelementptr inbounds float, float* %116, i64 15
%118 = load float, float* %117
%119 = load float*, float** %6
%120 = getelementptr inbounds float, float* %119, i64 3
%121 = load float, float* %120
%122 = call float @llvm.fmuladd.f32(float %118, float %121, float %115)
%123 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 3
store float %122, float* %123
%124 = load float*, float** %5
%125 = getelementptr inbounds float, float* %124, i64 0
%126 = load float, float* %125
%127 = load float*, float** %6
%128 = getelementptr inbounds float, float* %127, i64 4
%129 = load float, float* %128
%130 = load float*, float** %5
%131 = getelementptr inbounds float, float* %130, i64 4
%132 = load float, float* %131
%133 = load float*, float** %6
%134 = getelementptr inbounds float, float* %133, i64 5
%135 = load float, float* %134
%136 = fmul float %132, %135
%137 = call float @llvm.fmuladd.f32(float %126, float %129, float %136)
%138 = load float*, float** %5
%139 = getelementptr inbounds float, float* %138, i64 8
%140 = load float, float* %139
%141 = load float*, float** %6
%142 = getelementptr inbounds float, float* %141, i64 6
%143 = load float, float* %142
%144 = call float @llvm.fmuladd.f32(float %140, float %143, float %137)
%145 = load float*, float** %5
%146 = getelementptr inbounds float, float* %145, i64 12
%147 = load float, float* %146
%148 = load float*, float** %6
%149 = getelementptr inbounds float, float* %148, i64 7
%150 = load float, float* %149
%151 = call float @llvm.fmuladd.f32(float %147, float %150, float %144)
%152 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 4
store float %151, float* %152
%153 = load float*, float** %5
%154 = getelementptr inbounds float, float* %153, i64 1
%155 = load float, float* %154
%156 = load float*, float** %6
%157 = getelementptr inbounds float, float* %156, i64 4
%158 = load float, float* %157
%159 = load float*, float** %5
%160 = getelementptr inbounds float, float* %159, i64 5
%161 = load float, float* %160
%162 = load float*, float** %6
%163 = getelementptr inbounds float, float* %162, i64 5
%164 = load float, float* %163
%165 = fmul float %161, %164
%166 = call float @llvm.fmuladd.f32(float %155, float %158, float %165)
%167 = load float*, float** %5
%168 = getelementptr inbounds float, float* %167, i64 9
%169 = load float, float* %168
%170 = load float*, float** %6
%171 = getelementptr inbounds float, float* %170, i64 6
%172 = load float, float* %171
%173 = call float @llvm.fmuladd.f32(float %169, float %172, float %166)
%174 = load float*, float** %5
%175 = getelementptr inbounds float, float* %174, i64 13
%176 = load float, float* %175
%177 = load float*, float** %6
%178 = getelementptr inbounds float, float* %177, i64 7
%179 = load float, float* %178
%180 = call float @llvm.fmuladd.f32(float %176, float %179, float %173)
%181 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 5
store float %180, float* %181
%182 = load float*, float** %5
%183 = getelementptr inbounds float, float* %182, i64 2
%184 = load float, float* %183
%185 = load float*, float** %6
%186 = getelementptr inbounds float, float* %185, i64 4
%187 = load float, float* %186
%188 = load float*, float** %5
%189 = getelementptr inbounds float, float* %188, i64 6
%190 = load float, float* %189
%191 = load float*, float** %6
%192 = getelementptr inbounds float, float* %191, i64 5
%193 = load float, float* %192
%194 = fmul float %190, %193
%195 = call float @llvm.fmuladd.f32(float %184, float %187, float %194)
%196 = load float*, float** %5
%197 = getelementptr inbounds float, float* %196, i64 10
%198 = load float, float* %197
%199 = load float*, float** %6
%200 = getelementptr inbounds float, float* %199, i64 6
%201 = load float, float* %200
%202 = call float @llvm.fmuladd.f32(float %198, float %201, float %195)
%203 = load float*, float** %5
%204 = getelementptr inbounds float, float* %203, i64 14
%205 = load float, float* %204
%206 = load float*, float** %6
%207 = getelementptr inbounds float, float* %206, i64 7
%208 = load float, float* %207
%209 = call float @llvm.fmuladd.f32(float %205, float %208, float %202)
%210 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 6
store float %209, float* %210
%211 = load float*, float** %5
%212 = getelementptr inbounds float, float* %211, i64 3
%213 = load float, float* %212
%214 = load float*, float** %6
%215 = getelementptr inbounds float, float* %214, i64 4
%216 = load float, float* %215
%217 = load float*, float** %5
%218 = getelementptr inbounds float, float* %217, i64 7
%219 = load float, float* %218
%220 = load float*, float** %6
%221 = getelementptr inbounds float, float* %220, i64 5
%222 = load float, float* %221
%223 = fmul float %219, %222
%224 = call float @llvm.fmuladd.f32(float %213, float %216, float %223)
%225 = load float*, float** %5
%226 = getelementptr inbounds float, float* %225, i64 11
%227 = load float, float* %226
%228 = load float*, float** %6
%229 = getelementptr inbounds float, float* %228, i64 6
%230 = load float, float* %229
%231 = call float @llvm.fmuladd.f32(float %227, float %230, float %224)
%232 = load float*, float** %5
%233 = getelementptr inbounds float, float* %232, i64 15
%234 = load float, float* %233
%235 = load float*, float** %6
%236 = getelementptr inbounds float, float* %235, i64 7
%237 = load float, float* %236
%238 = call float @llvm.fmuladd.f32(float %234, float %237, float %231)
%239 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 7
store float %238, float* %239
%240 = load float*, float** %5
%241 = getelementptr inbounds float, float* %240, i64 0
%242 = load float, float* %241
%243 = load float*, float** %6
%244 = getelementptr inbounds float, float* %243, i64 8
%245 = load float, float* %244
%246 = load float*, float** %5
%247 = getelementptr inbounds float, float* %246, i64 4
%248 = load float, float* %247
%249 = load float*, float** %6
%250 = getelementptr inbounds float, float* %249, i64 9
%251 = load float, float* %250
%252 = fmul float %248, %251
%253 = call float @llvm.fmuladd.f32(float %242, float %245, float %252)
%254 = load float*, float** %5
%255 = getelementptr inbounds float, float* %254, i64 8
%256 = load float, float* %255
%257 = load float*, float** %6
%258 = getelementptr inbounds float, float* %257, i64 10
%259 = load float, float* %258
%260 = call float @llvm.fmuladd.f32(float %256, float %259, float %253)
%261 = load float*, float** %5
%262 = getelementptr inbounds float, float* %261, i64 12
%263 = load float, float* %262
%264 = load float*, float** %6
%265 = getelementptr inbounds float, float* %264, i64 11
%266 = load float, float* %265
%267 = call float @llvm.fmuladd.f32(float %263, float %266, float %260)
%268 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 8
store float %267, float* %268
%269 = load float*, float** %5
%270 = getelementptr inbounds float, float* %269, i64 1
%271 = load float, float* %270
%272 = load float*, float** %6
%273 = getelementptr inbounds float, float* %272, i64 8
%274 = load float, float* %273
%275 = load float*, float** %5
%276 = getelementptr inbounds float, float* %275, i64 5
%277 = load float, float* %276
%278 = load float*, float** %6
%279 = getelementptr inbounds float, float* %278, i64 9
%280 = load float, float* %279
%281 = fmul float %277, %280
%282 = call float @llvm.fmuladd.f32(float %271, float %274, float %281)
%283 = load float*, float** %5
%284 = getelementptr inbounds float, float* %283, i64 9
%285 = load float, float* %284
%286 = load float*, float** %6
%287 = getelementptr inbounds float, float* %286, i64 10
%288 = load float, float* %287
%289 = call float @llvm.fmuladd.f32(float %285, float %288, float %282)
%290 = load float*, float** %5
%291 = getelementptr inbounds float, float* %290, i64 13
%292 = load float, float* %291
%293 = load float*, float** %6
%294 = getelementptr inbounds float, float* %293, i64 11
%295 = load float, float* %294
%296 = call float @llvm.fmuladd.f32(float %292, float %295, float %289)
%297 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 9
store float %296, float* %297
%298 = load float*, float** %5
%299 = getelementptr inbounds float, float* %298, i64 2
%300 = load float, float* %299
%301 = load float*, float** %6
%302 = getelementptr inbounds float, float* %301, i64 8
%303 = load float, float* %302
%304 = load float*, float** %5
%305 = getelementptr inbounds float, float* %304, i64 6
%306 = load float, float* %305
%307 = load float*, float** %6
%308 = getelementptr inbounds float, float* %307, i64 9
%309 = load float, float* %308
%310 = fmul float %306, %309
%311 = call float @llvm.fmuladd.f32(float %300, float %303, float %310)
%312 = load float*, float** %5
%313 = getelementptr inbounds float, float* %312, i64 10
%314 = load float, float* %313
%315 = load float*, float** %6
%316 = getelementptr inbounds float, float* %315, i64 10
%317 = load float, float* %316
%318 = call float @llvm.fmuladd.f32(float %314, float %317, float %311)
%319 = load float*, float** %5
%320 = getelementptr inbounds float, float* %319, i64 14
%321 = load float, float* %320
%322 = load float*, float** %6
%323 = getelementptr inbounds float, float* %322, i64 11
%324 = load float, float* %323
%325 = call float @llvm.fmuladd.f32(float %321, float %324, float %318)
%326 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 10
store float %325, float* %326
%327 = load float*, float** %5
%328 = getelementptr inbounds float, float* %327, i64 3
%329 = load float, float* %328
%330 = load float*, float** %6
%331 = getelementptr inbounds float, float* %330, i64 8
%332 = load float, float* %331
%333 = load float*, float** %5
%334 = getelementptr inbounds float, float* %333, i64 7
%335 = load float, float* %334
%336 = load float*, float** %6
%337 = getelementptr inbounds float, float* %336, i64 9
%338 = load float, float* %337
%339 = fmul float %335, %338
%340 = call float @llvm.fmuladd.f32(float %329, float %332, float %339)
%341 = load float*, float** %5
%342 = getelementptr inbounds float, float* %341, i64 11
%343 = load float, float* %342
%344 = load float*, float** %6
%345 = getelementptr inbounds float, float* %344, i64 10
%346 = load float, float* %345
%347 = call float @llvm.fmuladd.f32(float %343, float %346, float %340)
%348 = load float*, float** %5
%349 = getelementptr inbounds float, float* %348, i64 15
%350 = load float, float* %349
%351 = load float*, float** %6
%352 = getelementptr inbounds float, float* %351, i64 11
%353 = load float, float* %352
%354 = call float @llvm.fmuladd.f32(float %350, float %353, float %347)
%355 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 11
store float %354, float* %355
%356 = load float*, float** %5
%357 = getelementptr inbounds float, float* %356, i64 0
%358 = load float, float* %357
%359 = load float*, float** %6
%360 = getelementptr inbounds float, float* %359, i64 12
%361 = load float, float* %360
%362 = load float*, float** %5
%363 = getelementptr inbounds float, float* %362, i64 4
%364 = load float, float* %363
%365 = load float*, float** %6
%366 = getelementptr inbounds float, float* %365, i64 13
%367 = load float, float* %366
%368 = fmul float %364, %367
%369 = call float @llvm.fmuladd.f32(float %358, float %361, float %368)
%370 = load float*, float** %5
%371 = getelementptr inbounds float, float* %370, i64 8
%372 = load float, float* %371
%373 = load float*, float** %6
%374 = getelementptr inbounds float, float* %373, i64 14
%375 = load float, float* %374
%376 = call float @llvm.fmuladd.f32(float %372, float %375, float %369)
%377 = load float*, float** %5
%378 = getelementptr inbounds float, float* %377, i64 12
%379 = load float, float* %378
%380 = load float*, float** %6
%381 = getelementptr inbounds float, float* %380, i64 15
%382 = load float, float* %381
%383 = call float @llvm.fmuladd.f32(float %379, float %382, float %376)
%384 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 12
store float %383, float* %384
%385 = load float*, float** %5
%386 = getelementptr inbounds float, float* %385, i64 1
%387 = load float, float* %386
%388 = load float*, float** %6
%389 = getelementptr inbounds float, float* %388, i64 12
%390 = load float, float* %389
%391 = load float*, float** %5
%392 = getelementptr inbounds float, float* %391, i64 5
%393 = load float, float* %392
%394 = load float*, float** %6
%395 = getelementptr inbounds float, float* %394, i64 13
%396 = load float, float* %395
%397 = fmul float %393, %396
%398 = call float @llvm.fmuladd.f32(float %387, float %390, float %397)
%399 = load float*, float** %5
%400 = getelementptr inbounds float, float* %399, i64 9
%401 = load float, float* %400
%402 = load float*, float** %6
%403 = getelementptr inbounds float, float* %402, i64 14
%404 = load float, float* %403
%405 = call float @llvm.fmuladd.f32(float %401, float %404, float %398)
%406 = load float*, float** %5
%407 = getelementptr inbounds float, float* %406, i64 13
%408 = load float, float* %407
%409 = load float*, float** %6
%410 = getelementptr inbounds float, float* %409, i64 15
%411 = load float, float* %410
%412 = call float @llvm.fmuladd.f32(float %408, float %411, float %405)
%413 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 13
store float %412, float* %413
%414 = load float*, float** %5
%415 = getelementptr inbounds float, float* %414, i64 2
%416 = load float, float* %415
%417 = load float*, float** %6
%418 = getelementptr inbounds float, float* %417, i64 12
%419 = load float, float* %418
%420 = load float*, float** %5
%421 = getelementptr inbounds float, float* %420, i64 6
%422 = load float, float* %421
%423 = load float*, float** %6
%424 = getelementptr inbounds float, float* %423, i64 13
%425 = load float, float* %424
%426 = fmul float %422, %425
%427 = call float @llvm.fmuladd.f32(float %416, float %419, float %426)
%428 = load float*, float** %5
%429 = getelementptr inbounds float, float* %428, i64 10
%430 = load float, float* %429
%431 = load float*, float** %6
%432 = getelementptr inbounds float, float* %431, i64 14
%433 = load float, float* %432
%434 = call float @llvm.fmuladd.f32(float %430, float %433, float %427)
%435 = load float*, float** %5
%436 = getelementptr inbounds float, float* %435, i64 14
%437 = load float, float* %436
%438 = load float*, float** %6
%439 = getelementptr inbounds float, float* %438, i64 15
%440 = load float, float* %439
%441 = call float @llvm.fmuladd.f32(float %437, float %440, float %434)
%442 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 14
store float %441, float* %442
%443 = load float*, float** %5
%444 = getelementptr inbounds float, float* %443, i64 3
%445 = load float, float* %444
%446 = load float*, float** %6
%447 = getelementptr inbounds float, float* %446, i64 12
%448 = load float, float* %447
%449 = load float*, float** %5
%450 = getelementptr inbounds float, float* %449, i64 7
%451 = load float, float* %450
%452 = load float*, float** %6
%453 = getelementptr inbounds float, float* %452, i64 13
%454 = load float, float* %453
%455 = fmul float %451, %454
%456 = call float @llvm.fmuladd.f32(float %445, float %448, float %455)
%457 = load float*, float** %5
%458 = getelementptr inbounds float, float* %457, i64 11
%459 = load float, float* %458
%460 = load float*, float** %6
%461 = getelementptr inbounds float, float* %460, i64 14
%462 = load float, float* %461
%463 = call float @llvm.fmuladd.f32(float %459, float %462, float %456)
%464 = load float*, float** %5
%465 = getelementptr inbounds float, float* %464, i64 15
%466 = load float, float* %465
%467 = load float*, float** %6
%468 = getelementptr inbounds float, float* %467, i64 15
%469 = load float, float* %468
%470 = call float @llvm.fmuladd.f32(float %466, float %469, float %463)
%471 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 15
store float %470, float* %471
%472 = load float*, float** %4
%473 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
%474 = call i32 @memcpy(float* %472, float* %473, i32 64)
ret void
}

LLVM IR (-O2):
define void @Mat4_Mat4_mul(float* %0, float* nocapture %1, float* nocapture %2) {
%4 = alloca [16 x float]
%5 = bitcast [16 x float]* %4 to i8*
%6 = load float, float* %2
%7 = getelementptr inbounds float, float* %1, i64 4
%8 = getelementptr inbounds float, float* %2, i64 1
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %1, i64 8
%11 = getelementptr inbounds float, float* %2, i64 2
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %1, i64 12
%14 = getelementptr inbounds float, float* %2, i64 3
%15 = load float, float* %14
%16 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 0
%17 = bitcast float* %1 to <4 x float>*
%18 = load <4 x float>, <4 x float>* %17
%19 = bitcast float* %7 to <4 x float>*
%20 = load <4 x float>, <4 x float>* %19
%21 = insertelement <4 x float> poison, float %9, i64 0
%22 = shufflevector <4 x float> %21, <4 x float> poison, <4 x i32> zeroinitializer
%23 = fmul <4 x float> %22, %20
%24 = insertelement <4 x float> poison, float %6, i64 0
%25 = shufflevector <4 x float> %24, <4 x float> poison, <4 x i32> zeroinitializer
%26 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %18, <4 x float> %25, <4 x float> %23)
%27 = bitcast float* %10 to <4 x float>*
%28 = load <4 x float>, <4 x float>* %27
%29 = insertelement <4 x float> poison, float %12, i64 0
%30 = shufflevector <4 x float> %29, <4 x float> poison, <4 x i32> zeroinitializer
%31 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %28, <4 x float> %30, <4 x float> %26)
%32 = bitcast float* %13 to <4 x float>*
%33 = load <4 x float>, <4 x float>* %32
%34 = insertelement <4 x float> poison, float %15, i64 0
%35 = shufflevector <4 x float> %34, <4 x float> poison, <4 x i32> zeroinitializer
%36 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %33, <4 x float> %35, <4 x float> %31)
%37 = bitcast [16 x float]* %4 to <4 x float>*
store <4 x float> %36, <4 x float>* %37
%38 = getelementptr inbounds float, float* %2, i64 4
%39 = load float, float* %38
%40 = getelementptr inbounds float, float* %2, i64 5
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %2, i64 6
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %2, i64 7
%45 = load float, float* %44
%46 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 4
%47 = insertelement <4 x float> poison, float %41, i64 0
%48 = shufflevector <4 x float> %47, <4 x float> poison, <4 x i32> zeroinitializer
%49 = fmul <4 x float> %20, %48
%50 = insertelement <4 x float> poison, float %39, i64 0
%51 = shufflevector <4 x float> %50, <4 x float> poison, <4 x i32> zeroinitializer
%52 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %18, <4 x float> %51, <4 x float> %49)
%53 = insertelement <4 x float> poison, float %43, i64 0
%54 = shufflevector <4 x float> %53, <4 x float> poison, <4 x i32> zeroinitializer
%55 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %28, <4 x float> %54, <4 x float> %52)
%56 = insertelement <4 x float> poison, float %45, 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> %33, <4 x float> %57, <4 x float> %55)
%59 = bitcast float* %46 to <4 x float>*
store <4 x float> %58, <4 x float>* %59
%60 = getelementptr inbounds float, float* %2, i64 8
%61 = load float, float* %60
%62 = getelementptr inbounds float, float* %2, i64 9
%63 = load float, float* %62
%64 = getelementptr inbounds float, float* %2, i64 10
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %2, i64 11
%67 = load float, float* %66
%68 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 8
%69 = insertelement <4 x float> poison, float %63, i64 0
%70 = shufflevector <4 x float> %69, <4 x float> poison, <4 x i32> zeroinitializer
%71 = fmul <4 x float> %20, %70
%72 = insertelement <4 x float> poison, float %61, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %18, <4 x float> %73, <4 x float> %71)
%75 = insertelement <4 x float> poison, float %65, i64 0
%76 = shufflevector <4 x float> %75, <4 x float> poison, <4 x i32> zeroinitializer
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %28, <4 x float> %76, <4 x float> %74)
%78 = insertelement <4 x float> poison, float %67, i64 0
%79 = shufflevector <4 x float> %78, <4 x float> poison, <4 x i32> zeroinitializer
%80 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %33, <4 x float> %79, <4 x float> %77)
%81 = bitcast float* %68 to <4 x float>*
store <4 x float> %80, <4 x float>* %81
%82 = getelementptr inbounds float, float* %2, i64 12
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %2, i64 13
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %2, i64 14
%87 = load float, float* %86
%88 = getelementptr inbounds float, float* %2, i64 15
%89 = load float, float* %88
%90 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 12
%91 = insertelement <4 x float> poison, float %85, i64 0
%92 = shufflevector <4 x float> %91, <4 x float> poison, <4 x i32> zeroinitializer
%93 = fmul <4 x float> %20, %92
%94 = insertelement <4 x float> poison, float %83, i64 0
%95 = shufflevector <4 x float> %94, <4 x float> poison, <4 x i32> zeroinitializer
%96 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %18, <4 x float> %95, <4 x float> %93)
%97 = insertelement <4 x float> poison, float %87, i64 0
%98 = shufflevector <4 x float> %97, <4 x float> poison, <4 x i32> zeroinitializer
%99 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %28, <4 x float> %98, <4 x float> %96)
%100 = insertelement <4 x float> poison, float %89, i64 0
%101 = shufflevector <4 x float> %100, <4 x float> poison, <4 x i32> zeroinitializer
%102 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %33, <4 x float> %101, <4 x float> %99)
%103 = bitcast float* %90 to <4 x float>*
store <4 x float> %102, <4 x float>* %103
%104 = call i32 @memcpy(float* %0, float* %16, i32 64)
ret void
}