#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(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) * 4 * ncols);
  for (i = 0; i < 4; i++) {
    rowa = a + i * 4;
    rowdest = out + i * ncols;
    for (j = 0; j < 4; j++) {
      for (k = 0; k < ncols; k++) {
        colb = b + k;
        rowdest[k] += rowa[j] * colb[ncols * j];
      }
    }
  }
}


x86 assembly (clang, -O0):
<m44mulf>:
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
shl    $0x4,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1223 <m44mulf+0x113>
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   $0x4,-0x28(%rbp)
jge    1210 <m44mulf+0x100>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11fd <m44mulf+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+0x86>
jmp    1202 <m44mulf+0xf2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1185 <m44mulf+0x75>
jmp    1215 <m44mulf+0x105>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1143 <m44mulf+0x33>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m44mulf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rcx,%r14
mov    %edx,%r15d
mov    %rsi,%rbx
mov    %rdi,%rbp
shl    $0x4,%edx
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %rcx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movslq %r15d,%rsi
mov    %esi,%ecx
lea    (%rbx,%rsi,4),%r12
lea    (%rbx,%rsi,8),%r10
lea    (%rsi,%rsi,2),%rax
lea    (%rbx,%rax,4),%r8
add    %rcx,%rax
lea    (%rbx,%rax,4),%rax
mov    %rax,0x48(%rsp)
lea    (%rcx,%rsi,2),%rax
lea    (%rbx,%rax,4),%rax
mov    %rax,0x50(%rsp)
lea    (%rsi,%rcx,1),%rax
lea    (%rbx,%rax,4),%rax
mov    %rax,0x58(%rsp)
lea    (%rbx,%rcx,4),%rax
mov    %rax,0x68(%rsp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rax,0x28(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x30(%rsp)
lea    0x10(%r14),%r9
mov    %rsi,0x70(%rsp)
lea    0x0(,%rsi,4),%rax
mov    %rax,0x80(%rsp)
lea    0x0(,%rcx,4),%r11
and    $0xffffffffffffffe0,%r11
lea    0x4(%r14),%r13
mov    %r14,0x78(%rsp)
mov    %r15d,0x4(%rsp)
mov    %r8,0x8(%rsp)
jmp    120c <m44mulf+0xfc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rdx
add    $0x1,%rdx
mov    0x80(%rsp),%rax
add    %rax,%r9
add    %rax,%r13
add    %rax,%r14
mov    %rdx,%rax
mov    %rdx,0x40(%rsp)
cmp    $0x4,%rdx
je     17c1 <m44mulf+0x6b1>
test   %r15d,%r15d
jle    11e0 <m44mulf+0xd0>
mov    0x40(%rsp),%rdx
mov    %rdx,%rsi
imul   0x70(%rsp),%rsi
lea    0x0(,%rdx,4),%rax
shl    $0x4,%rdx
mov    0x78(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
add    %rcx,%rsi
lea    (%rdi,%rsi,4),%rdi
lea    (%rdx,%rbp,1),%rsi
add    $0x4,%rsi
cmp    $0x8,%r15d
mov    %r8,0x10(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rdx,0x20(%rsp)
jae    12f0 <m44mulf+0x1e0>
xor    %edi,%edi
mov    %rdi,%r8
test   $0x1,%cl
je     1287 <m44mulf+0x177>
movss  0x0(%rbp,%rax,4),%xmm0
mulss  (%rbx,%rdi,4),%xmm0
mov    0x10(%rsp),%rdx
addss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
mov    %rdi,%r8
or     $0x1,%r8
not    %rdi
cmp    0x30(%rsp),%rdi
je     13a0 <m44mulf+0x290>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rax,4),%xmm0
mulss  (%rbx,%r8,4),%xmm0
addss  -0x4(%r13,%r8,4),%xmm0
movss  %xmm0,-0x4(%r13,%r8,4)
movss  0x0(%rbp,%rax,4),%xmm0
mulss  0x4(%rbx,%r8,4),%xmm0
addss  0x0(%r13,%r8,4),%xmm0
movss  %xmm0,0x0(%r13,%r8,4)
add    $0x2,%r8
cmp    %r8,%rcx
jne    12a0 <m44mulf+0x190>
jmp    13a0 <m44mulf+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rbp,1),%r15
mov    %rsi,0x18(%rsp)
cmp    %rsi,%r8
setb   %dl
cmp    %rdi,%r15
setb   %r15b
cmp    0x68(%rsp),%r8
setb   %sil
cmp    %rbx,%rdi
seta   %r8b
test   %r15b,%dl
jne    1656 <m44mulf+0x546>
mov    $0x0,%edi
and    %r8b,%sil
mov    0x4(%rsp),%r15d
mov    0x18(%rsp),%rsi
jne    125e <m44mulf+0x14e>
movss  0x0(%rbp,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rsi,1),%xmm1
movups 0x10(%rbx,%rsi,1),%xmm2
movups -0x10(%r9,%rsi,1),%xmm3
movups (%r9,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%r9,%rsi,1)
movups %xmm2,(%r9,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    1350 <m44mulf+0x240>
mov    0x28(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rcx,%rsi
mov    0x18(%rsp),%rsi
jne    125e <m44mulf+0x14e>
nopw   0x0(%rax,%rax,1)
test   %r15d,%r15d
mov    0x8(%rsp),%r8
jle    11e0 <m44mulf+0xd0>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rbp,1),%rdi
add    $0x8,%rdi
cmp    $0x8,%r15d
mov    %rdi,0x18(%rsp)
jae    1441 <m44mulf+0x331>
xor    %esi,%esi
mov    %rsi,%rdi
test   $0x1,%cl
je     13f2 <m44mulf+0x2e2>
movss  0x4(%rbp,%rax,4),%xmm0
mulss  (%r12,%rsi,4),%xmm0
mov    0x10(%rsp),%rdx
addss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0x30(%rsp),%rsi
je     14f0 <m44mulf+0x3e0>
movss  0x4(%rbp,%rax,4),%xmm0
mulss  (%r12,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0x4(%rbp,%rax,4),%xmm0
mulss  0x4(%r12,%rdi,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1400 <m44mulf+0x2f0>
jmp    14f0 <m44mulf+0x3e0>
mov    0x10(%rsp),%rdx
cmp    %rdi,%rdx
mov    %rsi,%r8
setb   %sil
mov    0x38(%rsp),%rdi
cmp    %rdi,%r8
setb   %r15b
cmp    0x58(%rsp),%rdx
setb   %dl
cmp    %rdi,%r12
setb   %r8b
test   %r15b,%sil
jne    1719 <m44mulf+0x609>
mov    $0x0,%esi
and    %r8b,%dl
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
jne    13c8 <m44mulf+0x2b8>
movss  0x4(%rbp,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%r12,%rsi,1),%xmm1
movups 0x10(%r12,%rsi,1),%xmm2
movups -0x10(%r9,%rsi,1),%xmm3
movups (%r9,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%r9,%rsi,1)
movups %xmm2,(%r9,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    14a0 <m44mulf+0x390>
mov    0x28(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rcx,%rdi
jne    13c8 <m44mulf+0x2b8>
nopw   0x0(%rax,%rax,1)
test   %r15d,%r15d
jle    11e0 <m44mulf+0xd0>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rbp,1),%rsi
add    $0xc,%rsi
cmp    $0x8,%r15d
mov    %rsi,0x60(%rsp)
jae    1591 <m44mulf+0x481>
xor    %esi,%esi
mov    %rsi,%rdi
test   $0x1,%cl
je     1541 <m44mulf+0x431>
movss  0x8(%rbp,%rax,4),%xmm0
mulss  (%r10,%rsi,4),%xmm0
mov    0x10(%rsp),%rdx
addss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0x30(%rsp),%rsi
je     1640 <m44mulf+0x530>
nop
movss  0x8(%rbp,%rax,4),%xmm0
mulss  (%r10,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0x8(%rbp,%rax,4),%xmm0
mulss  0x4(%r10,%rdi,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1550 <m44mulf+0x440>
jmp    1640 <m44mulf+0x530>
mov    0x10(%rsp),%rdx
cmp    %rsi,%rdx
setb   %sil
mov    0x38(%rsp),%rdi
cmp    %rdi,0x18(%rsp)
setb   %r15b
cmp    0x50(%rsp),%rdx
setb   %dl
cmp    %rdi,%r10
setb   %r8b
test   %r15b,%sil
jne    172a <m44mulf+0x61a>
mov    $0x0,%esi
and    %r8b,%dl
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
jne    1517 <m44mulf+0x407>
movss  0x8(%rbp,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r10,%rsi,1),%xmm1
movups 0x10(%r10,%rsi,1),%xmm2
movups -0x10(%r9,%rsi,1),%xmm3
movups (%r9,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%r9,%rsi,1)
movups %xmm2,(%r9,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    15f0 <m44mulf+0x4e0>
mov    0x28(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rcx,%rdi
jne    1517 <m44mulf+0x407>
nopw   0x0(%rax,%rax,1)
test   %r15d,%r15d
jle    11e0 <m44mulf+0xd0>
cmp    $0x8,%r15d
jae    1667 <m44mulf+0x557>
xor    %esi,%esi
jmp    1747 <m44mulf+0x637>
xor    %edi,%edi
mov    0x4(%rsp),%r15d
mov    0x18(%rsp),%rsi
jmp    125e <m44mulf+0x14e>
mov    0x20(%rsp),%rdx
lea    (%rdx,%rbp,1),%rsi
add    $0x10,%rsi
mov    0x10(%rsp),%rdx
cmp    %rsi,%rdx
setb   0x20(%rsp)
mov    0x38(%rsp),%rsi
cmp    %rsi,0x60(%rsp)
setb   %r15b
cmp    0x48(%rsp),%rdx
setb   %dil
cmp    %rsi,%r8
setb   %r8b
test   %r15b,0x20(%rsp)
jne    173b <m44mulf+0x62b>
mov    $0x0,%esi
and    %r8b,%dil
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
jne    1747 <m44mulf+0x637>
movss  0xc(%rbp,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %esi,%esi
xchg   %ax,%ax
movups (%r8,%rsi,1),%xmm1
movups 0x10(%r8,%rsi,1),%xmm2
movups -0x10(%r9,%rsi,1),%xmm3
movups (%r9,%rsi,1),%xmm4
mulps  %xmm0,%xmm1
addps  %xmm3,%xmm1
mulps  %xmm0,%xmm2
addps  %xmm4,%xmm2
movups %xmm1,-0x10(%r9,%rsi,1)
movups %xmm2,(%r9,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    16d0 <m44mulf+0x5c0>
mov    0x28(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rcx,%rdi
je     11e0 <m44mulf+0xd0>
jmp    1747 <m44mulf+0x637>
xor    %esi,%esi
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
jmp    13c8 <m44mulf+0x2b8>
xor    %esi,%esi
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
jmp    1517 <m44mulf+0x407>
xor    %esi,%esi
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%r8
mov    %rsi,%rdi
test   $0x1,%cl
je     1771 <m44mulf+0x661>
movss  0xc(%rbp,%rax,4),%xmm0
mulss  (%r8,%rsi,4),%xmm0
mov    0x10(%rsp),%rdx
addss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
mov    %rsi,%rdi
or     $0x1,%rdi
not    %rsi
cmp    0x30(%rsp),%rsi
je     11e0 <m44mulf+0xd0>
nop
movss  0xc(%rbp,%rax,4),%xmm0
mulss  (%r8,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  0xc(%rbp,%rax,4),%xmm0
mulss  0x4(%r8,%rdi,4),%xmm0
addss  0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    1780 <m44mulf+0x670>
jmp    11e0 <m44mulf+0xd0>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @m44mulf(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 16, %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 = %75, %4
%22 = load i32, i32* %9
%23 = icmp slt i32 %22, 4
br i1 %23, label %24, label %78
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, 4
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
br label %75
75: ; preds = %74
%76 = load i32, i32* %9
%77 = add nsw i32 %76, 1
store i32 %77, i32* %9
br label %21
78: ; preds = %21
ret void
}

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