#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 */

/* Variables and functions */
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
void m44mulf_affine(const float a[16], const float *b, int ncols, float *out) {
  int i, j, k;
  const float *rowa, *colb;
  float *rowdest;
  memset(out, 0, sizeof(float) * 3 * ncols);
  for (i = 0; i < 3; i++) {
    rowa = a + i * 4;
    rowdest = out + i * ncols;
    for (j = 0; j < 3; j++) {
      for (k = 0; k < ncols; k++) {
        colb = b + k;
        rowdest[k] += rowa[j] * colb[ncols * j];
      }
    }
    for (k = 0; k < ncols; k++)
      rowdest[k] += rowa[j];
  }
}


x86 assembly (clang, -O0):
<m44mulf_affine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x14(%rbp),%rax
imul   $0xc,%rax,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    1263 <m44mulf_affine+0x153>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1210 <m44mulf_affine+0x100>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11fd <m44mulf_affine+0xed>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1196 <m44mulf_affine+0x86>
jmp    1202 <m44mulf_affine+0xf2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1185 <m44mulf_affine+0x75>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1250 <m44mulf_affine+0x140>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1217 <m44mulf_affine+0x107>
jmp    1255 <m44mulf_affine+0x145>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1143 <m44mulf_affine+0x33>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m44mulf_affine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,%r14
mov    %edx,%ebp
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0x0(,%rbp,4),%eax
lea    (%rax,%rax,2),%edx
mov    %rcx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
xor    %edx,%edx
mov    %rbp,%r11
movslq %r11d,%rsi
mov    %esi,%r9d
lea    (%r12,%rsi,4),%r13
lea    (%r12,%rsi,8),%rcx
lea    (%r9,%rsi,2),%rax
lea    (%r12,%rax,4),%rax
mov    %rax,0x60(%rsp)
lea    (%rsi,%r9,1),%rax
lea    (%r12,%rax,4),%rax
mov    %rax,0x70(%rsp)
lea    (%r12,%r9,4),%rax
mov    %rax,0x78(%rsp)
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r9,%rax
neg    %rax
mov    %rax,0x40(%rsp)
mov    %rdi,%rax
mov    %rdi,0x50(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x48(%rsp)
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x68(%rsp)
lea    0x10(%r14),%rbp
lea    0x0(,%r9,4),%r8
and    $0xffffffffffffffe0,%r8
mov    %rsi,0x80(%rsp)
lea    0x0(,%rsi,4),%rax
mov    %rax,0x90(%rsp)
lea    0x4(%r14),%r10
mov    %r14,0x88(%rsp)
mov    %r11,(%rsp)
mov    %rcx,0x28(%rsp)
jmp    121f <m44mulf_affine+0x10f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    0x90(%rsp),%rax
add    %rax,%rbp
add    %rax,%r10
add    %rax,%r14
cmp    $0x3,%rdx
je     17d3 <m44mulf_affine+0x6c3>
test   %r11d,%r11d
jle    1200 <m44mulf_affine+0xf0>
mov    %rdx,%rsi
imul   0x80(%rsp),%rsi
lea    0x0(,%rdx,4),%rax
mov    %rdx,0x10(%rsp)
shl    $0x4,%rdx
mov    0x88(%rsp),%rdi
lea    (%rdi,%rsi,4),%rcx
add    %r9,%rsi
lea    (%rdi,%rsi,4),%rdi
lea    (%rbx,%rdx,1),%rsi
add    $0x4,%rsi
cmp    $0x8,%r11d
mov    %rcx,0x8(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x30(%rsp)
jae    1280 <m44mulf_affine+0x170>
xor    %r15d,%r15d
jmp    1320 <m44mulf_affine+0x210>
xchg   %ax,%ax
add    %rbx,%rdx
cmp    %rsi,%rcx
mov    %rcx,%rsi
setb   %r15b
cmp    %rdi,%rdx
setb   %cl
cmp    0x78(%rsp),%rsi
setb   %dl
cmp    %r12,%rdi
seta   %sil
test   %cl,%r15b
jne    1316 <m44mulf_affine+0x206>
mov    $0x0,%r15d
and    %sil,%dl
mov    (%rsp),%r11
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rcx
jne    132a <m44mulf_affine+0x21a>
movss  (%rbx,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%r12,%rdi,1),%xmm1
movups 0x10(%r12,%rdi,1),%xmm2
movups -0x10(%rbp,%rdi,1),%xmm3
movups 0x0(%rbp,%rdi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rbp,%rdi,1)
movups %xmm2,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    12d0 <m44mulf_affine+0x1c0>
mov    0x20(%rsp),%rsi
mov    %rsi,%r15
cmp    %r9,%rsi
jne    132a <m44mulf_affine+0x21a>
jmp    13aa <m44mulf_affine+0x29a>
xor    %r15d,%r15d
mov    (%rsp),%r11
nopl   (%rax)
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rcx
mov    %r15,%rdi
test   $0x1,%r9b
je     135b <m44mulf_affine+0x24b>
movss  (%rbx,%rax,4),%xmm0
mulss  (%r12,%r15,4),%xmm0
mov    0x8(%rsp),%rdx
addss  (%rdx,%r15,4),%xmm0
movss  %xmm0,(%rdx,%r15,4)
mov    0x10(%rsp),%rdx
mov    %r15,%rdi
or     $0x1,%rdi
not    %r15
cmp    0x40(%rsp),%r15
je     13aa <m44mulf_affine+0x29a>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm0
mulss  (%r12,%rdi,4),%xmm0
addss  -0x4(%r10,%rdi,4),%xmm0
movss  %xmm0,-0x4(%r10,%rdi,4)
movss  (%rbx,%rax,4),%xmm0
mulss  0x4(%r12,%rdi,4),%xmm0
addss  (%r10,%rdi,4),%xmm0
movss  %xmm0,(%r10,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1370 <m44mulf_affine+0x260>
test   %r11d,%r11d
mov    0x18(%rsp),%r15
jle    1200 <m44mulf_affine+0xf0>
lea    (%rbx,%r15,1),%rsi
add    $0x8,%rsi
cmp    $0x8,%r11d
mov    %rsi,0x10(%rsp)
jae    13d2 <m44mulf_affine+0x2c2>
xor    %esi,%esi
jmp    1480 <m44mulf_affine+0x370>
mov    0x8(%rsp),%rdi
cmp    %rsi,%rdi
setb   %sil
mov    0x38(%rsp),%r15
cmp    %r15,0x30(%rsp)
setb   %r11b
cmp    0x70(%rsp),%rdi
setb   %dil
cmp    %r15,%r13
setb   %r15b
test   %r11b,%sil
jne    1467 <m44mulf_affine+0x357>
mov    $0x0,%esi
and    %r15b,%dil
mov    (%rsp),%r11
mov    0x18(%rsp),%r15
jne    1480 <m44mulf_affine+0x370>
movss  0x4(%rbx,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
movups 0x0(%r13,%rsi,1),%xmm1
movups 0x10(%r13,%rsi,1),%xmm2
movups -0x10(%rbp,%rsi,1),%xmm3
movups 0x0(%rbp,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rbp,%rsi,1)
movups %xmm2,0x0(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1420 <m44mulf_affine+0x310>
mov    0x20(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r9,%rdi
jne    1480 <m44mulf_affine+0x370>
jmp    14fd <m44mulf_affine+0x3ed>
xor    %esi,%esi
mov    (%rsp),%r11
mov    0x18(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%rdi
test   $0x1,%r9b
je     14ac <m44mulf_affine+0x39c>
movss  0x4(%rbx,%rax,4),%xmm0
mulss  0x0(%r13,%rsi,4),%xmm0
mov    0x8(%rsp),%rdi
addss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rsi,4)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0x40(%rsp),%rsi
je     14fd <m44mulf_affine+0x3ed>
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%rbx,%rax,4),%xmm0
mulss  0x0(%r13,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0x4(%rbx,%rax,4),%xmm0
mulss  0x4(%r13,%rdi,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    14c0 <m44mulf_affine+0x3b0>
test   %r11d,%r11d
jle    1200 <m44mulf_affine+0xf0>
lea    (%rbx,%r15,1),%rsi
add    $0xc,%rsi
cmp    $0x8,%r11d
mov    %rsi,0x30(%rsp)
jae    1520 <m44mulf_affine+0x410>
xor    %esi,%esi
jmp    15c0 <m44mulf_affine+0x4b0>
mov    0x8(%rsp),%r15
cmp    %rsi,%r15
setb   %sil
mov    0x38(%rsp),%rdi
cmp    %rdi,0x10(%rsp)
setb   %r11b
cmp    0x60(%rsp),%r15
setb   %r15b
cmp    %rdi,%rcx
setb   %dil
test   %r11b,%sil
jne    15b4 <m44mulf_affine+0x4a4>
mov    $0x0,%esi
and    %dil,%r15b
mov    (%rsp),%r11
mov    0x18(%rsp),%r15
jne    15c0 <m44mulf_affine+0x4b0>
movss  0x8(%rbx,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
xchg   %ax,%ax
movups (%rcx,%rsi,1),%xmm1
movups 0x10(%rcx,%rsi,1),%xmm2
movups -0x10(%rbp,%rsi,1),%xmm3
movups 0x0(%rbp,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%rbp,%rsi,1)
movups %xmm2,0x0(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1570 <m44mulf_affine+0x460>
mov    0x20(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r9,%rdi
jne    15c0 <m44mulf_affine+0x4b0>
jmp    163a <m44mulf_affine+0x52a>
xor    %esi,%esi
mov    (%rsp),%r11
mov    0x18(%rsp),%r15
nop
mov    %rsi,%rdi
test   $0x1,%r9b
je     15ea <m44mulf_affine+0x4da>
movss  0x8(%rbx,%rax,4),%xmm0
mulss  (%rcx,%rsi,4),%xmm0
mov    0x8(%rsp),%rdi
addss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdi,%rsi,4)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0x40(%rsp),%rsi
je     163a <m44mulf_affine+0x52a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x8(%rbx,%rax,4),%xmm0
mulss  (%rcx,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0x8(%rbx,%rax,4),%xmm0
mulss  0x4(%rcx,%rdi,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%r9
jne    1600 <m44mulf_affine+0x4f0>
test   %r11d,%r11d
jle    1200 <m44mulf_affine+0xf0>
cmp    $0x8,%r11d
jb     166c <m44mulf_affine+0x55c>
lea    (%rbx,%r15,1),%rsi
add    $0x10,%rsi
cmp    %rsi,0x8(%rsp)
jae    171c <m44mulf_affine+0x60c>
mov    0x30(%rsp),%rsi
cmp    0x38(%rsp),%rsi
jae    171c <m44mulf_affine+0x60c>
xor    %edi,%edi
mov    %rdi,%r11
not    %r11
add    %r9,%r11
mov    0x68(%rsp),%rsi
test   %rsi,%rsi
je     16ac <m44mulf_affine+0x59c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0xc(%rbx,%rax,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1690 <m44mulf_affine+0x580>
cmp    $0x3,%r11
mov    (%rsp),%r11
jb     1200 <m44mulf_affine+0xf0>
nopw   0x0(%rax,%rax,1)
movss  0xc(%rbx,%rax,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0xc(%rbx,%rax,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
movss  0xc(%rbx,%rax,4),%xmm0
addss  0x8(%r14,%rdi,4),%xmm0
movss  %xmm0,0x8(%r14,%rdi,4)
movss  0xc(%rbx,%rax,4),%xmm0
addss  0xc(%r14,%rdi,4),%xmm0
movss  %xmm0,0xc(%r14,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r9
jne    16c0 <m44mulf_affine+0x5b0>
jmp    1200 <m44mulf_affine+0xf0>
cmpq   $0x0,0x58(%rsp)
je     17c8 <m44mulf_affine+0x6b8>
movss  0xc(%rbx,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x48(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%r14,%rdi,4),%xmm1
movups 0x10(%r14,%rdi,4),%xmm2
movups 0x20(%r14,%rdi,4),%xmm3
movups 0x30(%r14,%rdi,4),%xmm4
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,(%r14,%rdi,4)
movups %xmm2,0x10(%r14,%rdi,4)
addps  %xmm0,%xmm3
addps  %xmm0,%xmm4
movups %xmm3,0x20(%r14,%rdi,4)
movups %xmm4,0x30(%r14,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1740 <m44mulf_affine+0x630>
testb  $0x1,0x50(%rsp)
je     17b2 <m44mulf_affine+0x6a2>
movss  0xc(%rbx,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x8(%rsp),%rsi
movups (%rsi,%rdi,4),%xmm1
movups 0x10(%rsi,%rdi,4),%xmm2
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,(%rsi,%rdi,4)
movups %xmm2,0x10(%rsi,%rdi,4)
mov    0x20(%rsp),%rsi
mov    %rsi,%rdi
cmp    %r9,%rsi
je     1200 <m44mulf_affine+0xf0>
jmp    166e <m44mulf_affine+0x55e>
xor    %edi,%edi
testb  $0x1,0x50(%rsp)
jne    178b <m44mulf_affine+0x67b>
jmp    17b2 <m44mulf_affine+0x6a2>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @m44mulf_affine(float* %0, float* %1, i32 %2, float* %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
store float* %0, float** %5
store float* %1, float** %6
store i32 %2, i32* %7
store float* %3, float** %8
%15 = load float*, float** %8
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = mul i64 12, %17
%19 = trunc i64 %18 to i32
%20 = call i32 @memset(float* %15, i32 0, i32 %19)
store i32 0, i32* %9
br label %21
21: ; preds = %95, %4
%22 = load i32, i32* %9
%23 = icmp slt i32 %22, 3
br i1 %23, label %24, label %98
24: ; preds = %21
%25 = load float*, float** %5
%26 = load i32, i32* %9
%27 = mul nsw i32 %26, 4
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %25, i64 %28
store float* %29, float** %12
%30 = load float*, float** %8
%31 = load i32, i32* %9
%32 = load i32, i32* %7
%33 = mul nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %30, i64 %34
store float* %35, float** %14
store i32 0, i32* %10
br label %36
36: ; preds = %71, %24
%37 = load i32, i32* %10
%38 = icmp slt i32 %37, 3
br i1 %38, label %39, label %74
39: ; preds = %36
store i32 0, i32* %11
br label %40
40: ; preds = %67, %39
%41 = load i32, i32* %11
%42 = load i32, i32* %7
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %70
44: ; preds = %40
%45 = load float*, float** %6
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
store float* %48, float** %13
%49 = load float*, float** %12
%50 = load i32, i32* %10
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
%53 = load float, float* %52
%54 = load float*, float** %13
%55 = load i32, i32* %7
%56 = load i32, i32* %10
%57 = mul nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %54, i64 %58
%60 = load float, float* %59
%61 = load float*, float** %14
%62 = load i32, i32* %11
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %61, i64 %63
%65 = load float, float* %64
%66 = call float @llvm.fmuladd.f32(float %53, float %60, float %65)
store float %66, float* %64
br label %67
67: ; preds = %44
%68 = load i32, i32* %11
%69 = add nsw i32 %68, 1
store i32 %69, i32* %11
br label %40
70: ; preds = %40
br label %71
71: ; preds = %70
%72 = load i32, i32* %10
%73 = add nsw i32 %72, 1
store i32 %73, i32* %10
br label %36
74: ; preds = %36
store i32 0, i32* %11
br label %75
75: ; preds = %91, %74
%76 = load i32, i32* %11
%77 = load i32, i32* %7
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %94
79: ; preds = %75
%80 = load float*, float** %12
%81 = load i32, i32* %10
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = load float*, float** %14
%86 = load i32, i32* %11
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %85, i64 %87
%89 = load float, float* %88
%90 = fadd float %89, %84
store float %90, float* %88
br label %91
91: ; preds = %79
%92 = load i32, i32* %11
%93 = add nsw i32 %92, 1
store i32 %93, i32* %11
br label %75
94: ; preds = %75
br label %95
95: ; preds = %94
%96 = load i32, i32* %9
%97 = add nsw i32 %96, 1
store i32 %97, i32* %9
br label %21
98: ; preds = %21
ret void
}

LLVM IR (-O2):
define void @m44mulf_affine(float* nocapture %0, float* nocapture %1, i32 %2, float* %3) {
%5 = mul i32 %2, 12
%6 = tail call i32 @memset(float* %3, i32 0, i32 %5)
%7 = icmp sgt i32 %2, 0
%8 = sext i32 %2 to i64
%9 = zext i32 %2 to i64
%10 = zext i32 %2 to i64
%11 = getelementptr float, float* %1, i64 %8
%12 = shl nsw i64 %8, 1
%13 = zext i32 %2 to i64
%14 = getelementptr float, float* %1, i64 %12
%15 = zext i32 %2 to i64
%16 = add nsw i64 %12, %9
%17 = getelementptr float, float* %1, i64 %16
%18 = add nsw i64 %8, %9
%19 = getelementptr float, float* %1, i64 %18
%20 = getelementptr float, float* %1, i64 %9
%21 = and i64 %9, 4294967288
%22 = add nsw i64 %21, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = icmp ult i32 %2, 8
%26 = and i64 %9, 4294967288
%27 = icmp eq i64 %26, %9
%28 = and i64 %9, 1
%29 = icmp eq i64 %28, 0
%30 = sub nsw i64 0, %9
%31 = icmp ult i32 %2, 8
%32 = and i64 %9, 4294967288
%33 = icmp eq i64 %32, %9
%34 = and i64 %9, 1
%35 = icmp eq i64 %34, 0
%36 = sub nsw i64 0, %9
%37 = icmp ult i32 %2, 8
%38 = and i64 %9, 4294967288
%39 = icmp eq i64 %38, %9
%40 = and i64 %9, 1
%41 = icmp eq i64 %40, 0
%42 = sub nsw i64 0, %9
%43 = icmp ult i32 %2, 8
%44 = and i64 %9, 4294967288
%45 = and i64 %24, 1
%46 = icmp eq i64 %22, 0
%47 = and i64 %24, 4611686018427387902
%48 = icmp eq i64 %45, 0
%49 = icmp eq i64 %44, %9
%50 = and i64 %9, 3
%51 = icmp eq i64 %50, 0
br label %52
52: ; preds = %4, %403
%53 = phi i64 [ 0, %4 ], [ %404, %403 ]
%54 = mul i64 %53, %8
%55 = getelementptr float, float* %3, i64 %54
%56 = add i64 %54, %9
%57 = getelementptr float, float* %3, i64 %56
%58 = shl nuw nsw i64 %53, 2
%59 = getelementptr float, float* %0, i64 %58
%60 = or i64 %58, 1
%61 = getelementptr float, float* %0, i64 %60
%62 = mul i64 %53, %8
%63 = getelementptr float, float* %3, i64 %62
%64 = add i64 %62, %9
%65 = getelementptr float, float* %3, i64 %64
%66 = shl nuw nsw i64 %53, 2
%67 = or i64 %66, 1
%68 = getelementptr float, float* %0, i64 %67
%69 = or i64 %66, 2
%70 = getelementptr float, float* %0, i64 %69
%71 = mul i64 %53, %8
%72 = getelementptr float, float* %3, i64 %71
%73 = add i64 %71, %9
%74 = getelementptr float, float* %3, i64 %73
%75 = shl nuw nsw i64 %53, 2
%76 = or i64 %75, 2
%77 = getelementptr float, float* %0, i64 %76
%78 = or i64 %75, 3
%79 = getelementptr float, float* %0, i64 %78
%80 = mul i64 %53, %8
%81 = getelementptr float, float* %3, i64 %80
%82 = add i64 %80, %9
%83 = getelementptr float, float* %3, i64 %82
%84 = shl nuw nsw i64 %53, 2
%85 = or i64 %84, 3
%86 = getelementptr float, float* %0, i64 %85
%87 = add nuw i64 %84, 4
%88 = getelementptr float, float* %0, i64 %87
%89 = shl nuw nsw i64 %53, 2
%90 = getelementptr inbounds float, float* %0, i64 %89
%91 = mul nsw i64 %53, %8
%92 = getelementptr inbounds float, float* %3, i64 %91
br i1 %7, label %93, label %403
93: ; preds = %52
br i1 %25, label %129, label %94
94: ; preds = %93
%95 = icmp ult float* %55, %61
%96 = icmp ult float* %59, %57
%97 = and i1 %95, %96
%98 = icmp ult float* %55, %20
%99 = icmp ugt float* %57, %1
%100 = and i1 %98, %99
%101 = or i1 %97, %100
br i1 %101, label %129, label %102
102: ; preds = %94
%103 = load float, float* %90
%104 = insertelement <4 x float> poison, float %103, i64 0
%105 = shufflevector <4 x float> %104, <4 x float> poison, <4 x i32> zeroinitializer
%106 = insertelement <4 x float> poison, float %103, i64 0
%107 = shufflevector <4 x float> %106, <4 x float> poison, <4 x i32> zeroinitializer
br label %108
108: ; preds = %108, %102
%109 = phi i64 [ 0, %102 ], [ %126, %108 ]
%110 = getelementptr inbounds float, float* %1, i64 %109
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = getelementptr inbounds float, float* %110, i64 4
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = getelementptr inbounds float, float* %92, i64 %109
%117 = bitcast float* %116 to <4 x float>*
%118 = load <4 x float>, <4 x float>* %117
%119 = getelementptr inbounds float, float* %116, i64 4
%120 = bitcast float* %119 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %105, <4 x float> %112, <4 x float> %118)
%123 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %115, <4 x float> %121)
%124 = bitcast float* %116 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = bitcast float* %119 to <4 x float>*
store <4 x float> %123, <4 x float>* %125
%126 = add nuw i64 %109, 8
%127 = icmp eq i64 %126, %26
br i1 %127, label %128, label %108
128: ; preds = %108
br i1 %27, label %241, label %129
129: ; preds = %94, %93, %128
%130 = phi i64 [ 0, %94 ], [ 0, %93 ], [ %26, %128 ]
%131 = xor i64 %130, -1
br i1 %29, label %140, label %132
132: ; preds = %129
%133 = getelementptr inbounds float, float* %1, i64 %130
%134 = load float, float* %90
%135 = load float, float* %133
%136 = getelementptr inbounds float, float* %92, i64 %130
%137 = load float, float* %136
%138 = tail call float @llvm.fmuladd.f32(float %134, float %135, float %137)
store float %138, float* %136
%139 = or i64 %130, 1
br label %140
140: ; preds = %132, %129
%141 = phi i64 [ %130, %129 ], [ %139, %132 ]
%142 = icmp eq i64 %131, %30
br i1 %142, label %241, label %224
143: ; preds = %379
%144 = getelementptr inbounds float, float* %90, i64 3
br i1 %43, label %207, label %145
145: ; preds = %143
%146 = icmp ult float* %81, %88
%147 = icmp ult float* %86, %83
%148 = and i1 %146, %147
br i1 %148, label %207, label %149
149: ; preds = %145
br i1 %46, label %188, label %150
150: ; preds = %149
%151 = load float, float* %144
%152 = insertelement <4 x float> poison, float %151, i64 0
%153 = shufflevector <4 x float> %152, <4 x float> poison, <4 x i32> zeroinitializer
%154 = insertelement <4 x float> poison, float %151, i64 0
%155 = shufflevector <4 x float> %154, <4 x float> poison, <4 x i32> zeroinitializer
%156 = load float, float* %144
%157 = insertelement <4 x float> poison, float %156, i64 0
%158 = shufflevector <4 x float> %157, <4 x float> poison, <4 x i32> zeroinitializer
%159 = insertelement <4 x float> poison, float %156, i64 0
%160 = shufflevector <4 x float> %159, <4 x float> poison, <4 x i32> zeroinitializer
br label %161
161: ; preds = %161, %150
%162 = phi i64 [ 0, %150 ], [ %185, %161 ]
%163 = phi i64 [ 0, %150 ], [ %186, %161 ]
%164 = getelementptr inbounds float, float* %92, i64 %162
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = getelementptr inbounds float, float* %164, i64 4
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = fadd <4 x float> %153, %166
%171 = fadd <4 x float> %155, %169
%172 = bitcast float* %164 to <4 x float>*
store <4 x float> %170, <4 x float>* %172
%173 = bitcast float* %167 to <4 x float>*
store <4 x float> %171, <4 x float>* %173
%174 = or i64 %162, 8
%175 = getelementptr inbounds float, float* %92, i64 %174
%176 = bitcast float* %175 to <4 x float>*
%177 = load <4 x float>, <4 x float>* %176
%178 = getelementptr inbounds float, float* %175, i64 4
%179 = bitcast float* %178 to <4 x float>*
%180 = load <4 x float>, <4 x float>* %179
%181 = fadd <4 x float> %158, %177
%182 = fadd <4 x float> %160, %180
%183 = bitcast float* %175 to <4 x float>*
store <4 x float> %181, <4 x float>* %183
%184 = bitcast float* %178 to <4 x float>*
store <4 x float> %182, <4 x float>* %184
%185 = add nuw i64 %162, 16
%186 = add i64 %163, 2
%187 = icmp eq i64 %186, %47
br i1 %187, label %188, label %161
188: ; preds = %161, %149
%189 = phi i64 [ 0, %149 ], [ %185, %161 ]
br i1 %48, label %206, label %190
190: ; preds = %188
%191 = load float, float* %144
%192 = insertelement <4 x float> poison, float %191, i64 0
%193 = shufflevector <4 x float> %192, <4 x float> poison, <4 x i32> zeroinitializer
%194 = insertelement <4 x float> poison, float %191, i64 0
%195 = shufflevector <4 x float> %194, <4 x float> poison, <4 x i32> zeroinitializer
%196 = getelementptr inbounds float, float* %92, i64 %189
%197 = bitcast float* %196 to <4 x float>*
%198 = load <4 x float>, <4 x float>* %197
%199 = getelementptr inbounds float, float* %196, i64 4
%200 = bitcast float* %199 to <4 x float>*
%201 = load <4 x float>, <4 x float>* %200
%202 = fadd <4 x float> %193, %198
%203 = fadd <4 x float> %195, %201
%204 = bitcast float* %196 to <4 x float>*
store <4 x float> %202, <4 x float>* %204
%205 = bitcast float* %199 to <4 x float>*
store <4 x float> %203, <4 x float>* %205
br label %206
206: ; preds = %188, %190
br i1 %49, label %403, label %207
207: ; preds = %145, %143, %206
%208 = phi i64 [ 0, %145 ], [ 0, %143 ], [ %44, %206 ]
%209 = xor i64 %208, -1
%210 = add nsw i64 %209, %9
br i1 %51, label %221, label %211
211: ; preds = %207, %211
%212 = phi i64 [ %218, %211 ], [ %208, %207 ]
%213 = phi i64 [ %219, %211 ], [ 0, %207 ]
%214 = load float, float* %144
%215 = getelementptr inbounds float, float* %92, i64 %212
%216 = load float, float* %215
%217 = fadd float %214, %216
store float %217, float* %215
%218 = add nuw nsw i64 %212, 1
%219 = add i64 %213, 1
%220 = icmp eq i64 %219, %50
br i1 %220, label %221, label %211
221: ; preds = %211, %207
%222 = phi i64 [ %208, %207 ], [ %218, %211 ]
%223 = icmp ult i64 %210, 3
br i1 %223, label %403, label %380
224: ; preds = %140, %224
%225 = phi i64 [ %239, %224 ], [ %141, %140 ]
%226 = getelementptr inbounds float, float* %1, i64 %225
%227 = load float, float* %90
%228 = load float, float* %226
%229 = getelementptr inbounds float, float* %92, i64 %225
%230 = load float, float* %229
%231 = tail call float @llvm.fmuladd.f32(float %227, float %228, float %230)
store float %231, float* %229
%232 = add nuw nsw i64 %225, 1
%233 = getelementptr inbounds float, float* %1, i64 %232
%234 = load float, float* %90
%235 = load float, float* %233
%236 = getelementptr inbounds float, float* %92, i64 %232
%237 = load float, float* %236
%238 = tail call float @llvm.fmuladd.f32(float %234, float %235, float %237)
store float %238, float* %236
%239 = add nuw nsw i64 %225, 2
%240 = icmp eq i64 %239, %9
br i1 %240, label %241, label %224
241: ; preds = %140, %224, %128
br i1 %7, label %242, label %403
242: ; preds = %241
%243 = getelementptr inbounds float, float* %90, i64 1
br i1 %31, label %279, label %244
244: ; preds = %242
%245 = icmp ult float* %63, %70
%246 = icmp ult float* %68, %65
%247 = and i1 %245, %246
%248 = icmp ult float* %63, %19
%249 = icmp ult float* %11, %65
%250 = and i1 %248, %249
%251 = or i1 %247, %250
br i1 %251, label %279, label %252
252: ; preds = %244
%253 = load float, float* %243
%254 = insertelement <4 x float> poison, float %253, i64 0
%255 = shufflevector <4 x float> %254, <4 x float> poison, <4 x i32> zeroinitializer
%256 = insertelement <4 x float> poison, float %253, i64 0
%257 = shufflevector <4 x float> %256, <4 x float> poison, <4 x i32> zeroinitializer
br label %258
258: ; preds = %258, %252
%259 = phi i64 [ 0, %252 ], [ %276, %258 ]
%260 = getelementptr inbounds float, float* %11, i64 %259
%261 = bitcast float* %260 to <4 x float>*
%262 = load <4 x float>, <4 x float>* %261
%263 = getelementptr inbounds float, float* %260, i64 4
%264 = bitcast float* %263 to <4 x float>*
%265 = load <4 x float>, <4 x float>* %264
%266 = getelementptr inbounds float, float* %92, i64 %259
%267 = bitcast float* %266 to <4 x float>*
%268 = load <4 x float>, <4 x float>* %267
%269 = getelementptr inbounds float, float* %266, i64 4
%270 = bitcast float* %269 to <4 x float>*
%271 = load <4 x float>, <4 x float>* %270
%272 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %255, <4 x float> %262, <4 x float> %268)
%273 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %257, <4 x float> %265, <4 x float> %271)
%274 = bitcast float* %266 to <4 x float>*
store <4 x float> %272, <4 x float>* %274
%275 = bitcast float* %269 to <4 x float>*
store <4 x float> %273, <4 x float>* %275
%276 = add nuw i64 %259, 8
%277 = icmp eq i64 %276, %32
br i1 %277, label %278, label %258
278: ; preds = %258
br i1 %33, label %310, label %279
279: ; preds = %244, %242, %278
%280 = phi i64 [ 0, %244 ], [ 0, %242 ], [ %32, %278 ]
%281 = xor i64 %280, -1
br i1 %35, label %290, label %282
282: ; preds = %279
%283 = load float, float* %243
%284 = getelementptr inbounds float, float* %11, i64 %280
%285 = load float, float* %284
%286 = getelementptr inbounds float, float* %92, i64 %280
%287 = load float, float* %286
%288 = tail call float @llvm.fmuladd.f32(float %283, float %285, float %287)
store float %288, float* %286
%289 = or i64 %280, 1
br label %290
290: ; preds = %282, %279
%291 = phi i64 [ %280, %279 ], [ %289, %282 ]
%292 = icmp eq i64 %281, %36
br i1 %292, label %310, label %293
293: ; preds = %290, %293
%294 = phi i64 [ %308, %293 ], [ %291, %290 ]
%295 = load float, float* %243
%296 = getelementptr inbounds float, float* %11, i64 %294
%297 = load float, float* %296
%298 = getelementptr inbounds float, float* %92, i64 %294
%299 = load float, float* %298
%300 = tail call float @llvm.fmuladd.f32(float %295, float %297, float %299)
store float %300, float* %298
%301 = add nuw nsw i64 %294, 1
%302 = load float, float* %243
%303 = getelementptr inbounds float, float* %11, i64 %301
%304 = load float, float* %303
%305 = getelementptr inbounds float, float* %92, i64 %301
%306 = load float, float* %305
%307 = tail call float @llvm.fmuladd.f32(float %302, float %304, float %306)
store float %307, float* %305
%308 = add nuw nsw i64 %294, 2
%309 = icmp eq i64 %308, %10
br i1 %309, label %310, label %293
310: ; preds = %290, %293, %278
br i1 %7, label %311, label %403
311: ; preds = %310
%312 = getelementptr inbounds float, float* %90, i64 2
br i1 %37, label %348, label %313
313: ; preds = %311
%314 = icmp ult float* %72, %79
%315 = icmp ult float* %77, %74
%316 = and i1 %314, %315
%317 = icmp ult float* %72, %17
%318 = icmp ult float* %14, %74
%319 = and i1 %317, %318
%320 = or i1 %316, %319
br i1 %320, label %348, label %321
321: ; preds = %313
%322 = load float, float* %312
%323 = insertelement <4 x float> poison, float %322, i64 0
%324 = shufflevector <4 x float> %323, <4 x float> poison, <4 x i32> zeroinitializer
%325 = insertelement <4 x float> poison, float %322, i64 0
%326 = shufflevector <4 x float> %325, <4 x float> poison, <4 x i32> zeroinitializer
br label %327
327: ; preds = %327, %321
%328 = phi i64 [ 0, %321 ], [ %345, %327 ]
%329 = getelementptr inbounds float, float* %14, i64 %328
%330 = bitcast float* %329 to <4 x float>*
%331 = load <4 x float>, <4 x float>* %330
%332 = getelementptr inbounds float, float* %329, i64 4
%333 = bitcast float* %332 to <4 x float>*
%334 = load <4 x float>, <4 x float>* %333
%335 = getelementptr inbounds float, float* %92, i64 %328
%336 = bitcast float* %335 to <4 x float>*
%337 = load <4 x float>, <4 x float>* %336
%338 = getelementptr inbounds float, float* %335, i64 4
%339 = bitcast float* %338 to <4 x float>*
%340 = load <4 x float>, <4 x float>* %339
%341 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %324, <4 x float> %331, <4 x float> %337)
%342 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %326, <4 x float> %334, <4 x float> %340)
%343 = bitcast float* %335 to <4 x float>*
store <4 x float> %341, <4 x float>* %343
%344 = bitcast float* %338 to <4 x float>*
store <4 x float> %342, <4 x float>* %344
%345 = add nuw i64 %328, 8
%346 = icmp eq i64 %345, %38
br i1 %346, label %347, label %327
347: ; preds = %327
br i1 %39, label %379, label %348
348: ; preds = %313, %311, %347
%349 = phi i64 [ 0, %313 ], [ 0, %311 ], [ %38, %347 ]
%350 = xor i64 %349, -1
br i1 %41, label %359, label %351
351: ; preds = %348
%352 = load float, float* %312
%353 = getelementptr inbounds float, float* %14, i64 %349
%354 = load float, float* %353
%355 = getelementptr inbounds float, float* %92, i64 %349
%356 = load float, float* %355
%357 = tail call float @llvm.fmuladd.f32(float %352, float %354, float %356)
store float %357, float* %355
%358 = or i64 %349, 1
br label %359
359: ; preds = %351, %348
%360 = phi i64 [ %349, %348 ], [ %358, %351 ]
%361 = icmp eq i64 %350, %42
br i1 %361, label %379, label %362
362: ; preds = %359, %362
%363 = phi i64 [ %377, %362 ], [ %360, %359 ]
%364 = load float, float* %312
%365 = getelementptr inbounds float, float* %14, i64 %363
%366 = load float, float* %365
%367 = getelementptr inbounds float, float* %92, i64 %363
%368 = load float, float* %367
%369 = tail call float @llvm.fmuladd.f32(float %364, float %366, float %368)
store float %369, float* %367
%370 = add nuw nsw i64 %363, 1
%371 = load float, float* %312
%372 = getelementptr inbounds float, float* %14, i64 %370
%373 = load float, float* %372
%374 = getelementptr inbounds float, float* %92, i64 %370
%375 = load float, float* %374
%376 = tail call float @llvm.fmuladd.f32(float %371, float %373, float %375)
store float %376, float* %374
%377 = add nuw nsw i64 %363, 2
%378 = icmp eq i64 %377, %13
br i1 %378, label %379, label %362
379: ; preds = %359, %362, %347
br i1 %7, label %143, label %403
380: ; preds = %221, %380
%381 = phi i64 [ %401, %380 ], [ %222, %221 ]
%382 = load float, float* %144
%383 = getelementptr inbounds float, float* %92, i64 %381
%384 = load float, float* %383
%385 = fadd float %382, %384
store float %385, float* %383
%386 = add nuw nsw i64 %381, 1
%387 = load float, float* %144
%388 = getelementptr inbounds float, float* %92, i64 %386
%389 = load float, float* %388
%390 = fadd float %387, %389
store float %390, float* %388
%391 = add nuw nsw i64 %381, 2
%392 = load float, float* %144
%393 = getelementptr inbounds float, float* %92, i64 %391
%394 = load float, float* %393
%395 = fadd float %392, %394
store float %395, float* %393
%396 = add nuw nsw i64 %381, 3
%397 = load float, float* %144
%398 = getelementptr inbounds float, float* %92, i64 %396
%399 = load float, float* %398
%400 = fadd float %397, %399
store float %400, float* %398
%401 = add nuw nsw i64 %381, 4
%402 = icmp eq i64 %401, %15
br i1 %402, label %403, label %380
403: ; preds = %221, %380, %206, %52, %241, %310, %379
%404 = add nuw nsw i64 %53, 1
%405 = icmp eq i64 %404, 3
br i1 %405, label %406, label %52
406: ; preds = %403
ret void
}