#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*/ coinst_(int *, float *, int *, int *, float *, float *,
                           float *, float *, int *);
int /*<<< orphan*/ free(float *);
int ipow_(int *);
scalar_t__ malloc(int);
void FilterTrace(int nsamp, float srate, int which_fil, int dec_type,
                 float *data, float fl, float fh) {
  int npts, ind, ind1, n2, i, errc;
  float dt, low_f, hi_f;
  float *cw, *c1;
  npts = nsamp;
  ind = which_fil;
  ind1 = dec_type;
  low_f = fl;
  hi_f = fh;
  n2 = ipow_(&npts);
  dt = (float)1 / srate;
  cw = (float *)malloc(sizeof(double) * (n2 + 10));
  c1 = (float *)malloc(sizeof(float) * (n2 + 10));
  for (i = 0; i < nsamp; i++) {
    c1[i] = data[i];
  }
  coinst_(&npts, &dt, &ind1, &ind, c1, cw, &low_f, &hi_f, &errc);
  for (i = 0; i < nsamp; i++) {
    data[i] = c1[i];
  }
  free(c1);
  free(cw);
  return;
}


x86 assembly (clang, -O0):
<FilterTrace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
movss  %xmm0,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
movss  %xmm2,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
lea    -0x24(%rbp),%rdi
call   1040 <ipow_@plt>
mov    %eax,-0x30(%rbp)
movss  0xe62(%rip),%xmm0
divss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xa,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0xa,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1211 <FilterTrace+0xd1>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11dd <FilterTrace+0x9d>
mov    -0x58(%rbp),%r8
mov    -0x50(%rbp),%r9
lea    -0x24(%rbp),%rdi
lea    -0x3c(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
lea    -0x28(%rbp),%rcx
lea    -0x40(%rbp),%r11
lea    -0x44(%rbp),%r10
lea    -0x38(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1060 <coinst_@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1283 <FilterTrace+0x143>
mov    -0x58(%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    124f <FilterTrace+0x10f>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FilterTrace>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %rcx,%r15
movss  %xmm0,0x18(%rsp)
mov    %edi,%r12d
mov    %edi,(%rsp)
mov    %esi,0x14(%rsp)
mov    %edx,0x10(%rsp)
movss  %xmm1,0x8(%rsp)
movss  %xmm2,0x4(%rsp)
mov    %rsp,%rdi
call   1040 <ipow_@plt>
mov    %eax,%ebx
movss  0xe7f(%rip),%xmm0
divss  0x18(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
lea    0x50(,%rbx,8),%edi
call   1050 <malloc@plt>
mov    %rax,%r14
lea    0x28(,%rbx,4),%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
test   %r12d,%r12d
jle    1250 <FilterTrace+0x110>
mov    %r12d,%ebp
cmp    $0x8,%r12d
jb     11d7 <FilterTrace+0x97>
lea    (%r15,%rbp,4),%rax
cmp    %rax,%rbx
jae    128f <FilterTrace+0x14f>
lea    (%rbx,%rbp,4),%rax
cmp    %r15,%rax
jbe    128f <FilterTrace+0x14f>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1205 <FilterTrace+0xc5>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11f0 <FilterTrace+0xb0>
cmp    $0x3,%rcx
jb     1364 <FilterTrace+0x224>
nop
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x8(%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%rbx,%rax,4)
movss  0xc(%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1210 <FilterTrace+0xd0>
jmp    1364 <FilterTrace+0x224>
sub    $0x8,%rsp
lea    0x24(%rsp),%rax
lea    0xc(%rsp),%rbp
lea    0x10(%rsp),%r10
lea    0x8(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x1c(%rsp),%rcx
mov    %rbx,%r8
mov    %r14,%r9
push   %rax
push   %rbp
push   %r10
call   1060 <coinst_@plt>
add    $0x20,%rsp
jmp    1514 <FilterTrace+0x3d4>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    12b2 <FilterTrace+0x172>
xor    %esi,%esi
jmp    1320 <FilterTrace+0x1e0>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%rbx,%rsi,4)
movups %xmm1,0x10(%rbx,%rsi,4)
movups 0x20(%r15,%rsi,4),%xmm0
movups 0x30(%r15,%rsi,4),%xmm1
movups %xmm0,0x20(%rbx,%rsi,4)
movups %xmm1,0x30(%rbx,%rsi,4)
movups 0x40(%r15,%rsi,4),%xmm0
movups 0x50(%r15,%rsi,4),%xmm1
movups %xmm0,0x40(%rbx,%rsi,4)
movups %xmm1,0x50(%rbx,%rsi,4)
movups 0x60(%r15,%rsi,4),%xmm0
movups 0x70(%r15,%rsi,4),%xmm1
movups %xmm0,0x60(%rbx,%rsi,4)
movups %xmm1,0x70(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    12c0 <FilterTrace+0x180>
test   %rcx,%rcx
je     135b <FilterTrace+0x21b>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r15,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   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,%rcx
jne    1340 <FilterTrace+0x200>
cmp    %rbp,%rax
jne    11d9 <FilterTrace+0x99>
sub    $0x8,%rsp
lea    0x24(%rsp),%rax
lea    0xc(%rsp),%r10
lea    0x10(%rsp),%r11
lea    0x8(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x18(%rsp),%rdx
lea    0x1c(%rsp),%rcx
mov    %rbx,%r8
mov    %r14,%r9
push   %rax
push   %r10
push   %r11
call   1060 <coinst_@plt>
add    $0x20,%rsp
test   %r12d,%r12d
jle    1514 <FilterTrace+0x3d4>
cmp    $0x8,%r12d
jb     13c8 <FilterTrace+0x288>
lea    (%rbx,%rbp,4),%rax
cmp    %r15,%rax
jbe    1440 <FilterTrace+0x300>
lea    (%r15,%rbp,4),%rax
cmp    %rax,%rbx
jae    1440 <FilterTrace+0x300>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     13f5 <FilterTrace+0x2b5>
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    13e0 <FilterTrace+0x2a0>
cmp    $0x3,%rcx
jb     1514 <FilterTrace+0x3d4>
nop
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x4(%r15,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,0x8(%r15,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,0xc(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1400 <FilterTrace+0x2c0>
jmp    1514 <FilterTrace+0x3d4>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1463 <FilterTrace+0x323>
xor    %esi,%esi
jmp    14d0 <FilterTrace+0x390>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups 0x20(%rbx,%rsi,4),%xmm0
movups 0x30(%rbx,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups 0x40(%rbx,%rsi,4),%xmm0
movups 0x50(%rbx,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movups 0x60(%rbx,%rsi,4),%xmm0
movups 0x70(%rbx,%rsi,4),%xmm1
movups %xmm0,0x60(%r15,%rsi,4)
movups %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1470 <FilterTrace+0x330>
test   %rcx,%rcx
je     150b <FilterTrace+0x3cb>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   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,%rcx
jne    14f0 <FilterTrace+0x3b0>
cmp    %rbp,%rax
jne    13ca <FilterTrace+0x28a>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @FilterTrace(i32 %0, float %1, i32 %2, i32 %3, float* nocapture %4, float %5, float %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = bitcast i32* %8 to i8*
%16 = bitcast i32* %9 to i8*
%17 = bitcast i32* %10 to i8*
%18 = bitcast i32* %11 to i8*
%19 = bitcast float* %12 to i8*
%20 = bitcast float* %13 to i8*
%21 = bitcast float* %14 to i8*
store i32 %0, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store float %5, float* %13
store float %6, float* %14
%22 = call i32 @ipow_(i32* %8)
%23 = fdiv float 1.000000e+00, %1
store float %23, float* %12
%24 = add nsw i32 %22, 10
%25 = shl i32 %24, 3
%26 = call i64 @malloc(i32 %25)
%27 = inttoptr i64 %26 to float*
%28 = shl i32 %24, 2
%29 = call i64 @malloc(i32 %28)
%30 = inttoptr i64 %29 to float*
%31 = inttoptr i64 %29 to i8*
%32 = icmp sgt i32 %0, 0
br i1 %32, label %35, label %33
33: ; preds = %7
%34 = call i32 @coinst_(i32* %8, float* %12, i32* %10, i32* %9, float* %30, float* %27, float* %13, float* %14, i32* %11)
br label %289
35: ; preds = %7
%36 = zext i32 %0 to i64
%37 = icmp ult i32 %0, 8
br i1 %37, label %124, label %38
38: ; preds = %35
%39 = getelementptr float, float* %30, i64 %36
%40 = getelementptr float, float* %4, i64 %36
%41 = bitcast float* %40 to i8*
%42 = icmp ult i8* %31, %41
%43 = icmp ugt float* %39, %4
%44 = and i1 %42, %43
br i1 %44, label %124, label %45
45: ; preds = %38
%46 = and i64 %36, 4294967288
%47 = add nsw i64 %46, -8
%48 = lshr exact i64 %47, 3
%49 = add nuw nsw i64 %48, 1
%50 = and i64 %49, 3
%51 = icmp ult i64 %47, 24
br i1 %51, label %103, label %52
52: ; preds = %45
%53 = and i64 %49, 4611686018427387900
br label %54
54: ; preds = %54, %52
%55 = phi i64 [ 0, %52 ], [ %100, %54 ]
%56 = phi i64 [ 0, %52 ], [ %101, %54 ]
%57 = getelementptr inbounds float, float* %4, i64 %55
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds float, float* %57, i64 4
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = getelementptr inbounds float, float* %30, i64 %55
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %59, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> %62, <4 x float>* %66
%67 = or i64 %55, 8
%68 = getelementptr inbounds float, float* %4, i64 %67
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %68, i64 4
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr inbounds float, float* %30, i64 %67
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %70, <4 x float>* %75
%76 = getelementptr inbounds float, float* %74, i64 4
%77 = bitcast float* %76 to <4 x float>*
store <4 x float> %73, <4 x float>* %77
%78 = or i64 %55, 16
%79 = getelementptr inbounds float, float* %4, i64 %78
%80 = bitcast float* %79 to <4 x float>*
%81 = load <4 x float>, <4 x float>* %80
%82 = getelementptr inbounds float, float* %79, i64 4
%83 = bitcast float* %82 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = getelementptr inbounds float, float* %30, i64 %78
%86 = bitcast float* %85 to <4 x float>*
store <4 x float> %81, <4 x float>* %86
%87 = getelementptr inbounds float, float* %85, i64 4
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %84, <4 x float>* %88
%89 = or i64 %55, 24
%90 = getelementptr inbounds float, float* %4, i64 %89
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = getelementptr inbounds float, float* %90, i64 4
%94 = bitcast float* %93 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = getelementptr inbounds float, float* %30, i64 %89
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %92, <4 x float>* %97
%98 = getelementptr inbounds float, float* %96, i64 4
%99 = bitcast float* %98 to <4 x float>*
store <4 x float> %95, <4 x float>* %99
%100 = add nuw i64 %55, 32
%101 = add i64 %56, 4
%102 = icmp eq i64 %101, %53
br i1 %102, label %103, label %54
103: ; preds = %54, %45
%104 = phi i64 [ 0, %45 ], [ %100, %54 ]
%105 = icmp eq i64 %50, 0
br i1 %105, label %122, label %106
106: ; preds = %103, %106
%107 = phi i64 [ %119, %106 ], [ %104, %103 ]
%108 = phi i64 [ %120, %106 ], [ 0, %103 ]
%109 = getelementptr inbounds float, float* %4, i64 %107
%110 = bitcast float* %109 to <4 x float>*
%111 = load <4 x float>, <4 x float>* %110
%112 = getelementptr inbounds float, float* %109, i64 4
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = getelementptr inbounds float, float* %30, i64 %107
%116 = bitcast float* %115 to <4 x float>*
store <4 x float> %111, <4 x float>* %116
%117 = getelementptr inbounds float, float* %115, i64 4
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %114, <4 x float>* %118
%119 = add nuw i64 %107, 8
%120 = add i64 %108, 1
%121 = icmp eq i64 %120, %50
br i1 %121, label %122, label %106
122: ; preds = %106, %103
%123 = icmp eq i64 %46, %36
br i1 %123, label %161, label %124
124: ; preds = %38, %35, %122
%125 = phi i64 [ 0, %38 ], [ 0, %35 ], [ %46, %122 ]
%126 = xor i64 %125, -1
%127 = add nsw i64 %126, %36
%128 = and i64 %36, 3
%129 = icmp eq i64 %128, 0
br i1 %129, label %139, label %130
130: ; preds = %124, %130
%131 = phi i64 [ %136, %130 ], [ %125, %124 ]
%132 = phi i64 [ %137, %130 ], [ 0, %124 ]
%133 = getelementptr inbounds float, float* %4, i64 %131
%134 = load float, float* %133
%135 = getelementptr inbounds float, float* %30, i64 %131
store float %134, float* %135
%136 = add nuw nsw i64 %131, 1
%137 = add i64 %132, 1
%138 = icmp eq i64 %137, %128
br i1 %138, label %139, label %130
139: ; preds = %130, %124
%140 = phi i64 [ %125, %124 ], [ %136, %130 ]
%141 = icmp ult i64 %127, 3
br i1 %141, label %161, label %142
142: ; preds = %139, %142
%143 = phi i64 [ %159, %142 ], [ %140, %139 ]
%144 = getelementptr inbounds float, float* %4, i64 %143
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %30, i64 %143
store float %145, float* %146
%147 = add nuw nsw i64 %143, 1
%148 = getelementptr inbounds float, float* %4, i64 %147
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %30, i64 %147
store float %149, float* %150
%151 = add nuw nsw i64 %143, 2
%152 = getelementptr inbounds float, float* %4, i64 %151
%153 = load float, float* %152
%154 = getelementptr inbounds float, float* %30, i64 %151
store float %153, float* %154
%155 = add nuw nsw i64 %143, 3
%156 = getelementptr inbounds float, float* %4, i64 %155
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %30, i64 %155
store float %157, float* %158
%159 = add nuw nsw i64 %143, 4
%160 = icmp eq i64 %159, %36
br i1 %160, label %161, label %142
161: ; preds = %139, %142, %122
%162 = call i32 @coinst_(i32* %8, float* %12, i32* %10, i32* %9, float* %30, float* %27, float* %13, float* %14, i32* %11)
br i1 %32, label %163, label %289
163: ; preds = %161
%164 = zext i32 %0 to i64
%165 = icmp ult i32 %0, 8
br i1 %165, label %252, label %166
166: ; preds = %163
%167 = getelementptr float, float* %4, i64 %36
%168 = bitcast float* %167 to i8*
%169 = getelementptr float, float* %30, i64 %36
%170 = icmp ugt float* %169, %4
%171 = icmp ult i8* %31, %168
%172 = and i1 %170, %171
br i1 %172, label %252, label %173
173: ; preds = %166
%174 = and i64 %36, 4294967288
%175 = add nsw i64 %174, -8
%176 = lshr exact i64 %175, 3
%177 = add nuw nsw i64 %176, 1
%178 = and i64 %177, 3
%179 = icmp ult i64 %175, 24
br i1 %179, label %231, label %180
180: ; preds = %173
%181 = and i64 %177, 4611686018427387900
br label %182
182: ; preds = %182, %180
%183 = phi i64 [ 0, %180 ], [ %228, %182 ]
%184 = phi i64 [ 0, %180 ], [ %229, %182 ]
%185 = getelementptr inbounds float, float* %30, i64 %183
%186 = bitcast float* %185 to <4 x float>*
%187 = load <4 x float>, <4 x float>* %186
%188 = getelementptr inbounds float, float* %185, i64 4
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = getelementptr inbounds float, float* %4, i64 %183
%192 = bitcast float* %191 to <4 x float>*
store <4 x float> %187, <4 x float>* %192
%193 = getelementptr inbounds float, float* %191, i64 4
%194 = bitcast float* %193 to <4 x float>*
store <4 x float> %190, <4 x float>* %194
%195 = or i64 %183, 8
%196 = getelementptr inbounds float, float* %30, i64 %195
%197 = bitcast float* %196 to <4 x float>*
%198 = load <4 x float>, <4 x float>* %197
%199 = getelementptr inbounds float, float* %196, i64 4
%200 = bitcast float* %199 to <4 x float>*
%201 = load <4 x float>, <4 x float>* %200
%202 = getelementptr inbounds float, float* %4, i64 %195
%203 = bitcast float* %202 to <4 x float>*
store <4 x float> %198, <4 x float>* %203
%204 = getelementptr inbounds float, float* %202, i64 4
%205 = bitcast float* %204 to <4 x float>*
store <4 x float> %201, <4 x float>* %205
%206 = or i64 %183, 16
%207 = getelementptr inbounds float, float* %30, i64 %206
%208 = bitcast float* %207 to <4 x float>*
%209 = load <4 x float>, <4 x float>* %208
%210 = getelementptr inbounds float, float* %207, i64 4
%211 = bitcast float* %210 to <4 x float>*
%212 = load <4 x float>, <4 x float>* %211
%213 = getelementptr inbounds float, float* %4, i64 %206
%214 = bitcast float* %213 to <4 x float>*
store <4 x float> %209, <4 x float>* %214
%215 = getelementptr inbounds float, float* %213, i64 4
%216 = bitcast float* %215 to <4 x float>*
store <4 x float> %212, <4 x float>* %216
%217 = or i64 %183, 24
%218 = getelementptr inbounds float, float* %30, i64 %217
%219 = bitcast float* %218 to <4 x float>*
%220 = load <4 x float>, <4 x float>* %219
%221 = getelementptr inbounds float, float* %218, i64 4
%222 = bitcast float* %221 to <4 x float>*
%223 = load <4 x float>, <4 x float>* %222
%224 = getelementptr inbounds float, float* %4, i64 %217
%225 = bitcast float* %224 to <4 x float>*
store <4 x float> %220, <4 x float>* %225
%226 = getelementptr inbounds float, float* %224, i64 4
%227 = bitcast float* %226 to <4 x float>*
store <4 x float> %223, <4 x float>* %227
%228 = add nuw i64 %183, 32
%229 = add i64 %184, 4
%230 = icmp eq i64 %229, %181
br i1 %230, label %231, label %182
231: ; preds = %182, %173
%232 = phi i64 [ 0, %173 ], [ %228, %182 ]
%233 = icmp eq i64 %178, 0
br i1 %233, label %250, label %234
234: ; preds = %231, %234
%235 = phi i64 [ %247, %234 ], [ %232, %231 ]
%236 = phi i64 [ %248, %234 ], [ 0, %231 ]
%237 = getelementptr inbounds float, float* %30, i64 %235
%238 = bitcast float* %237 to <4 x float>*
%239 = load <4 x float>, <4 x float>* %238
%240 = getelementptr inbounds float, float* %237, i64 4
%241 = bitcast float* %240 to <4 x float>*
%242 = load <4 x float>, <4 x float>* %241
%243 = getelementptr inbounds float, float* %4, i64 %235
%244 = bitcast float* %243 to <4 x float>*
store <4 x float> %239, <4 x float>* %244
%245 = getelementptr inbounds float, float* %243, i64 4
%246 = bitcast float* %245 to <4 x float>*
store <4 x float> %242, <4 x float>* %246
%247 = add nuw i64 %235, 8
%248 = add i64 %236, 1
%249 = icmp eq i64 %248, %178
br i1 %249, label %250, label %234
250: ; preds = %234, %231
%251 = icmp eq i64 %174, %36
br i1 %251, label %289, label %252
252: ; preds = %166, %163, %250
%253 = phi i64 [ 0, %166 ], [ 0, %163 ], [ %174, %250 ]
%254 = xor i64 %253, -1
%255 = add nsw i64 %254, %36
%256 = and i64 %36, 3
%257 = icmp eq i64 %256, 0
br i1 %257, label %267, label %258
258: ; preds = %252, %258
%259 = phi i64 [ %264, %258 ], [ %253, %252 ]
%260 = phi i64 [ %265, %258 ], [ 0, %252 ]
%261 = getelementptr inbounds float, float* %30, i64 %259
%262 = load float, float* %261
%263 = getelementptr inbounds float, float* %4, i64 %259
store float %262, float* %263
%264 = add nuw nsw i64 %259, 1
%265 = add i64 %260, 1
%266 = icmp eq i64 %265, %256
br i1 %266, label %267, label %258
267: ; preds = %258, %252
%268 = phi i64 [ %253, %252 ], [ %264, %258 ]
%269 = icmp ult i64 %255, 3
br i1 %269, label %289, label %270
270: ; preds = %267, %270
%271 = phi i64 [ %287, %270 ], [ %268, %267 ]
%272 = getelementptr inbounds float, float* %30, i64 %271
%273 = load float, float* %272
%274 = getelementptr inbounds float, float* %4, i64 %271
store float %273, float* %274
%275 = add nuw nsw i64 %271, 1
%276 = getelementptr inbounds float, float* %30, i64 %275
%277 = load float, float* %276
%278 = getelementptr inbounds float, float* %4, i64 %275
store float %277, float* %278
%279 = add nuw nsw i64 %271, 2
%280 = getelementptr inbounds float, float* %30, i64 %279
%281 = load float, float* %280
%282 = getelementptr inbounds float, float* %4, i64 %279
store float %281, float* %282
%283 = add nuw nsw i64 %271, 3
%284 = getelementptr inbounds float, float* %30, i64 %283
%285 = load float, float* %284
%286 = getelementptr inbounds float, float* %4, i64 %283
store float %285, float* %286
%287 = add nuw nsw i64 %271, 4
%288 = icmp eq i64 %287, %164
br i1 %288, label %289, label %270
289: ; preds = %267, %270, %250, %33, %161
%290 = call i32 @free(float* %30)
%291 = call i32 @free(float* %27)
ret void
}