void MatrixTransformTTTfN3f(unsigned int n, float *q, float *m, float *p) {
  register const float m0 = m[0], m4 = m[4], m8 = m[8], m12 = m[12];
  register const float m1 = m[1], m5 = m[5], m9 = m[9], m13 = m[13];
  register const float m2 = m[2], m6 = m[6], m10 = m[10], m14 = m[14];
  register const float m3 = m[3], m7 = m[7], m11 = m[11];
  register float p0, p1, p2;
  while (n--) {
    p0 = *(p++) + m12;
    p1 = *(p++) + m13;
    p2 = *(p++) + m14;
    *(q++) = m0 * p0 + m1 * p1 + m2 * p2 + m3;
    *(q++) = m4 * p0 + m5 * p1 + m6 * p2 + m7;
    *(q++) = m8 * p0 + m9 * p1 + m10 * p2 + m11;
  }
}


x86 assembly (clang, -O0):
<MatrixTransformTTTfN3f>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4(%rbp)
cmp    $0x0,%eax
je     1326 <MatrixTransformTTTfN3f+0x226>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
movss  (%rax),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
movss  (%rax),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
movss  (%rax),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x34(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x38(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  %xmm0,(%rax)
jmp    11e4 <MatrixTransformTTTfN3f+0xe4>
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixTransformTTTfN3f>:
sub    $0xd8,%rsp
test   %edi,%edi
je     14f0 <MatrixTransformTTTfN3f+0x3f0>
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm6
movss  0x10(%rdx),%xmm5
movss  0x20(%rdx),%xmm4
movss  0x30(%rdx),%xmm0
movss  0x14(%rdx),%xmm11
movss  0x24(%rdx),%xmm1
movss  0x34(%rdx),%xmm2
movss  0x8(%rdx),%xmm14
movss  0x18(%rdx),%xmm9
movss  0x28(%rdx),%xmm10
movss  0x38(%rdx),%xmm12
movss  0xc(%rdx),%xmm13
movss  0x1c(%rdx),%xmm8
movss  0x2c(%rdx),%xmm15
lea    -0x1(%rdi),%r8d
cmp    $0x3,%r8d
movaps %xmm1,0xb0(%rsp)
movaps %xmm2,-0x50(%rsp)
movaps %xmm5,0xc0(%rsp)
movaps %xmm11,0xa0(%rsp)
jae    119b <MatrixTransformTTTfN3f+0x9b>
mov    %rsi,%r10
mov    %rcx,%r11
movaps %xmm7,%xmm3
movaps %xmm6,%xmm11
jmp    1429 <MatrixTransformTTTfN3f+0x329>
movaps %xmm15,-0x80(%rsp)
movaps %xmm8,-0x70(%rsp)
movaps %xmm10,-0x60(%rsp)
lea    (%r8,%r8,2),%rax
lea    (%rcx,%rax,4),%rdx
add    $0xc,%rdx
cmp    %rsi,%rdx
jbe    11ef <MatrixTransformTTTfN3f+0xef>
lea    (%rsi,%rax,4),%rax
add    $0xc,%rax
cmp    %rcx,%rax
jbe    11ef <MatrixTransformTTTfN3f+0xef>
mov    %rsi,%r10
mov    %rcx,%r11
movaps %xmm7,%xmm3
movaps %xmm6,%xmm11
movaps -0x60(%rsp),%xmm10
movaps -0x70(%rsp),%xmm8
movaps -0x80(%rsp),%xmm15
jmp    1429 <MatrixTransformTTTfN3f+0x329>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
sub    %r9d,%edi
lea    0x0(,%r9,4),%rax
lea    (%rax,%rax,2),%r11
lea    (%rsi,%r11,1),%r10
add    %rcx,%r11
movaps %xmm0,(%rsp)
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x60(%rsp)
movaps %xmm12,-0x10(%rsp)
shufps $0x0,%xmm12,%xmm12
movaps %xmm12,0x90(%rsp)
movaps %xmm6,0x20(%rsp)
shufps $0x0,%xmm6,%xmm6
movaps %xmm6,0x40(%rsp)
movaps %xmm7,0x30(%rsp)
shufps $0x0,%xmm7,%xmm7
movaps %xmm14,-0x30(%rsp)
shufps $0x0,%xmm14,%xmm14
movaps %xmm13,-0x20(%rsp)
shufps $0x0,%xmm13,%xmm13
movaps %xmm13,0x80(%rsp)
shufps $0x0,%xmm11,%xmm11
movaps %xmm11,0x70(%rsp)
shufps $0x0,%xmm5,%xmm5
movaps %xmm5,0x50(%rsp)
movaps %xmm9,-0x40(%rsp)
movaps %xmm9,%xmm12
movaps %xmm14,%xmm5
movaps %xmm7,%xmm6
shufps $0x0,%xmm9,%xmm12
movaps -0x70(%rsp),%xmm11
shufps $0x0,%xmm11,%xmm11
movaps %xmm1,%xmm14
shufps $0x0,%xmm1,%xmm14
movaps %xmm4,%xmm13
movaps %xmm4,0x10(%rsp)
movaps %xmm8,%xmm4
shufps $0x0,%xmm13,%xmm13
movaps -0x60(%rsp),%xmm10
shufps $0x0,%xmm10,%xmm10
movaps -0x80(%rsp),%xmm9
shufps $0x0,%xmm9,%xmm9
xor    %eax,%eax
mov    %r9,%rdx
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rax,1),%xmm0
movups 0x10(%rcx,%rax,1),%xmm15
movups 0x20(%rcx,%rax,1),%xmm3
movaps %xmm3,%xmm1
shufps $0xe5,%xmm15,%xmm1
movaps %xmm3,%xmm2
shufps $0xf6,%xmm15,%xmm2
movaps %xmm0,%xmm7
shufps $0x1,%xmm15,%xmm7
shufps $0x21,%xmm0,%xmm15
shufps $0x2c,%xmm1,%xmm0
addps  %xmm4,%xmm0
shufps $0x28,%xmm2,%xmm7
addps  0x60(%rsp),%xmm7
shufps $0xc2,%xmm3,%xmm15
addps  0x90(%rsp),%xmm15
movaps 0x40(%rsp),%xmm1
mulps  %xmm7,%xmm1
movaps %xmm6,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movaps %xmm5,%xmm8
mulps  %xmm15,%xmm8
addps  %xmm2,%xmm8
addps  0x80(%rsp),%xmm8
movaps 0x70(%rsp),%xmm1
mulps  %xmm7,%xmm1
movaps 0x50(%rsp),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movaps %xmm12,%xmm1
mulps  %xmm15,%xmm1
addps  %xmm2,%xmm1
addps  %xmm11,%xmm1
mulps  %xmm14,%xmm7
mulps  %xmm13,%xmm0
addps  %xmm7,%xmm0
mulps  %xmm10,%xmm15
addps  %xmm0,%xmm15
addps  %xmm9,%xmm15
movaps %xmm15,%xmm0
shufps $0xd4,%xmm8,%xmm0
movaps %xmm1,%xmm2
movlhps %xmm8,%xmm2
shufps $0x82,%xmm0,%xmm2
movaps %xmm8,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm15,%xmm3
shufps $0x11,%xmm1,%xmm3
shufps $0x82,%xmm0,%xmm3
shufps $0xff,%xmm15,%xmm1
shufps $0x23,%xmm15,%xmm8
shufps $0x82,%xmm1,%xmm8
movups %xmm8,0x20(%rsi,%rax,1)
movups %xmm3,0x10(%rsi,%rax,1)
movups %xmm2,(%rsi,%rax,1)
add    $0x30,%rax
add    $0xfffffffffffffffc,%rdx
jne    12e0 <MatrixTransformTTTfN3f+0x1e0>
cmp    %r9,%r8
movaps 0x30(%rsp),%xmm3
movaps 0x20(%rsp),%xmm11
movaps 0x10(%rsp),%xmm4
movaps (%rsp),%xmm0
movaps -0x50(%rsp),%xmm2
movaps -0x30(%rsp),%xmm14
movaps -0x40(%rsp),%xmm9
movaps -0x60(%rsp),%xmm10
movaps -0x10(%rsp),%xmm12
movaps -0x20(%rsp),%xmm13
movaps -0x70(%rsp),%xmm8
movaps -0x80(%rsp),%xmm15
je     14f0 <MatrixTransformTTTfN3f+0x3f0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%r11,%rax,1),%xmm7
addss  %xmm0,%xmm7
movss  0x4(%r11,%rax,1),%xmm1
addss  %xmm2,%xmm1
movaps %xmm0,%xmm6
movss  0x8(%r11,%rax,1),%xmm0
addss  %xmm12,%xmm0
movaps %xmm11,%xmm2
mulss  %xmm1,%xmm2
movaps %xmm3,%xmm5
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movaps %xmm14,%xmm2
mulss  %xmm0,%xmm2
addss  %xmm3,%xmm2
addss  %xmm13,%xmm2
movss  %xmm2,(%r10,%rax,1)
movaps 0xa0(%rsp),%xmm2
mulss  %xmm1,%xmm2
movaps 0xc0(%rsp),%xmm3
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movaps %xmm9,%xmm2
mulss  %xmm0,%xmm2
addss  %xmm3,%xmm2
movaps %xmm5,%xmm3
addss  %xmm8,%xmm2
movss  %xmm2,0x4(%r10,%rax,1)
mulss  0xb0(%rsp),%xmm1
movaps -0x50(%rsp),%xmm2
mulss  %xmm4,%xmm7
addss  %xmm1,%xmm7
mulss  %xmm10,%xmm0
addss  %xmm7,%xmm0
addss  %xmm15,%xmm0
movss  %xmm0,0x8(%r10,%rax,1)
movaps %xmm6,%xmm0
add    $0xc,%rax
add    $0xffffffff,%edi
jne    1430 <MatrixTransformTTTfN3f+0x330>
add    $0xd8,%rsp
ret

LLVM IR (-O0):
define void @MatrixTransformTTTfN3f(i32 %0, float* %1, float* %2, float* %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
store i32 %0, i32* %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
%27 = load float*, float** %7
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
store float %29, float* %9
%30 = load float*, float** %7
%31 = getelementptr inbounds float, float* %30, i64 4
%32 = load float, float* %31
store float %32, float* %10
%33 = load float*, float** %7
%34 = getelementptr inbounds float, float* %33, i64 8
%35 = load float, float* %34
store float %35, float* %11
%36 = load float*, float** %7
%37 = getelementptr inbounds float, float* %36, i64 12
%38 = load float, float* %37
store float %38, float* %12
%39 = load float*, float** %7
%40 = getelementptr inbounds float, float* %39, i64 1
%41 = load float, float* %40
store float %41, float* %13
%42 = load float*, float** %7
%43 = getelementptr inbounds float, float* %42, i64 5
%44 = load float, float* %43
store float %44, float* %14
%45 = load float*, float** %7
%46 = getelementptr inbounds float, float* %45, i64 9
%47 = load float, float* %46
store float %47, float* %15
%48 = load float*, float** %7
%49 = getelementptr inbounds float, float* %48, i64 13
%50 = load float, float* %49
store float %50, float* %16
%51 = load float*, float** %7
%52 = getelementptr inbounds float, float* %51, i64 2
%53 = load float, float* %52
store float %53, float* %17
%54 = load float*, float** %7
%55 = getelementptr inbounds float, float* %54, i64 6
%56 = load float, float* %55
store float %56, float* %18
%57 = load float*, float** %7
%58 = getelementptr inbounds float, float* %57, i64 10
%59 = load float, float* %58
store float %59, float* %19
%60 = load float*, float** %7
%61 = getelementptr inbounds float, float* %60, i64 14
%62 = load float, float* %61
store float %62, float* %20
%63 = load float*, float** %7
%64 = getelementptr inbounds float, float* %63, i64 3
%65 = load float, float* %64
store float %65, float* %21
%66 = load float*, float** %7
%67 = getelementptr inbounds float, float* %66, i64 7
%68 = load float, float* %67
store float %68, float* %22
%69 = load float*, float** %7
%70 = getelementptr inbounds float, float* %69, i64 11
%71 = load float, float* %70
store float %71, float* %23
br label %72
72: ; preds = %76, %4
%73 = load i32, i32* %5
%74 = add i32 %73, -1
store i32 %74, i32* %5
%75 = icmp ne i32 %73, 0
br i1 %75, label %76, label %131
76: ; preds = %72
%77 = load float*, float** %8
%78 = getelementptr inbounds float, float* %77, i32 1
store float* %78, float** %8
%79 = load float, float* %77
%80 = load float, float* %12
%81 = fadd float %79, %80
store float %81, float* %24
%82 = load float*, float** %8
%83 = getelementptr inbounds float, float* %82, i32 1
store float* %83, float** %8
%84 = load float, float* %82
%85 = load float, float* %16
%86 = fadd float %84, %85
store float %86, float* %25
%87 = load float*, float** %8
%88 = getelementptr inbounds float, float* %87, i32 1
store float* %88, float** %8
%89 = load float, float* %87
%90 = load float, float* %20
%91 = fadd float %89, %90
store float %91, float* %26
%92 = load float, float* %9
%93 = load float, float* %24
%94 = load float, float* %13
%95 = load float, float* %25
%96 = fmul float %94, %95
%97 = call float @llvm.fmuladd.f32(float %92, float %93, float %96)
%98 = load float, float* %17
%99 = load float, float* %26
%100 = call float @llvm.fmuladd.f32(float %98, float %99, float %97)
%101 = load float, float* %21
%102 = fadd float %100, %101
%103 = load float*, float** %6
%104 = getelementptr inbounds float, float* %103, i32 1
store float* %104, float** %6
store float %102, float* %103
%105 = load float, float* %10
%106 = load float, float* %24
%107 = load float, float* %14
%108 = load float, float* %25
%109 = fmul float %107, %108
%110 = call float @llvm.fmuladd.f32(float %105, float %106, float %109)
%111 = load float, float* %18
%112 = load float, float* %26
%113 = call float @llvm.fmuladd.f32(float %111, float %112, float %110)
%114 = load float, float* %22
%115 = fadd float %113, %114
%116 = load float*, float** %6
%117 = getelementptr inbounds float, float* %116, i32 1
store float* %117, float** %6
store float %115, float* %116
%118 = load float, float* %11
%119 = load float, float* %24
%120 = load float, float* %15
%121 = load float, float* %25
%122 = fmul float %120, %121
%123 = call float @llvm.fmuladd.f32(float %118, float %119, float %122)
%124 = load float, float* %19
%125 = load float, float* %26
%126 = call float @llvm.fmuladd.f32(float %124, float %125, float %123)
%127 = load float, float* %23
%128 = fadd float %126, %127
%129 = load float*, float** %6
%130 = getelementptr inbounds float, float* %129, i32 1
store float* %130, float** %6
store float %128, float* %129
br label %72
131: ; preds = %72
ret void
}

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