#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*/ assert(int);
void convolve(const float *x, float *y, int sz, const float *k, int ksz) {
  assert((ksz & 1) == 1);
  for (int i = 0; i < ksz / 2 && i < sz; i++)
    y[i] = x[i];
  for (int i = 0; i < sz - ksz; i++) {
    float acc = 0;
    for (int j = 0; j < ksz; j++)
      acc += k[j] * x[i + j];
    y[ksz / 2 + i] = acc;
  }
  for (int i = sz - ksz + ksz / 2; i < sz; i++)
    y[i] = x[i];
}


x86 assembly (clang, -O0):
<convolve>:
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    %r8d,-0x24(%rbp)
mov    -0x24(%rbp),%eax
and    $0x1,%eax
cmp    $0x1,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x39(%rbp)
jge    1171 <convolve+0x61>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1181 <convolve+0x71>
jmp    11a9 <convolve+0x99>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1148 <convolve+0x38>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    1252 <convolve+0x142>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    121b <convolve+0x10b>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d0 <convolve+0xc0>
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b0 <convolve+0xa0>
mov    -0x14(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a4 <convolve+0x194>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1270 <convolve+0x160>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolve>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,%ebx
mov    %rcx,%rbp
mov    %edx,%r14d
mov    %rsi,%r12
mov    %rdi,%r15
mov    %r8d,%edi
and    $0x1,%edi
call   1030 <assert@plt>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
mov    %rax,0x8(%rsp)
mov    %ebx,(%rsp)
cmp    $0x2,%ebx
jl     12f4 <convolve+0x1e4>
test   %r14d,%r14d
jle    12f4 <convolve+0x1e4>
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
lea    -0x1(%r14),%edx
cmp    %edx,%eax
cmovb  %eax,%edx
lea    0x1(%rdx),%ecx
cmp    $0x7,%edx
jb     118e <convolve+0x7e>
lea    (%r15,%rcx,4),%rax
cmp    %r12,%rax
jbe    1214 <convolve+0x104>
lea    (%r12,%rcx,4),%rax
cmp    %r15,%rax
jbe    1214 <convolve+0x104>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %rcx,%rax
mov    %rcx,%rsi
and    $0x3,%rsi
je     11c6 <convolve+0xb6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r15,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    11b0 <convolve+0xa0>
cmp    $0x3,%rax
jb     12f4 <convolve+0x1e4>
movss  (%r15,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
movss  0x4(%r15,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12,%rdx,4)
movss  0x8(%r15,%rdx,4),%xmm0
movss  %xmm0,0x8(%r12,%rdx,4)
movss  0xc(%r15,%rdx,4),%xmm0
movss  %xmm0,0xc(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    11d0 <convolve+0xc0>
jmp    12f4 <convolve+0x1e4>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x18,%rdi
jae    1237 <convolve+0x127>
xor    %edi,%edi
jmp    12a8 <convolve+0x198>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,(%r12,%rdi,4)
movups %xmm1,0x10(%r12,%rdi,4)
movups 0x20(%r15,%rdi,4),%xmm0
movups 0x30(%r15,%rdi,4),%xmm1
movups %xmm0,0x20(%r12,%rdi,4)
movups %xmm1,0x30(%r12,%rdi,4)
movups 0x40(%r15,%rdi,4),%xmm0
movups 0x50(%r15,%rdi,4),%xmm1
movups %xmm0,0x40(%r12,%rdi,4)
movups %xmm1,0x50(%r12,%rdi,4)
movups 0x60(%r15,%rdi,4),%xmm0
movups 0x70(%r15,%rdi,4),%xmm1
movups %xmm0,0x60(%r12,%rdi,4)
movups %xmm1,0x70(%r12,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1240 <convolve+0x130>
test   %rax,%rax
je     12eb <convolve+0x1db>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r15,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movups %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rax
jne    12d0 <convolve+0x1c0>
cmp    %rcx,%rdx
jne    1190 <convolve+0x80>
mov    %r14,0x10(%rsp)
mov    %r14d,%eax
sub    (%rsp),%eax
mov    %eax,0x4(%rsp)
test   %eax,%eax
jle    13fd <convolve+0x2ed>
movslq 0x8(%rsp),%r11
mov    0x4(%rsp),%r13d
mov    (%rsp),%ecx
lea    -0x1(%rcx),%r10
mov    %ecx,%edi
and    $0x3,%edi
and    $0xfffffffc,%ecx
lea    0xc(%r15),%rax
xor    %edx,%edx
mov    %r15,%r14
jmp    1352 <convolve+0x242>
nop
xorps  %xmm0,%xmm0
lea    (%rdx,%r11,1),%rsi
movss  %xmm0,(%r12,%rsi,4)
add    $0x1,%rdx
add    $0x4,%rax
add    $0x4,%r14
cmp    %r13,%rdx
je     13fd <convolve+0x2ed>
cmpl   $0x0,(%rsp)
jle    1330 <convolve+0x220>
xorps  %xmm0,%xmm0
xor    %r8d,%r8d
cmp    $0x3,%r10
jb     13c0 <convolve+0x2b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%r8,4),%xmm1
movss  0x4(%rbp,%r8,4),%xmm2
mulss  -0xc(%rax,%r8,4),%xmm1
mulss  -0x8(%rax,%r8,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rbp,%r8,4),%xmm3
mulss  -0x4(%rax,%r8,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rbp,%r8,4),%xmm0
mulss  (%rax,%r8,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%r8
cmp    %r8,%rcx
jne    1370 <convolve+0x260>
test   %rdi,%rdi
je     1333 <convolve+0x223>
lea    (%r14,%r8,4),%r9
lea    0x0(,%r8,4),%rbx
add    %rbp,%rbx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rsi,4),%xmm1
mulss  (%r9,%rsi,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    13e0 <convolve+0x2d0>
jmp    1333 <convolve+0x223>
mov    0x4(%rsp),%eax
add    0x8(%rsp),%eax
mov    0x10(%rsp),%rbx
cmp    %ebx,%eax
jge    15af <convolve+0x49f>
cltq
movslq %ebx,%rcx
mov    %rcx,%r9
sub    %rax,%r9
cmp    $0x8,%r9
jb     1533 <convolve+0x423>
lea    (%r12,%rax,4),%rdx
lea    (%r15,%rcx,4),%rsi
cmp    %rsi,%rdx
jae    1445 <convolve+0x335>
lea    (%r12,%rcx,4),%rdx
lea    (%r15,%rax,4),%rsi
cmp    %rdx,%rsi
jb     1533 <convolve+0x423>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdx
jae    146c <convolve+0x35c>
xor    %esi,%esi
jmp    14e9 <convolve+0x3d9>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%rax,4),%rdx
add    $0x70,%rdx
lea    (%r15,%rax,4),%rbp
add    $0x70,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rbp,%rsi,4),%xmm0
movups -0x60(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x70(%rdx,%rsi,4)
movups %xmm1,-0x60(%rdx,%rsi,4)
movups -0x50(%rbp,%rsi,4),%xmm0
movups -0x40(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x50(%rdx,%rsi,4)
movups %xmm1,-0x40(%rdx,%rsi,4)
movups -0x30(%rbp,%rsi,4),%xmm0
movups -0x20(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,4)
movups %xmm1,-0x20(%rdx,%rsi,4)
movups -0x10(%rbp,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm1,(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1490 <convolve+0x380>
test   %r10,%r10
je     152b <convolve+0x41b>
add    %rax,%rsi
lea    (%r12,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r15,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r10
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1510 <convolve+0x400>
cmp    %r8,%r9
je     15af <convolve+0x49f>
add    %r8,%rax
sub    %eax,%ebx
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
and    $0x3,%rbx
je     1566 <convolve+0x456>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1550 <convolve+0x440>
cmp    $0x3,%rdx
jb     15af <convolve+0x49f>
nopl   0x0(%rax)
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%r12,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%r12,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%r12,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1570 <convolve+0x460>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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