#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 ConvertInstr(int nsamp, float srate, int instr_type, float *data) {
  int npts, ind, ind1, n2, i, errc;
  float dt, dum;
  float *cw, *c1;
  ind1 = 0;
  npts = nsamp;
  ind = instr_type;
  n2 = ipow_(&npts);
  dum = 0.0;
  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, &ind, &ind1, c1, cw, &dum, &dum, &errc);
  for (i = 0; i < nsamp; i++) {
    data[i] = c1[i];
  }
  free(c1);
  free(cw);
  return;
}


x86 assembly (clang, -O0):
<ConvertInstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
movss  %xmm0,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
lea    -0x1c(%rbp),%rdi
call   1040 <ipow_@plt>
mov    %eax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xe7a(%rip),%xmm0
divss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0xa,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%eax
add    $0xa,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f9 <ConvertInstr+0xb9>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c5 <ConvertInstr+0x85>
mov    -0x48(%rbp),%r8
mov    -0x40(%rbp),%r9
lea    -0x1c(%rbp),%rdi
lea    -0x34(%rbp),%rsi
lea    -0x20(%rbp),%rdx
lea    -0x24(%rbp),%rcx
lea    -0x38(%rbp),%r10
lea    -0x30(%rbp),%rax
mov    %r10,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1060 <coinst_@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1267 <ConvertInstr+0x127>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1233 <ConvertInstr+0xf3>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConvertInstr>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %rdx,%r15
movss  %xmm0,0x18(%rsp)
mov    %edi,%r12d
movl   $0x0,0x10(%rsp)
mov    %edi,0x4(%rsp)
mov    %esi,0x14(%rsp)
lea    0x4(%rsp),%rdi
call   1040 <ipow_@plt>
mov    %eax,%ebx
movl   $0x0,0x8(%rsp)
movss  0xe7c(%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 <ConvertInstr+0x110>
mov    %r12d,%ebp
cmp    $0x8,%r12d
jb     11da <ConvertInstr+0x9a>
lea    (%r15,%rbp,4),%rax
cmp    %rax,%rbx
jae    1289 <ConvertInstr+0x149>
lea    (%rbx,%rbp,4),%rax
cmp    %r15,%rax
jbe    1289 <ConvertInstr+0x149>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1205 <ConvertInstr+0xc5>
xchg   %ax,%ax
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11f0 <ConvertInstr+0xb0>
cmp    $0x3,%rcx
jb     1364 <ConvertInstr+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 <ConvertInstr+0xd0>
jmp    1364 <ConvertInstr+0x224>
sub    $0x8,%rsp
lea    0x24(%rsp),%rax
lea    0x10(%rsp),%rbp
lea    0xc(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x1c(%rsp),%rdx
lea    0x18(%rsp),%rcx
mov    %rbx,%r8
mov    %r14,%r9
push   %rax
push   %rbp
push   %rbp
call   1060 <coinst_@plt>
add    $0x20,%rsp
jmp    1514 <ConvertInstr+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    12ac <ConvertInstr+0x16c>
xor    %esi,%esi
jmp    1320 <ConvertInstr+0x1e0>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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 <ConvertInstr+0x180>
test   %rcx,%rcx
je     135b <ConvertInstr+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 <ConvertInstr+0x200>
cmp    %rbp,%rax
jne    11dc <ConvertInstr+0x9c>
sub    $0x8,%rsp
lea    0x24(%rsp),%r10
lea    0x10(%rsp),%rax
lea    0xc(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x1c(%rsp),%rdx
lea    0x18(%rsp),%rcx
mov    %rbx,%r8
mov    %r14,%r9
push   %r10
push   %rax
push   %rax
call   1060 <coinst_@plt>
add    $0x20,%rsp
test   %r12d,%r12d
jle    1514 <ConvertInstr+0x3d4>
cmp    $0x8,%r12d
jb     13c2 <ConvertInstr+0x282>
lea    (%rbx,%rbp,4),%rax
cmp    %r15,%rax
jbe    1440 <ConvertInstr+0x300>
lea    (%r15,%rbp,4),%rax
cmp    %rax,%rbx
jae    1440 <ConvertInstr+0x300>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     13f5 <ConvertInstr+0x2b5>
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    13e0 <ConvertInstr+0x2a0>
cmp    $0x3,%rcx
jb     1514 <ConvertInstr+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 <ConvertInstr+0x2c0>
jmp    1514 <ConvertInstr+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 <ConvertInstr+0x323>
xor    %esi,%esi
jmp    14d0 <ConvertInstr+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 <ConvertInstr+0x330>
test   %rcx,%rcx
je     150b <ConvertInstr+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 <ConvertInstr+0x3b0>
cmp    %rbp,%rax
jne    13c4 <ConvertInstr+0x284>
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 @ConvertInstr(i32 %0, float %1, i32 %2, float* %3) {
%5 = alloca i32
%6 = alloca float
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float*
%18 = alloca float*
store i32 %0, i32* %5
store float %1, float* %6
store i32 %2, i32* %7
store float* %3, float** %8
store i32 0, i32* %11
%19 = load i32, i32* %5
store i32 %19, i32* %9
%20 = load i32, i32* %7
store i32 %20, i32* %10
%21 = call i32 @ipow_(i32* %9)
store i32 %21, i32* %12
store float 0.000000e+00, float* %16
%22 = load float, float* %6
%23 = fdiv float 1.000000e+00, %22
store float %23, float* %15
%24 = load i32, i32* %12
%25 = add nsw i32 %24, 10
%26 = sext i32 %25 to i64
%27 = mul i64 8, %26
%28 = trunc i64 %27 to i32
%29 = call i64 @malloc(i32 %28)
%30 = inttoptr i64 %29 to float*
store float* %30, float** %17
%31 = load i32, i32* %12
%32 = add nsw i32 %31, 10
%33 = sext i32 %32 to i64
%34 = mul i64 4, %33
%35 = trunc i64 %34 to i32
%36 = call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to float*
store float* %37, float** %18
store i32 0, i32* %13
br label %38
38: ; preds = %52, %4
%39 = load i32, i32* %13
%40 = load i32, i32* %5
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %55
42: ; preds = %38
%43 = load float*, float** %8
%44 = load i32, i32* %13
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %43, i64 %45
%47 = load float, float* %46
%48 = load float*, float** %18
%49 = load i32, i32* %13
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %48, i64 %50
store float %47, float* %51
br label %52
52: ; preds = %42
%53 = load i32, i32* %13
%54 = add nsw i32 %53, 1
store i32 %54, i32* %13
br label %38
55: ; preds = %38
%56 = load float*, float** %18
%57 = load float*, float** %17
%58 = call i32 @coinst_(i32* %9, float* %15, i32* %10, i32* %11, float* %56, float* %57, float* %16, float* %16, i32* %14)
store i32 0, i32* %13
br label %59
59: ; preds = %73, %55
%60 = load i32, i32* %13
%61 = load i32, i32* %5
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %76
63: ; preds = %59
%64 = load float*, float** %18
%65 = load i32, i32* %13
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %8
%70 = load i32, i32* %13
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %69, i64 %71
store float %68, float* %72
br label %73
73: ; preds = %63
%74 = load i32, i32* %13
%75 = add nsw i32 %74, 1
store i32 %75, i32* %13
br label %59
76: ; preds = %59
%77 = load float*, float** %18
%78 = call i32 @free(float* %77)
%79 = load float*, float** %17
%80 = call i32 @free(float* %79)
ret void
}

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