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

/* Forward declarations */

/* Type definitions */
typedef size_t i;
typedef size_t col;
typedef scalar_t__ *N;

/* Variables and functions */
float *alloca(int);
void matmul(float A[], float B[], float C0[], int N) {
  float *C;
  int row, col, i;
  float sum;
  if (C0 == A || C0 == B) {
    C = alloca(N * N * sizeof(float));
  } else {
    C = C0;
  }
  for (row = 0; row < N; row++) {
    for (col = 0; col < N; col++) {
      sum = 0;
      for (i = 0; i < N; i++) {
        sum += A[(i) * (N) + (row)] * B[(col) * (N) + (i)];
      }
      C[(col) * (N) + (row)] = sum;
    }
  }
  if (C != C0) {
    for (i = 0; i < N * N; i++) {
      C0[i] = C[i];
    }
  }
}


x86 assembly (clang, -O0):
<matmul>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x8(%rbp),%rax
je     1143 <matmul+0x33>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    1160 <matmul+0x50>
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <alloca@plt>
mov    %rax,-0x28(%rbp)
jmp    1168 <matmul+0x58>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1231 <matmul+0x121>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    121e <matmul+0x10e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f5 <matmul+0xe5>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119d <matmul+0x8d>
movss  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1182 <matmul+0x72>
jmp    1223 <matmul+0x113>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116f <matmul+0x5f>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
je     1285 <matmul+0x175>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1280 <matmul+0x170>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1246 <matmul+0x136>
jmp    1285 <matmul+0x175>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmul>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r13d
mov    %rdx,%rbx
mov    %rsi,(%rsp)
mov    %rdi,%r14
cmp    %rdi,%rdx
je     1139 <matmul+0x29>
mov    %rbx,%rax
cmp    (%rsp),%rbx
jne    1148 <matmul+0x38>
mov    %r13d,%edi
imul   %r13d,%edi
shl    $0x2,%edi
call   1030 <alloca@plt>
mov    %rbx,0x8(%rsp)
test   %r13d,%r13d
jle    1250 <matmul+0x140>
mov    %r13d,%r11d
mov    %r11d,%edx
and    $0xfffffffe,%edx
lea    0x0(,%r11,4),%rsi
lea    0x0(,%r11,8),%rdi
mov    (%rsp),%rcx
add    $0x4,%rcx
mov    %rcx,0x10(%rsp)
xor    %r10d,%r10d
mov    %r14,%r12
jmp    11a1 <matmul+0x91>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
add    $0x4,%r12
cmp    %r11,%r10
je     1250 <matmul+0x140>
mov    0x10(%rsp),%rbp
xor    %r8d,%r8d
jmp    11c4 <matmul+0xb4>
nopl   0x0(%rax,%rax,1)
add    %r10,%rbx
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%r8
add    %rsi,%rbp
cmp    %r11,%r8
je     1190 <matmul+0x80>
xorps  %xmm0,%xmm0
cmp    $0x1,%r13d
jne    11e0 <matmul+0xd0>
xor    %r15d,%r15d
jmp    121d <matmul+0x10d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%r9
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movss  (%r9),%xmm1
mulss  -0x4(%rbp,%r15,4),%xmm1
addss  %xmm0,%xmm1
movss  (%r9,%rsi,1),%xmm0
mulss  0x0(%rbp,%r15,4),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%r15
add    %rdi,%r9
cmp    %r15,%rdx
jne    11f0 <matmul+0xe0>
mov    %r8,%rbx
imul   %r11,%rbx
test   $0x1,%r11b
je     11b0 <matmul+0xa0>
mov    %r15,%rcx
imul   %r11,%rcx
add    %r10,%rcx
movss  (%r14,%rcx,4),%xmm1
add    %rbx,%r15
mov    (%rsp),%rcx
mulss  (%rcx,%r15,4),%xmm1
addss  %xmm1,%xmm0
jmp    11b0 <matmul+0xa0>
mov    0x8(%rsp),%rsi
cmp    %rsi,%rax
je     13d5 <matmul+0x2c5>
imul   %r13d,%r13d
test   %r13d,%r13d
je     13d5 <matmul+0x2c5>
mov    %r13d,%ecx
cmp    $0x8,%r13d
jb     1286 <matmul+0x176>
lea    (%rax,%rcx,4),%rdx
cmp    %rsi,%rdx
jbe    12fc <matmul+0x1ec>
lea    (%rsi,%rcx,4),%rdx
cmp    %rdx,%rax
jae    12fc <matmul+0x1ec>
xor    %edx,%edx
mov    %rdx,%rbp
not    %rbp
add    %rcx,%rbp
mov    %rcx,%rdi
and    $0x3,%rdi
je     12b4 <matmul+0x1a4>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    12a0 <matmul+0x190>
cmp    $0x3,%rbp
jb     13d5 <matmul+0x2c5>
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm0
movss  %xmm0,0xc(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    12c0 <matmul+0x1b0>
jmp    13d5 <matmul+0x2c5>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    1321 <matmul+0x211>
xor    %ebp,%ebp
jmp    1388 <matmul+0x278>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rbp,4)
movups %xmm1,0x10(%rsi,%rbp,4)
movups 0x20(%rax,%rbp,4),%xmm0
movups 0x30(%rax,%rbp,4),%xmm1
movups %xmm0,0x20(%rsi,%rbp,4)
movups %xmm1,0x30(%rsi,%rbp,4)
movups 0x40(%rax,%rbp,4),%xmm0
movups 0x50(%rax,%rbp,4),%xmm1
movups %xmm0,0x40(%rsi,%rbp,4)
movups %xmm1,0x50(%rsi,%rbp,4)
movups 0x60(%rax,%rbp,4),%xmm0
movups 0x70(%rax,%rbp,4),%xmm1
movups %xmm0,0x60(%rsi,%rbp,4)
movups %xmm1,0x70(%rsi,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1330 <matmul+0x220>
test   %r8,%r8
je     13cc <matmul+0x2bc>
lea    (%rsi,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rbx,1),%xmm0
movups 0x0(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    13b0 <matmul+0x2a0>
cmp    %rcx,%rdx
jne    1288 <matmul+0x178>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @matmul(float* %0, float* %1, float* %2, i32 %3) {
%5 = icmp eq float* %2, %0
%6 = icmp eq float* %2, %1
%7 = or i1 %5, %6
br i1 %7, label %8, label %12
8: ; preds = %4
%9 = mul nsw i32 %3, %3
%10 = shl i32 %9, 2
%11 = tail call float* @alloca(i32 %10)
br label %12
12: ; preds = %4, %8
%13 = phi float* [ %11, %8 ], [ %2, %4 ]
%14 = icmp sgt i32 %3, 0
br i1 %14, label %15, label %73
15: ; preds = %12
%16 = zext i32 %3 to i64
%17 = zext i32 %3 to i64
%18 = and i64 %17, 1
%19 = icmp eq i32 %3, 1
%20 = and i64 %17, 4294967294
%21 = icmp eq i64 %18, 0
br label %22
22: ; preds = %70, %15
%23 = phi i64 [ 0, %15 ], [ %71, %70 ]
br label %24
24: ; preds = %64, %22
%25 = phi i64 [ 0, %22 ], [ %68, %64 ]
%26 = mul nsw i64 %25, %16
br i1 %19, label %51, label %27
27: ; preds = %24, %27
%28 = phi i64 [ %48, %27 ], [ 0, %24 ]
%29 = phi float [ %47, %27 ], [ 0.000000e+00, %24 ]
%30 = phi i64 [ %49, %27 ], [ 0, %24 ]
%31 = mul nsw i64 %28, %16
%32 = add nuw nsw i64 %31, %23
%33 = getelementptr inbounds float, float* %0, i64 %32
%34 = load float, float* %33
%35 = add nuw nsw i64 %28, %26
%36 = getelementptr inbounds float, float* %1, i64 %35
%37 = load float, float* %36
%38 = tail call float @llvm.fmuladd.f32(float %34, float %37, float %29)
%39 = or i64 %28, 1
%40 = mul nsw i64 %39, %16
%41 = add nuw nsw i64 %40, %23
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = load float, float* %42
%44 = add nuw nsw i64 %39, %26
%45 = getelementptr inbounds float, float* %1, i64 %44
%46 = load float, float* %45
%47 = tail call float @llvm.fmuladd.f32(float %43, float %46, float %38)
%48 = add nuw nsw i64 %28, 2
%49 = add i64 %30, 2
%50 = icmp eq i64 %49, %20
br i1 %50, label %51, label %27
51: ; preds = %27, %24
%52 = phi float [ undef, %24 ], [ %47, %27 ]
%53 = phi i64 [ 0, %24 ], [ %48, %27 ]
%54 = phi float [ 0.000000e+00, %24 ], [ %47, %27 ]
br i1 %21, label %64, label %55
55: ; preds = %51
%56 = mul nsw i64 %53, %16
%57 = add nuw nsw i64 %56, %23
%58 = getelementptr inbounds float, float* %0, i64 %57
%59 = load float, float* %58
%60 = add nuw nsw i64 %53, %26
%61 = getelementptr inbounds float, float* %1, i64 %60
%62 = load float, float* %61
%63 = tail call float @llvm.fmuladd.f32(float %59, float %62, float %54)
br label %64
64: ; preds = %51, %55
%65 = phi float [ %52, %51 ], [ %63, %55 ]
%66 = add nuw nsw i64 %26, %23
%67 = getelementptr inbounds float, float* %13, i64 %66
store float %65, float* %67
%68 = add nuw nsw i64 %25, 1
%69 = icmp eq i64 %68, %17
br i1 %69, label %70, label %24
70: ; preds = %64
%71 = add nuw nsw i64 %23, 1
%72 = icmp eq i64 %71, %17
br i1 %72, label %73, label %22
73: ; preds = %70, %12
%74 = icmp eq float* %13, %2
br i1 %74, label %203, label %75
75: ; preds = %73
%76 = mul i32 %3, %3
%77 = icmp eq i32 %76, 0
br i1 %77, label %203, label %78
78: ; preds = %75
%79 = zext i32 %76 to i64
%80 = icmp ult i32 %76, 8
br i1 %80, label %166, label %81
81: ; preds = %78
%82 = getelementptr float, float* %2, i64 %79
%83 = getelementptr float, float* %13, i64 %79
%84 = icmp ugt float* %83, %2
%85 = icmp ult float* %13, %82
%86 = and i1 %84, %85
br i1 %86, label %166, label %87
87: ; preds = %81
%88 = and i64 %79, 4294967288
%89 = add nsw i64 %88, -8
%90 = lshr exact i64 %89, 3
%91 = add nuw nsw i64 %90, 1
%92 = and i64 %91, 3
%93 = icmp ult i64 %89, 24
br i1 %93, label %145, label %94
94: ; preds = %87
%95 = and i64 %91, 4611686018427387900
br label %96
96: ; preds = %96, %94
%97 = phi i64 [ 0, %94 ], [ %142, %96 ]
%98 = phi i64 [ 0, %94 ], [ %143, %96 ]
%99 = getelementptr inbounds float, float* %13, i64 %97
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = getelementptr inbounds float, float* %99, i64 4
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %2, i64 %97
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %101, <4 x float>* %106
%107 = getelementptr inbounds float, float* %105, i64 4
%108 = bitcast float* %107 to <4 x float>*
store <4 x float> %104, <4 x float>* %108
%109 = or i64 %97, 8
%110 = getelementptr inbounds float, float* %13, 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* %2, i64 %109
%117 = bitcast float* %116 to <4 x float>*
store <4 x float> %112, <4 x float>* %117
%118 = getelementptr inbounds float, float* %116, i64 4
%119 = bitcast float* %118 to <4 x float>*
store <4 x float> %115, <4 x float>* %119
%120 = or i64 %97, 16
%121 = getelementptr inbounds float, float* %13, i64 %120
%122 = bitcast float* %121 to <4 x float>*
%123 = load <4 x float>, <4 x float>* %122
%124 = getelementptr inbounds float, float* %121, i64 4
%125 = bitcast float* %124 to <4 x float>*
%126 = load <4 x float>, <4 x float>* %125
%127 = getelementptr inbounds float, float* %2, i64 %120
%128 = bitcast float* %127 to <4 x float>*
store <4 x float> %123, <4 x float>* %128
%129 = getelementptr inbounds float, float* %127, i64 4
%130 = bitcast float* %129 to <4 x float>*
store <4 x float> %126, <4 x float>* %130
%131 = or i64 %97, 24
%132 = getelementptr inbounds float, float* %13, i64 %131
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %132, i64 4
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = getelementptr inbounds float, float* %2, i64 %131
%139 = bitcast float* %138 to <4 x float>*
store <4 x float> %134, <4 x float>* %139
%140 = getelementptr inbounds float, float* %138, i64 4
%141 = bitcast float* %140 to <4 x float>*
store <4 x float> %137, <4 x float>* %141
%142 = add nuw i64 %97, 32
%143 = add i64 %98, 4
%144 = icmp eq i64 %143, %95
br i1 %144, label %145, label %96
145: ; preds = %96, %87
%146 = phi i64 [ 0, %87 ], [ %142, %96 ]
%147 = icmp eq i64 %92, 0
br i1 %147, label %164, label %148
148: ; preds = %145, %148
%149 = phi i64 [ %161, %148 ], [ %146, %145 ]
%150 = phi i64 [ %162, %148 ], [ 0, %145 ]
%151 = getelementptr inbounds float, float* %13, i64 %149
%152 = bitcast float* %151 to <4 x float>*
%153 = load <4 x float>, <4 x float>* %152
%154 = getelementptr inbounds float, float* %151, i64 4
%155 = bitcast float* %154 to <4 x float>*
%156 = load <4 x float>, <4 x float>* %155
%157 = getelementptr inbounds float, float* %2, i64 %149
%158 = bitcast float* %157 to <4 x float>*
store <4 x float> %153, <4 x float>* %158
%159 = getelementptr inbounds float, float* %157, i64 4
%160 = bitcast float* %159 to <4 x float>*
store <4 x float> %156, <4 x float>* %160
%161 = add nuw i64 %149, 8
%162 = add i64 %150, 1
%163 = icmp eq i64 %162, %92
br i1 %163, label %164, label %148
164: ; preds = %148, %145
%165 = icmp eq i64 %88, %79
br i1 %165, label %203, label %166
166: ; preds = %81, %78, %164
%167 = phi i64 [ 0, %81 ], [ 0, %78 ], [ %88, %164 ]
%168 = xor i64 %167, -1
%169 = add nsw i64 %168, %79
%170 = and i64 %79, 3
%171 = icmp eq i64 %170, 0
br i1 %171, label %181, label %172
172: ; preds = %166, %172
%173 = phi i64 [ %178, %172 ], [ %167, %166 ]
%174 = phi i64 [ %179, %172 ], [ 0, %166 ]
%175 = getelementptr inbounds float, float* %13, i64 %173
%176 = load float, float* %175
%177 = getelementptr inbounds float, float* %2, i64 %173
store float %176, float* %177
%178 = add nuw nsw i64 %173, 1
%179 = add i64 %174, 1
%180 = icmp eq i64 %179, %170
br i1 %180, label %181, label %172
181: ; preds = %172, %166
%182 = phi i64 [ %167, %166 ], [ %178, %172 ]
%183 = icmp ult i64 %169, 3
br i1 %183, label %203, label %184
184: ; preds = %181, %184
%185 = phi i64 [ %201, %184 ], [ %182, %181 ]
%186 = getelementptr inbounds float, float* %13, i64 %185
%187 = load float, float* %186
%188 = getelementptr inbounds float, float* %2, i64 %185
store float %187, float* %188
%189 = add nuw nsw i64 %185, 1
%190 = getelementptr inbounds float, float* %13, i64 %189
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %2, i64 %189
store float %191, float* %192
%193 = add nuw nsw i64 %185, 2
%194 = getelementptr inbounds float, float* %13, i64 %193
%195 = load float, float* %194
%196 = getelementptr inbounds float, float* %2, i64 %193
store float %195, float* %196
%197 = add nuw nsw i64 %185, 3
%198 = getelementptr inbounds float, float* %13, i64 %197
%199 = load float, float* %198
%200 = getelementptr inbounds float, float* %2, i64 %197
store float %199, float* %200
%201 = add nuw nsw i64 %185, 4
%202 = icmp eq i64 %201, %79
br i1 %202, label %203, label %184
203: ; preds = %181, %184, %164, %75, %73
ret void
}