#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 int nsam;

/* Variables and functions */
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
void wrap(float *data, int nsam) {
  int n, ne, j;
  float *rdata;
  if (((nsam)&01) == 1) {
    n = (nsam + 1) / 2;
    ne = n;
  } else {
    n = nsam / 2;
    ne = n + 1;
  }
  rdata = (float *)malloc(nsam * sizeof(float));
  for (j = 0; j < nsam; j++)
    rdata[j] = data[j];
  for (j = 0; j < ne; j++)
    data[j] = rdata[n - 1 + j];
  for (j = 0; j < n - 1; j++)
    data[ne + j] = rdata[j];
  free(rdata);
  return;
}


x86 assembly (clang, -O0):
<wrap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1,%eax
cmp    $0x1,%eax
jne    115a <wrap+0x3a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1171 <wrap+0x51>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bf <wrap+0x9f>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    118b <wrap+0x6b>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1202 <wrap+0xe2>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11c6 <wrap+0xa6>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1247 <wrap+0x127>
mov    -0x20(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1209 <wrap+0xe9>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wrap>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %esi,%r14d
mov    %rdi,%rbx
test   $0x1,%r14b
jne    1148 <wrap+0x28>
mov    %r14d,%r12d
shr    $0x1f,%r12d
add    %r14d,%r12d
sar    %r12d
lea    0x1(%r12),%r15d
jmp    115d <wrap+0x3d>
lea    0x1(%r14),%eax
shr    $0x1f,%eax
lea    (%r14,%rax,1),%r15d
add    $0x1,%r15d
sar    %r15d
mov    %r15d,%r12d
lea    0x0(,%r14,4),%edi
call   1040 <malloc@plt>
test   %r14d,%r14d
jle    12e5 <wrap+0x1c5>
mov    %r14d,%ecx
cmp    $0x8,%r14d
jb     1192 <wrap+0x72>
lea    (%rbx,%rcx,4),%rdx
cmp    %rdx,%rax
jae    120c <wrap+0xec>
lea    (%rax,%rcx,4),%rdx
cmp    %rbx,%rdx
jbe    120c <wrap+0xec>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     11c4 <wrap+0xa4>
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11b0 <wrap+0x90>
cmp    $0x3,%rsi
jb     12e5 <wrap+0x1c5>
xchg   %ax,%ax
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
movss  0x8(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
movss  0xc(%rbx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    11d0 <wrap+0xb0>
jmp    12e5 <wrap+0x1c5>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    1231 <wrap+0x111>
xor    %ebp,%ebp
jmp    1298 <wrap+0x178>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rbp,4),%xmm0
movups 0x10(%rbx,%rbp,4),%xmm1
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
movups 0x20(%rbx,%rbp,4),%xmm0
movups 0x30(%rbx,%rbp,4),%xmm1
movups %xmm0,0x20(%rax,%rbp,4)
movups %xmm1,0x30(%rax,%rbp,4)
movups 0x40(%rbx,%rbp,4),%xmm0
movups 0x50(%rbx,%rbp,4),%xmm1
movups %xmm0,0x40(%rax,%rbp,4)
movups %xmm1,0x50(%rax,%rbp,4)
movups 0x60(%rbx,%rbp,4),%xmm0
movups 0x70(%rbx,%rbp,4),%xmm1
movups %xmm0,0x60(%rax,%rbp,4)
movups %xmm1,0x70(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1240 <wrap+0x120>
test   %r8,%r8
je     12dc <wrap+0x1bc>
lea    (%rax,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rbx,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rsi,1),%xmm0
movups 0x0(%rbp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    12c0 <wrap+0x1a0>
cmp    %rcx,%rdx
jne    1194 <wrap+0x74>
lea    -0x1(%r12),%r9d
test   %r15d,%r15d
jle    1484 <wrap+0x364>
movslq %r9d,%r8
mov    %r15d,%edx
cmp    $0x8,%r15d
jb     1321 <wrap+0x201>
lea    (%r8,%rdx,1),%rcx
lea    (%rax,%rcx,4),%rcx
cmp    %rbx,%rcx
jbe    13ac <wrap+0x28c>
lea    (%rbx,%rdx,4),%rcx
lea    (%rax,%r8,4),%rsi
cmp    %rcx,%rsi
jae    13ac <wrap+0x28c>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %rdx,%rcx
mov    %rdx,%rsi
and    $0x3,%rsi
je     1355 <wrap+0x235>
lea    (%rax,%r8,4),%rbp
nopl   0x0(%rax)
movss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1340 <wrap+0x220>
cmp    $0x3,%rcx
jb     1484 <wrap+0x364>
lea    (%rax,%r8,4),%rcx
add    $0x4,%rcx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rbx,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rbx,%rdi,4)
movss  0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,0xc(%rbx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1370 <wrap+0x250>
jmp    1484 <wrap+0x364>
mov    %edx,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    13d1 <wrap+0x2b1>
xor    %ebp,%ebp
jmp    1438 <wrap+0x318>
and    $0xfffffffffffffffc,%rsi
lea    (%rax,%r8,4),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
nop
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rbp,4)
movups %xmm1,0x10(%rbx,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm1,0x30(%rbx,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm1,0x50(%rbx,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm1,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    13e0 <wrap+0x2c0>
test   %r10,%r10
je     147b <wrap+0x35b>
lea    (%rbx,%rbp,4),%rcx
add    $0x10,%rcx
add    %r8,%rbp
lea    (%rax,%rbp,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r10
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1460 <wrap+0x340>
cmp    %rdx,%rdi
jne    1323 <wrap+0x203>
cmp    $0x2,%r12d
jl     1624 <wrap+0x504>
movslq %r15d,%r8
mov    %r9d,%edx
cmp    $0x8,%r9d
jb     14bc <wrap+0x39c>
lea    (%rbx,%r8,4),%rcx
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
jae    154c <wrap+0x42c>
lea    (%r8,%rdx,1),%rcx
lea    (%rbx,%rcx,4),%rcx
cmp    %rcx,%rax
jae    154c <wrap+0x42c>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rdx,%rsi
mov    %rdx,%rdi
and    $0x3,%rdi
je     14f5 <wrap+0x3d5>
lea    (%rbx,%r8,4),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    14e0 <wrap+0x3c0>
cmp    $0x3,%rsi
jb     1624 <wrap+0x504>
lea    (%rbx,%r8,4),%rsi
add    $0xc,%rsi
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rcx,4)
movss  0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1510 <wrap+0x3f0>
jmp    1624 <wrap+0x504>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rsi
jae    1571 <wrap+0x451>
xor    %esi,%esi
jmp    15d9 <wrap+0x4b9>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,4),%rbp
add    $0x70,%rbp
xor    %esi,%esi
nop
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups %xmm0,-0x70(%rbp,%rsi,4)
movups %xmm1,-0x60(%rbp,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm1
movups %xmm0,-0x50(%rbp,%rsi,4)
movups %xmm1,-0x40(%rbp,%rsi,4)
movups 0x40(%rax,%rsi,4),%xmm0
movups 0x50(%rax,%rsi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,4)
movups %xmm1,-0x20(%rbp,%rsi,4)
movups 0x60(%rax,%rsi,4),%xmm0
movups 0x70(%rax,%rsi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,4)
movups %xmm1,0x0(%rbp,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1580 <wrap+0x460>
test   %r9,%r9
je     161b <wrap+0x4fb>
lea    (%rsi,%r8,1),%rdi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r9
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1600 <wrap+0x4e0>
cmp    %rdx,%rcx
jne    14be <wrap+0x39e>
mov    %rax,%rdi
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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