void multiply(float A[10][3], float B[3][3], float C[10][3], int n) {
  int i, j, k;
  for (i = 0; i < n; i++) {
    for (j = 0; j < 3; j++) {
      C[i][j] = 0;
      for (k = 0; k < 3; k++)
        C[i][j] += A[i][k] * B[k][j];
    }
  }
}


x86 assembly (clang, -O0):
<multiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ec <multiply+0xec>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    11d9 <multiply+0xd9>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    11c6 <multiply+0xc6>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1159 <multiply+0x59>
jmp    11cb <multiply+0xcb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <multiply+0x2d>
jmp    11de <multiply+0xde>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <multiply+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply>:
push   %rbx
test   %ecx,%ecx
jle    15eb <multiply+0x4eb>
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1118 <multiply+0x18>
xor    %r8d,%r8d
jmp    14f4 <multiply+0x3f4>
lea    0x0(,%rax,4),%r9
lea    (%r9,%r9,2),%rcx
lea    (%rdx,%rcx,1),%r8
add    %rdi,%rcx
cmp    %rdx,%rcx
seta   %r11b
lea    0x24(%rsi),%rcx
cmp    %rdi,%r8
seta   %bl
cmp    %rdx,%rcx
seta   %cl
cmp    %rsi,%r8
seta   %r10b
xor    %r8d,%r8d
test   %bl,%r11b
jne    14f4 <multiply+0x3f4>
and    %r10b,%cl
jne    14f4 <multiply+0x3f4>
mov    %eax,%r8d
and    $0xfffffffc,%r8d
and    $0xfffffffffffffff0,%r9
lea    (%r9,%r9,2),%r9
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rdx,%rcx,1)
movl   $0x0,0xc(%rdx,%rcx,1)
movl   $0x0,0x18(%rdx,%rcx,1)
movl   $0x0,0x24(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm2
movss  0xc(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm2
movss  0x18(%rdi,%rcx,1),%xmm1
movss  0x24(%rdi,%rcx,1),%xmm3
unpcklps %xmm3,%xmm1
movlhps %xmm1,%xmm2
movss  (%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,1)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movss  %xmm2,0xc(%rdx,%rcx,1)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movss  %xmm2,0x18(%rdx,%rcx,1)
movaps %xmm1,%xmm2
shufps $0xff,%xmm1,%xmm2
movss  %xmm2,0x24(%rdx,%rcx,1)
movss  0x4(%rdi,%rcx,1),%xmm3
movss  0x10(%rdi,%rcx,1),%xmm2
unpcklps %xmm2,%xmm3
movss  0x1c(%rdi,%rcx,1),%xmm2
movss  0x28(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm2
movlhps %xmm2,%xmm3
movss  0xc(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rcx,1)
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
movss  %xmm1,0xc(%rdx,%rcx,1)
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movss  %xmm1,0x18(%rdx,%rcx,1)
movaps %xmm2,%xmm1
shufps $0xff,%xmm2,%xmm1
movss  %xmm1,0x24(%rdx,%rcx,1)
movss  0x8(%rdi,%rcx,1),%xmm3
movss  0x14(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm3
movss  0x20(%rdi,%rcx,1),%xmm1
movss  0x2c(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm1
movlhps %xmm1,%xmm3
movss  0x18(%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm2,%xmm1
movl   $0x0,0x4(%rdx,%rcx,1)
movl   $0x0,0x10(%rdx,%rcx,1)
movl   $0x0,0x1c(%rdx,%rcx,1)
movl   $0x0,0x28(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm3
movss  0xc(%rdi,%rcx,1),%xmm2
unpcklps %xmm2,%xmm3
movss  0x18(%rdi,%rcx,1),%xmm2
movss  0x24(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm2
movlhps %xmm2,%xmm3
movss  0x4(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  %xmm2,0x4(%rdx,%rcx,1)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
movss  %xmm3,0x10(%rdx,%rcx,1)
movaps %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movss  %xmm3,0x1c(%rdx,%rcx,1)
movaps %xmm2,%xmm3
shufps $0xff,%xmm2,%xmm3
movss  %xmm3,0x28(%rdx,%rcx,1)
movss  0x4(%rdi,%rcx,1),%xmm4
movss  0x10(%rdi,%rcx,1),%xmm3
unpcklps %xmm3,%xmm4
movss  0x1c(%rdi,%rcx,1),%xmm3
movss  0x28(%rdi,%rcx,1),%xmm5
unpcklps %xmm5,%xmm3
movlhps %xmm3,%xmm4
movss  0x10(%rsi),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm2,%xmm3
movss  %xmm3,0x4(%rdx,%rcx,1)
movaps %xmm3,%xmm2
shufps $0x55,%xmm3,%xmm2
movss  %xmm2,0x10(%rdx,%rcx,1)
movaps %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
movss  %xmm2,0x1c(%rdx,%rcx,1)
movaps %xmm3,%xmm2
shufps $0xff,%xmm3,%xmm2
movss  %xmm2,0x28(%rdx,%rcx,1)
movss  0x8(%rdi,%rcx,1),%xmm2
movss  0x14(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm2
movss  0x20(%rdi,%rcx,1),%xmm4
movss  0x2c(%rdi,%rcx,1),%xmm5
unpcklps %xmm5,%xmm4
movlhps %xmm4,%xmm2
movss  0x1c(%rsi),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movaps %xmm1,%xmm2
shufps $0xff,%xmm4,%xmm2
shufps $0xc9,%xmm0,%xmm2
shufps $0xd2,%xmm2,%xmm2
movaps %xmm4,%xmm3
movlhps %xmm1,%xmm3
xorps  %xmm5,%xmm5
shufps $0xd4,%xmm1,%xmm5
shufps $0x82,%xmm5,%xmm3
unpckhpd %xmm4,%xmm1
xorps  %xmm5,%xmm5
shufps $0xd4,%xmm4,%xmm5
shufps $0x82,%xmm1,%xmm5
movups %xmm5,0x10(%rdx,%rcx,1)
movups %xmm3,(%rdx,%rcx,1)
movups %xmm2,0x20(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm2
movss  0xc(%rdi,%rcx,1),%xmm1
unpcklps %xmm1,%xmm2
movss  0x18(%rdi,%rcx,1),%xmm1
movss  0x24(%rdi,%rcx,1),%xmm3
unpcklps %xmm3,%xmm1
movlhps %xmm1,%xmm2
movss  0x8(%rsi),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rcx,1)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movss  %xmm2,0x14(%rdx,%rcx,1)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movss  %xmm2,0x20(%rdx,%rcx,1)
movaps %xmm1,%xmm2
shufps $0xff,%xmm1,%xmm2
movss  %xmm2,0x2c(%rdx,%rcx,1)
movss  0x4(%rdi,%rcx,1),%xmm3
movss  0x10(%rdi,%rcx,1),%xmm2
unpcklps %xmm2,%xmm3
movss  0x1c(%rdi,%rcx,1),%xmm2
movss  0x28(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm2
movlhps %xmm2,%xmm3
movss  0x14(%rsi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movss  %xmm2,0x8(%rdx,%rcx,1)
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
movss  %xmm1,0x14(%rdx,%rcx,1)
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movss  %xmm1,0x20(%rdx,%rcx,1)
movaps %xmm2,%xmm1
shufps $0xff,%xmm2,%xmm1
movss  %xmm1,0x2c(%rdx,%rcx,1)
movss  0x8(%rdi,%rcx,1),%xmm1
movss  0x14(%rdi,%rcx,1),%xmm3
unpcklps %xmm3,%xmm1
movss  0x20(%rdi,%rcx,1),%xmm3
movss  0x2c(%rdi,%rcx,1),%xmm4
unpcklps %xmm4,%xmm3
movlhps %xmm3,%xmm1
movss  0x20(%rsi),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movss  %xmm3,0x8(%rdx,%rcx,1)
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
movss  %xmm1,0x14(%rdx,%rcx,1)
movaps %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
movss  %xmm1,0x20(%rdx,%rcx,1)
shufps $0xff,%xmm3,%xmm3
movss  %xmm3,0x2c(%rdx,%rcx,1)
add    $0x30,%rcx
cmp    %rcx,%r9
jne    1180 <multiply+0x80>
cmp    %rax,%r8
je     15eb <multiply+0x4eb>
lea    (%r8,%r8,2),%rcx
lea    0x8(,%rcx,4),%rcx
sub    %r8,%rax
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,-0x8(%rdx,%rcx,1)
movss  -0x8(%rdi,%rcx,1),%xmm1
mulss  (%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rcx,1)
movss  -0x4(%rdi,%rcx,1),%xmm2
mulss  0xc(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x8(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm1
mulss  0x18(%rsi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,-0x8(%rdx,%rcx,1)
movl   $0x0,-0x4(%rdx,%rcx,1)
movss  -0x8(%rdi,%rcx,1),%xmm1
mulss  0x4(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rcx,1)
movss  -0x4(%rdi,%rcx,1),%xmm2
mulss  0x10(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm1
mulss  0x1c(%rsi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,-0x4(%rdx,%rcx,1)
movl   $0x0,(%rdx,%rcx,1)
movss  -0x8(%rdi,%rcx,1),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,1)
movss  -0x4(%rdi,%rcx,1),%xmm2
mulss  0x14(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rcx,1)
movss  (%rdi,%rcx,1),%xmm1
mulss  0x20(%rsi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rdx,%rcx,1)
add    $0xc,%rcx
add    $0xffffffffffffffff,%rax
jne    1510 <multiply+0x410>
pop    %rbx
ret

LLVM IR (-O0):
define void @multiply([3 x float]* %0, [3 x float]* %1, [3 x float]* %2, i32 %3) {
%5 = alloca [3 x float]*
%6 = alloca [3 x float]*
%7 = alloca [3 x float]*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store [3 x float]* %0, [3 x float]** %5
store [3 x float]* %1, [3 x float]** %6
store [3 x float]* %2, [3 x float]** %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %12
12: ; preds = %65, %4
%13 = load i32, i32* %9
%14 = load i32, i32* %8
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %68
16: ; preds = %12
store i32 0, i32* %10
br label %17
17: ; preds = %61, %16
%18 = load i32, i32* %10
%19 = icmp slt i32 %18, 3
br i1 %19, label %20, label %64
20: ; preds = %17
%21 = load [3 x float]*, [3 x float]** %7
%22 = load i32, i32* %9
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 %23
%25 = load i32, i32* %10
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 %26
store float 0.000000e+00, float* %27
store i32 0, i32* %11
br label %28
28: ; preds = %57, %20
%29 = load i32, i32* %11
%30 = icmp slt i32 %29, 3
br i1 %30, label %31, label %60
31: ; preds = %28
%32 = load [3 x float]*, [3 x float]** %5
%33 = load i32, i32* %9
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 %34
%36 = load i32, i32* %11
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 %37
%39 = load float, float* %38
%40 = load [3 x float]*, [3 x float]** %6
%41 = load i32, i32* %11
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [3 x float], [3 x float]* %40, i64 %42
%44 = load i32, i32* %10
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [3 x float], [3 x float]* %43, i64 0, i64 %45
%47 = load float, float* %46
%48 = load [3 x float]*, [3 x float]** %7
%49 = load i32, i32* %9
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [3 x float], [3 x float]* %48, i64 %50
%52 = load i32, i32* %10
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [3 x float], [3 x float]* %51, i64 0, i64 %53
%55 = load float, float* %54
%56 = call float @llvm.fmuladd.f32(float %39, float %47, float %55)
store float %56, float* %54
br label %57
57: ; preds = %31
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
store i32 %59, i32* %11
br label %28
60: ; preds = %28
br label %61
61: ; preds = %60
%62 = load i32, i32* %10
%63 = add nsw i32 %62, 1
store i32 %63, i32* %10
br label %17
64: ; preds = %17
br label %65
65: ; preds = %64
%66 = load i32, i32* %9
%67 = add nsw i32 %66, 1
store i32 %67, i32* %9
br label %12
68: ; preds = %12
ret void
}

LLVM IR (-O2):
define void @multiply([3 x float]* nocapture %0, [3 x float]* nocapture %1, [3 x float]* nocapture %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %247
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 0
%9 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 1, i64 0
%10 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 2, i64 0
%11 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 1
%12 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 1, i64 1
%13 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 2, i64 1
%14 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 2
%15 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 1, i64 2
%16 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 2, i64 2
%17 = icmp ult i32 %3, 4
br i1 %17, label %208, label %18
18: ; preds = %6
%19 = getelementptr [3 x float], [3 x float]* %2, i64 %7, i64 0
%20 = getelementptr [3 x float], [3 x float]* %0, i64 %7, i64 0
%21 = getelementptr [3 x float], [3 x float]* %1, i64 3, i64 0
%22 = bitcast float* %20 to [3 x float]*
%23 = icmp ugt [3 x float]* %22, %2
%24 = bitcast float* %19 to [3 x float]*
%25 = icmp ugt [3 x float]* %24, %0
%26 = and i1 %23, %25
%27 = bitcast float* %21 to [3 x float]*
%28 = icmp ugt [3 x float]* %27, %2
%29 = bitcast float* %19 to [3 x float]*
%30 = icmp ugt [3 x float]* %29, %1
%31 = and i1 %28, %30
%32 = or i1 %26, %31
br i1 %32, label %208, label %33
33: ; preds = %18
%34 = and i64 %7, 4294967292
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %204, %35 ]
%37 = or i64 %36, 1
%38 = or i64 %36, 2
%39 = or i64 %36, 3
%40 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %36, i64 0
%41 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %37, i64 0
%42 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %38, i64 0
%43 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %39, i64 0
%44 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %36, i64 0
%45 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %37, i64 0
%46 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %38, i64 0
%47 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %39, i64 0
store float 0.000000e+00, float* %44
store float 0.000000e+00, float* %45
store float 0.000000e+00, float* %46
store float 0.000000e+00, float* %47
%48 = load float, float* %40
%49 = load float, float* %41
%50 = load float, float* %42
%51 = load float, float* %43
%52 = insertelement <4 x float> poison, float %48, i64 0
%53 = insertelement <4 x float> %52, float %49, i64 1
%54 = insertelement <4 x float> %53, float %50, i64 2
%55 = insertelement <4 x float> %54, float %51, i64 3
%56 = load float, float* %8
%57 = insertelement <4 x float> poison, float %56, i64 0
%58 = shufflevector <4 x float> %57, <4 x float> poison, <4 x i32> zeroinitializer
%59 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %55, <4 x float> %58, <4 x float> zeroinitializer)
%60 = extractelement <4 x float> %59, i64 0
store float %60, float* %44
%61 = extractelement <4 x float> %59, i64 1
store float %61, float* %45
%62 = extractelement <4 x float> %59, i64 2
store float %62, float* %46
%63 = extractelement <4 x float> %59, i64 3
store float %63, float* %47
%64 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %36, i64 1
%65 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %37, i64 1
%66 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %38, i64 1
%67 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %39, i64 1
%68 = load float, float* %64
%69 = load float, float* %65
%70 = load float, float* %66
%71 = load float, float* %67
%72 = insertelement <4 x float> poison, float %68, i64 0
%73 = insertelement <4 x float> %72, float %69, i64 1
%74 = insertelement <4 x float> %73, float %70, i64 2
%75 = insertelement <4 x float> %74, float %71, i64 3
%76 = load float, float* %9
%77 = insertelement <4 x float> poison, float %76, i64 0
%78 = shufflevector <4 x float> %77, <4 x float> poison, <4 x i32> zeroinitializer
%79 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %75, <4 x float> %78, <4 x float> %59)
%80 = extractelement <4 x float> %79, i64 0
store float %80, float* %44
%81 = extractelement <4 x float> %79, i64 1
store float %81, float* %45
%82 = extractelement <4 x float> %79, i64 2
store float %82, float* %46
%83 = extractelement <4 x float> %79, i64 3
store float %83, float* %47
%84 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %36, i64 2
%85 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %37, i64 2
%86 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %38, i64 2
%87 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %39, i64 2
%88 = load float, float* %84
%89 = load float, float* %85
%90 = load float, float* %86
%91 = load float, float* %87
%92 = insertelement <4 x float> poison, float %88, i64 0
%93 = insertelement <4 x float> %92, float %89, i64 1
%94 = insertelement <4 x float> %93, float %90, i64 2
%95 = insertelement <4 x float> %94, float %91, i64 3
%96 = load float, float* %10
%97 = insertelement <4 x float> poison, float %96, 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> %95, <4 x float> %98, <4 x float> %79)
%100 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %36, i64 1
%101 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %37, i64 1
%102 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %38, i64 1
%103 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %39, i64 1
store float 0.000000e+00, float* %100
store float 0.000000e+00, float* %101
store float 0.000000e+00, float* %102
store float 0.000000e+00, float* %103
%104 = load float, float* %40
%105 = load float, float* %41
%106 = load float, float* %42
%107 = load float, float* %43
%108 = insertelement <4 x float> poison, float %104, i64 0
%109 = insertelement <4 x float> %108, float %105, i64 1
%110 = insertelement <4 x float> %109, float %106, i64 2
%111 = insertelement <4 x float> %110, float %107, i64 3
%112 = load float, float* %11
%113 = insertelement <4 x float> poison, float %112, i64 0
%114 = shufflevector <4 x float> %113, <4 x float> poison, <4 x i32> zeroinitializer
%115 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %111, <4 x float> %114, <4 x float> zeroinitializer)
%116 = extractelement <4 x float> %115, i64 0
store float %116, float* %100
%117 = extractelement <4 x float> %115, i64 1
store float %117, float* %101
%118 = extractelement <4 x float> %115, i64 2
store float %118, float* %102
%119 = extractelement <4 x float> %115, i64 3
store float %119, float* %103
%120 = load float, float* %64
%121 = load float, float* %65
%122 = load float, float* %66
%123 = load float, float* %67
%124 = insertelement <4 x float> poison, float %120, i64 0
%125 = insertelement <4 x float> %124, float %121, i64 1
%126 = insertelement <4 x float> %125, float %122, i64 2
%127 = insertelement <4 x float> %126, float %123, i64 3
%128 = load float, float* %12
%129 = insertelement <4 x float> poison, float %128, i64 0
%130 = shufflevector <4 x float> %129, <4 x float> poison, <4 x i32> zeroinitializer
%131 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %127, <4 x float> %130, <4 x float> %115)
%132 = extractelement <4 x float> %131, i64 0
store float %132, float* %100
%133 = extractelement <4 x float> %131, i64 1
store float %133, float* %101
%134 = extractelement <4 x float> %131, i64 2
store float %134, float* %102
%135 = extractelement <4 x float> %131, i64 3
store float %135, float* %103
%136 = load float, float* %84
%137 = load float, float* %85
%138 = load float, float* %86
%139 = load float, float* %87
%140 = insertelement <4 x float> poison, float %136, i64 0
%141 = insertelement <4 x float> %140, float %137, i64 1
%142 = insertelement <4 x float> %141, float %138, i64 2
%143 = insertelement <4 x float> %142, float %139, i64 3
%144 = load float, float* %13
%145 = insertelement <4 x float> poison, float %144, i64 0
%146 = shufflevector <4 x float> %145, <4 x float> poison, <4 x i32> zeroinitializer
%147 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %143, <4 x float> %146, <4 x float> %131)
%148 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %36, i64 2
%149 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %37, i64 2
%150 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %38, i64 2
%151 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %39, i64 2
%152 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %36, i64 0
%153 = bitcast float* %152 to <12 x float>*
%154 = shufflevector <4 x float> %99, <4 x float> %147, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%155 = shufflevector <8 x float> %154, <8 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float poison, float poison, float poison, float poison>, <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> %155, <12 x float>* %153
%156 = load float, float* %40
%157 = load float, float* %41
%158 = load float, float* %42
%159 = load float, float* %43
%160 = insertelement <4 x float> poison, float %156, i64 0
%161 = insertelement <4 x float> %160, float %157, i64 1
%162 = insertelement <4 x float> %161, float %158, i64 2
%163 = insertelement <4 x float> %162, float %159, i64 3
%164 = load float, float* %14
%165 = insertelement <4 x float> poison, float %164, i64 0
%166 = shufflevector <4 x float> %165, <4 x float> poison, <4 x i32> zeroinitializer
%167 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %163, <4 x float> %166, <4 x float> zeroinitializer)
%168 = extractelement <4 x float> %167, i64 0
store float %168, float* %148
%169 = extractelement <4 x float> %167, i64 1
store float %169, float* %149
%170 = extractelement <4 x float> %167, i64 2
store float %170, float* %150
%171 = extractelement <4 x float> %167, i64 3
store float %171, float* %151
%172 = load float, float* %64
%173 = load float, float* %65
%174 = load float, float* %66
%175 = load float, float* %67
%176 = insertelement <4 x float> poison, float %172, i64 0
%177 = insertelement <4 x float> %176, float %173, i64 1
%178 = insertelement <4 x float> %177, float %174, i64 2
%179 = insertelement <4 x float> %178, float %175, i64 3
%180 = load float, float* %15
%181 = insertelement <4 x float> poison, float %180, i64 0
%182 = shufflevector <4 x float> %181, <4 x float> poison, <4 x i32> zeroinitializer
%183 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %179, <4 x float> %182, <4 x float> %167)
%184 = extractelement <4 x float> %183, i64 0
store float %184, float* %148
%185 = extractelement <4 x float> %183, i64 1
store float %185, float* %149
%186 = extractelement <4 x float> %183, i64 2
store float %186, float* %150
%187 = extractelement <4 x float> %183, i64 3
store float %187, float* %151
%188 = load float, float* %84
%189 = load float, float* %85
%190 = load float, float* %86
%191 = load float, float* %87
%192 = insertelement <4 x float> poison, float %188, i64 0
%193 = insertelement <4 x float> %192, float %189, i64 1
%194 = insertelement <4 x float> %193, float %190, i64 2
%195 = insertelement <4 x float> %194, float %191, i64 3
%196 = load float, float* %16
%197 = insertelement <4 x float> poison, float %196, i64 0
%198 = shufflevector <4 x float> %197, <4 x float> poison, <4 x i32> zeroinitializer
%199 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %195, <4 x float> %198, <4 x float> %183)
%200 = extractelement <4 x float> %199, i64 0
store float %200, float* %148
%201 = extractelement <4 x float> %199, i64 1
store float %201, float* %149
%202 = extractelement <4 x float> %199, i64 2
store float %202, float* %150
%203 = extractelement <4 x float> %199, i64 3
store float %203, float* %151
%204 = add nuw i64 %36, 4
%205 = icmp eq i64 %204, %34
br i1 %205, label %206, label %35
206: ; preds = %35
%207 = icmp eq i64 %34, %7
br i1 %207, label %247, label %208
208: ; preds = %18, %6, %206
%209 = phi i64 [ 0, %18 ], [ 0, %6 ], [ %34, %206 ]
br label %210
210: ; preds = %208, %210
%211 = phi i64 [ %245, %210 ], [ %209, %208 ]
%212 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %211, i64 0
%213 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %211, i64 0
store float 0.000000e+00, float* %213
%214 = load float, float* %212
%215 = load float, float* %8
%216 = tail call float @llvm.fmuladd.f32(float %214, float %215, float 0.000000e+00)
store float %216, float* %213
%217 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %211, i64 1
%218 = load float, float* %217
%219 = load float, float* %9
%220 = tail call float @llvm.fmuladd.f32(float %218, float %219, float %216)
store float %220, float* %213
%221 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 %211, i64 2
%222 = load float, float* %221
%223 = load float, float* %10
%224 = tail call float @llvm.fmuladd.f32(float %222, float %223, float %220)
store float %224, float* %213
%225 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %211, i64 1
store float 0.000000e+00, float* %225
%226 = load float, float* %212
%227 = load float, float* %11
%228 = tail call float @llvm.fmuladd.f32(float %226, float %227, float 0.000000e+00)
store float %228, float* %225
%229 = load float, float* %217
%230 = load float, float* %12
%231 = tail call float @llvm.fmuladd.f32(float %229, float %230, float %228)
store float %231, float* %225
%232 = load float, float* %221
%233 = load float, float* %13
%234 = tail call float @llvm.fmuladd.f32(float %232, float %233, float %231)
store float %234, float* %225
%235 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 %211, i64 2
store float 0.000000e+00, float* %235
%236 = load float, float* %212
%237 = load float, float* %14
%238 = tail call float @llvm.fmuladd.f32(float %236, float %237, float 0.000000e+00)
store float %238, float* %235
%239 = load float, float* %217
%240 = load float, float* %15
%241 = tail call float @llvm.fmuladd.f32(float %239, float %240, float %238)
store float %241, float* %235
%242 = load float, float* %221
%243 = load float, float* %16
%244 = tail call float @llvm.fmuladd.f32(float %242, float %243, float %241)
store float %244, float* %235
%245 = add nuw nsw i64 %211, 1
%246 = icmp eq i64 %245, %7
br i1 %246, label %247, label %210
247: ; preds = %210, %206, %4
ret void
}