#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 */
float fabs(float);
int get_nchan_from_depth(int);
scalar_t__ malloc(int);
void burst_setup_channel_mapping(size_t *chan_map, size_t nfreq, float freq0,
                                 float delta_f, int depth) {
  int nchan = get_nchan_from_depth(depth);
  int i, j;
  float l0 = 1.0 / (freq0 + 0.5 * delta_f);
  l0 = l0 * l0;
  float l1 = 1.0 / (freq0 + (nfreq - 0.5) * delta_f);
  l1 = l1 * l1;
  if (l0 > l1) {
    float tmp = l0;
    l0 = l1;
    l1 = tmp;
  }
  float *out_chans = (float *)malloc(sizeof(float) * nchan);
  float dl = (l1 - l0) / (nchan - 1);
  for (i = 0; i < nchan; i++)
    out_chans[i] = l0 + dl * i;
  for (i = 0; i < nfreq; i++) {
    float myl = 1.0 / (freq0 + (0.5 + i) * delta_f);
    myl = myl * myl;
    int jmin = -1;
    float minerr = 1e30;
    for (j = 0; j < nchan; j++) {
      float curerr = fabs(myl - out_chans[j]);
      if (curerr < minerr) {
        minerr = curerr;
        jmin = j;
      }
    }
    chan_map[i] = jmin;
  }
}


x86 assembly (clang, -O0):
<burst_setup_channel_mapping>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%edi
call   1050 <get_nchan_from_depth@plt>
mov    %eax,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe96(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe7e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xe63(%rip),%xmm2
movq   -0x10(%rbp),%xmm1
punpckldq %xmm2,%xmm1
movapd 0xe62(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0xe33(%rip),%xmm2
subsd  %xmm2,%xmm1
movss  -0x18(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe0e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    123b <burst_setup_channel_mapping+0x10b>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12b0 <burst_setup_channel_mapping+0x180>
movss  -0x2c(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1272 <burst_setup_channel_mapping+0x142>
movl   $0x0,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    13ab <burst_setup_channel_mapping+0x27b>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x24(%rbp),%xmm2
movsd  0xd2d(%rip),%xmm1
addsd  %xmm2,%xmm1
movss  -0x18(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd08(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0xffffffff,-0x4c(%rbp)
movss  0xd0d(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    138d <burst_setup_channel_mapping+0x25d>
movss  -0x48(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    137a <burst_setup_channel_mapping+0x24a>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    137f <burst_setup_channel_mapping+0x24f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    132f <burst_setup_channel_mapping+0x1ff>
movslq -0x4c(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b7 <burst_setup_channel_mapping+0x187>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<burst_setup_channel_mapping>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
movss  %xmm1,0x10(%rsp)
movss  %xmm0,(%rsp)
mov    %rsi,%r15
mov    %rdi,%r14
mov    %edx,%edi
call   1040 <get_nchan_from_depth@plt>
mov    %eax,%r12d
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm0,(%rsp)
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x0(,%r12,4),%edi
call   1030 <malloc@plt>
movapd 0x10(%rsp),%xmm12
movapd (%rsp),%xmm11
mov    %r12d,%r8d
test   %r12d,%r12d
jle    132d <burst_setup_channel_mapping+0x20d>
movq   %r15,%xmm0
punpckldq 0xe6b(%rip),%xmm0
subpd  0xe73(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
addsd  0xeef(%rip),%xmm1
movapd %xmm12,%xmm0
unpcklpd %xmm1,%xmm0
movapd 0xe5e(%rip),%xmm1
unpcklpd %xmm12,%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm11,%xmm0
unpcklpd %xmm11,%xmm0
addpd  %xmm1,%xmm0
movapd 0xe4f(%rip),%xmm1
divpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm2
mulps  %xmm2,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm1
maxss  %xmm0,%xmm1
lea    -0x1(%r12),%ecx
cvtsi2ss %ecx,%xmm3
minss  %xmm2,%xmm0
subss  %xmm0,%xmm1
divss  %xmm3,%xmm1
cmp    $0x8,%r12d
jae    121c <burst_setup_channel_mapping+0xfc>
xor    %edx,%edx
jmp    1310 <burst_setup_channel_mapping+0x1f0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1422 <burst_setup_channel_mapping+0x302>
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
movdqa 0xde9(%rip),%xmm6
xor    %esi,%esi
movdqa 0xdee(%rip),%xmm8
movdqa 0xdf5(%rip),%xmm9
movdqa 0xdfc(%rip),%xmm10
movdqa 0xe04(%rip),%xmm5
nopl   0x0(%rax)
movdqa %xmm6,%xmm4
paddd  %xmm8,%xmm4
cvtdq2ps %xmm6,%xmm7
cvtdq2ps %xmm4,%xmm4
mulps  %xmm2,%xmm7
addps  %xmm3,%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm7,(%rax,%rsi,4)
movups %xmm4,0x10(%rax,%rsi,4)
movdqa %xmm6,%xmm4
paddd  %xmm9,%xmm4
movdqa %xmm6,%xmm7
paddd  %xmm10,%xmm7
cvtdq2ps %xmm4,%xmm4
cvtdq2ps %xmm7,%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm7
addps  %xmm3,%xmm7
movups %xmm4,0x20(%rax,%rsi,4)
movups %xmm7,0x30(%rax,%rsi,4)
add    $0x10,%rsi
paddd  %xmm5,%xmm6
add    $0xfffffffffffffffe,%rcx
jne    1280 <burst_setup_channel_mapping+0x160>
test   $0x1,%dil
je     1309 <burst_setup_channel_mapping+0x1e9>
cvtdq2ps %xmm6,%xmm4
paddd  0xd5f(%rip),%xmm6
cvtdq2ps %xmm6,%xmm5
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,(%rax,%rsi,4)
movups %xmm5,0x10(%rax,%rsi,4)
cmp    %r8,%rdx
je     132d <burst_setup_channel_mapping+0x20d>
xchg   %ax,%ax
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1310 <burst_setup_channel_mapping+0x1f0>
test   %r15,%r15
je     1416 <burst_setup_channel_mapping+0x2f6>
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %esi,%esi
movsd  0xd62(%rip),%xmm0
movsd  0xd62(%rip),%xmm1
movss  0xd62(%rip),%xmm2
movaps 0xd33(%rip),%xmm3
jmp    1379 <burst_setup_channel_mapping+0x259>
nop
mov    $0xffffffff,%edi
movslq %edi,%rcx
mov    %rcx,(%r14,%rsi,8)
add    $0x1,%rsi
cmp    %r15,%rsi
je     1416 <burst_setup_channel_mapping+0x2f6>
xorps  %xmm4,%xmm4
cvtsi2sd %esi,%xmm4
addsd  %xmm0,%xmm4
test   %r12d,%r12d
jle    1360 <burst_setup_channel_mapping+0x240>
mulsd  %xmm12,%xmm4
addsd  %xmm11,%xmm4
movapd %xmm1,%xmm5
divsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
mulss  %xmm4,%xmm4
mov    $0xffffffff,%edi
xor    %ecx,%ecx
movaps %xmm2,%xmm5
cmp    $0x1,%r12d
je     13f9 <burst_setup_channel_mapping+0x2d9>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm4,%xmm6
subss  (%rax,%rcx,4),%xmm6
andps  %xmm3,%xmm6
ucomiss %xmm6,%xmm5
mov    %edi,%ebx
cmova  %ecx,%ebx
minss  %xmm5,%xmm6
movaps %xmm4,%xmm5
subss  0x4(%rax,%rcx,4),%xmm5
andps  %xmm3,%xmm5
ucomiss %xmm5,%xmm6
lea    0x1(%rcx),%edi
cmovbe %ebx,%edi
minss  %xmm6,%xmm5
add    $0x2,%rcx
cmp    %rdx,%rcx
jne    13c0 <burst_setup_channel_mapping+0x2a0>
test   $0x1,%r8b
je     1365 <burst_setup_channel_mapping+0x245>
subss  (%rax,%rcx,4),%xmm4
andps  %xmm3,%xmm4
ucomiss %xmm4,%xmm5
cmova  %ecx,%edi
jmp    1365 <burst_setup_channel_mapping+0x245>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movdqa 0xc16(%rip),%xmm6
xor    %esi,%esi
test   $0x1,%dil
jne    12e6 <burst_setup_channel_mapping+0x1c6>
jmp    1309 <burst_setup_channel_mapping+0x1e9>

LLVM IR (-O0):
define void @burst_setup_channel_mapping(i64* %0, i64 %1, float %2, float %3, i32 %4) {
%6 = alloca i64*
%7 = alloca i64
%8 = alloca float
%9 = alloca float
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float*
%18 = alloca float
%19 = alloca float
%20 = alloca i32
%21 = alloca float
%22 = alloca float
store i64* %0, i64** %6
store i64 %1, i64* %7
store float %2, float* %8
store float %3, float* %9
store i32 %4, i32* %10
%23 = load i32, i32* %10
%24 = call i32 @get_nchan_from_depth(i32 %23)
store i32 %24, i32* %11
%25 = load float, float* %8
%26 = fpext float %25 to double
%27 = load float, float* %9
%28 = fpext float %27 to double
%29 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %28, double %26)
%30 = fdiv double 1.000000e+00, %29
%31 = fptrunc double %30 to float
store float %31, float* %14
%32 = load float, float* %14
%33 = load float, float* %14
%34 = fmul float %32, %33
store float %34, float* %14
%35 = load float, float* %8
%36 = fpext float %35 to double
%37 = load i64, i64* %7
%38 = uitofp i64 %37 to double
%39 = fsub double %38, 5.000000e-01
%40 = load float, float* %9
%41 = fpext float %40 to double
%42 = call double @llvm.fmuladd.f64(double %39, double %41, double %36)
%43 = fdiv double 1.000000e+00, %42
%44 = fptrunc double %43 to float
store float %44, float* %15
%45 = load float, float* %15
%46 = load float, float* %15
%47 = fmul float %45, %46
store float %47, float* %15
%48 = load float, float* %14
%49 = load float, float* %15
%50 = fcmp ogt float %48, %49
br i1 %50, label %51, label %55
51: ; preds = %5
%52 = load float, float* %14
store float %52, float* %16
%53 = load float, float* %15
store float %53, float* %14
%54 = load float, float* %16
store float %54, float* %15
br label %55
55: ; preds = %51, %5
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = mul i64 4, %57
%59 = trunc i64 %58 to i32
%60 = call i64 @malloc(i32 %59)
%61 = inttoptr i64 %60 to float*
store float* %61, float** %17
%62 = load float, float* %15
%63 = load float, float* %14
%64 = fsub float %62, %63
%65 = load i32, i32* %11
%66 = sub nsw i32 %65, 1
%67 = sitofp i32 %66 to float
%68 = fdiv float %64, %67
store float %68, float* %18
store i32 0, i32* %12
br label %69
69: ; preds = %83, %55
%70 = load i32, i32* %12
%71 = load i32, i32* %11
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %86
73: ; preds = %69
%74 = load float, float* %14
%75 = load float, float* %18
%76 = load i32, i32* %12
%77 = sitofp i32 %76 to float
%78 = call float @llvm.fmuladd.f32(float %75, float %77, float %74)
%79 = load float*, float** %17
%80 = load i32, i32* %12
%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* %12
%85 = add nsw i32 %84, 1
store i32 %85, i32* %12
br label %69
86: ; preds = %69
store i32 0, i32* %12
br label %87
87: ; preds = %136, %86
%88 = load i32, i32* %12
%89 = sext i32 %88 to i64
%90 = load i64, i64* %7
%91 = icmp ult i64 %89, %90
br i1 %91, label %92, label %139
92: ; preds = %87
%93 = load float, float* %8
%94 = fpext float %93 to double
%95 = load i32, i32* %12
%96 = sitofp i32 %95 to double
%97 = fadd double 5.000000e-01, %96
%98 = load float, float* %9
%99 = fpext float %98 to double
%100 = call double @llvm.fmuladd.f64(double %97, double %99, double %94)
%101 = fdiv double 1.000000e+00, %100
%102 = fptrunc double %101 to float
store float %102, float* %19
%103 = load float, float* %19
%104 = load float, float* %19
%105 = fmul float %103, %104
store float %105, float* %19
store i32 -1, i32* %20
store float 0x46293E5940000000, float* %21
store i32 0, i32* %13
br label %106
106: ; preds = %126, %92
%107 = load i32, i32* %13
%108 = load i32, i32* %11
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %129
110: ; preds = %106
%111 = load float, float* %19
%112 = load float*, float** %17
%113 = load i32, i32* %13
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %112, i64 %114
%116 = load float, float* %115
%117 = fsub float %111, %116
%118 = call float @fabs(float %117)
store float %118, float* %22
%119 = load float, float* %22
%120 = load float, float* %21
%121 = fcmp olt float %119, %120
br i1 %121, label %122, label %125
122: ; preds = %110
%123 = load float, float* %22
store float %123, float* %21
%124 = load i32, i32* %13
store i32 %124, i32* %20
br label %125
125: ; preds = %122, %110
br label %126
126: ; preds = %125
%127 = load i32, i32* %13
%128 = add nsw i32 %127, 1
store i32 %128, i32* %13
br label %106
129: ; preds = %106
%130 = load i32, i32* %20
%131 = sext i32 %130 to i64
%132 = load i64*, i64** %6
%133 = load i32, i32* %12
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i64, i64* %132, i64 %134
store i64 %131, i64* %135
br label %136
136: ; preds = %129
%137 = load i32, i32* %12
%138 = add nsw i32 %137, 1
store i32 %138, i32* %12
br label %87
139: ; preds = %87
ret void
}

LLVM IR (-O2):
define void @burst_setup_channel_mapping(i64* nocapture writeonly %0, i64 %1, float %2, float %3, i32 %4) {
%6 = tail call i32 @get_nchan_from_depth(i32 %4)
%7 = fpext float %2 to double
%8 = fpext float %3 to double
%9 = uitofp i64 %1 to double
%10 = fadd double %9, -5.000000e-01
%11 = insertelement <2 x double> poison, double %8, i64 0
%12 = insertelement <2 x double> %11, double %10, i64 1
%13 = insertelement <2 x double> <double 5.000000e-01, double poison>, double %8, i64 1
%14 = insertelement <2 x double> poison, double %7, i64 0
%15 = shufflevector <2 x double> %14, <2 x double> poison, <2 x i32> zeroinitializer
%16 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %12, <2 x double> %13, <2 x double> %15)
%17 = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, %16
%18 = fptrunc <2 x double> %17 to <2 x float>
%19 = fmul <2 x float> %18, %18
%20 = extractelement <2 x float> %19, i64 0
%21 = extractelement <2 x float> %19, i64 1
%22 = fcmp ogt float %20, %21
%23 = select i1 %22, float %20, float %21
%24 = select i1 %22, float %21, float %20
%25 = shl i32 %6, 2
%26 = tail call i64 @malloc(i32 %25)
%27 = inttoptr i64 %26 to float*
%28 = fsub float %23, %24
%29 = add nsw i32 %6, -1
%30 = sitofp i32 %29 to float
%31 = fdiv float %28, %30
%32 = icmp sgt i32 %6, 0
br i1 %32, label %33, label %99
33: ; preds = %5
%34 = zext i32 %6 to i64
%35 = icmp ult i32 %6, 8
br i1 %35, label %97, label %36
36: ; preds = %33
%37 = and i64 %34, 4294967288
%38 = insertelement <4 x float> poison, float %31, i64 0
%39 = shufflevector <4 x float> %38, <4 x float> poison, <4 x i32> zeroinitializer
%40 = insertelement <4 x float> poison, float %24, i64 0
%41 = shufflevector <4 x float> %40, <4 x float> poison, <4 x i32> zeroinitializer
%42 = insertelement <4 x float> poison, float %31, i64 0
%43 = shufflevector <4 x float> %42, <4 x float> poison, <4 x i32> zeroinitializer
%44 = insertelement <4 x float> poison, float %24, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%46 = add nsw i64 %37, -8
%47 = lshr exact i64 %46, 3
%48 = add nuw nsw i64 %47, 1
%49 = and i64 %48, 1
%50 = icmp eq i64 %46, 0
br i1 %50, label %81, label %51
51: ; preds = %36
%52 = and i64 %48, 4611686018427387902
br label %53
53: ; preds = %53, %51
%54 = phi i64 [ 0, %51 ], [ %77, %53 ]
%55 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %51 ], [ %78, %53 ]
%56 = phi i64 [ 0, %51 ], [ %79, %53 ]
%57 = add <4 x i32> %55, <i32 4, i32 4, i32 4, i32 4>
%58 = sitofp <4 x i32> %55 to <4 x float>
%59 = sitofp <4 x i32> %57 to <4 x float>
%60 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %39, <4 x float> %58, <4 x float> %41)
%61 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %43, <4 x float> %59, <4 x float> %45)
%62 = getelementptr inbounds float, float* %27, i64 %54
%63 = bitcast float* %62 to <4 x float>*
store <4 x float> %60, <4 x float>* %63
%64 = getelementptr inbounds float, float* %62, i64 4
%65 = bitcast float* %64 to <4 x float>*
store <4 x float> %61, <4 x float>* %65
%66 = or i64 %54, 8
%67 = add <4 x i32> %55, <i32 8, i32 8, i32 8, i32 8>
%68 = add <4 x i32> %55, <i32 12, i32 12, i32 12, i32 12>
%69 = sitofp <4 x i32> %67 to <4 x float>
%70 = sitofp <4 x i32> %68 to <4 x float>
%71 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %39, <4 x float> %69, <4 x float> %41)
%72 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %43, <4 x float> %70, <4 x float> %45)
%73 = getelementptr inbounds float, float* %27, i64 %66
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %71, <4 x float>* %74
%75 = getelementptr inbounds float, float* %73, i64 4
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> %72, <4 x float>* %76
%77 = add nuw i64 %54, 16
%78 = add <4 x i32> %55, <i32 16, i32 16, i32 16, i32 16>
%79 = add i64 %56, 2
%80 = icmp eq i64 %79, %52
br i1 %80, label %81, label %53
81: ; preds = %53, %36
%82 = phi i64 [ 0, %36 ], [ %77, %53 ]
%83 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %36 ], [ %78, %53 ]
%84 = icmp eq i64 %49, 0
br i1 %84, label %95, label %85
85: ; preds = %81
%86 = add <4 x i32> %83, <i32 4, i32 4, i32 4, i32 4>
%87 = sitofp <4 x i32> %83 to <4 x float>
%88 = sitofp <4 x i32> %86 to <4 x float>
%89 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %39, <4 x float> %87, <4 x float> %41)
%90 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %43, <4 x float> %88, <4 x float> %45)
%91 = getelementptr inbounds float, float* %27, i64 %82
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %89, <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
br label %95
95: ; preds = %81, %85
%96 = icmp eq i64 %37, %34
br i1 %96, label %99, label %97
97: ; preds = %33, %95
%98 = phi i64 [ 0, %33 ], [ %37, %95 ]
br label %107
99: ; preds = %107, %95, %5
%100 = icmp eq i64 %1, 0
br i1 %100, label %169, label %101
101: ; preds = %99
%102 = zext i32 %6 to i64
%103 = and i64 %102, 1
%104 = icmp eq i32 %6, 1
%105 = and i64 %102, 4294967294
%106 = icmp eq i64 %103, 0
br label %115
107: ; preds = %97, %107
%108 = phi i64 [ %113, %107 ], [ %98, %97 ]
%109 = trunc i64 %108 to i32
%110 = sitofp i32 %109 to float
%111 = tail call float @llvm.fmuladd.f32(float %31, float %110, float %24)
%112 = getelementptr inbounds float, float* %27, i64 %108
store float %111, float* %112
%113 = add nuw nsw i64 %108, 1
%114 = icmp eq i64 %113, %34
br i1 %114, label %99, label %107
115: ; preds = %101, %163
%116 = phi i64 [ 0, %101 ], [ %167, %163 ]
%117 = trunc i64 %116 to i32
%118 = sitofp i32 %117 to double
%119 = fadd double %118, 5.000000e-01
%120 = tail call double @llvm.fmuladd.f64(double %119, double %8, double %7)
%121 = fdiv double 1.000000e+00, %120
%122 = fptrunc double %121 to float
%123 = fmul float %122, %122
br i1 %32, label %124, label %163
124: ; preds = %115
br i1 %104, label %150, label %125
125: ; preds = %124, %125
%126 = phi i64 [ %147, %125 ], [ 0, %124 ]
%127 = phi float [ %146, %125 ], [ 0x46293E5940000000, %124 ]
%128 = phi i32 [ %145, %125 ], [ -1, %124 ]
%129 = phi i64 [ %148, %125 ], [ 0, %124 ]
%130 = getelementptr inbounds float, float* %27, i64 %126
%131 = load float, float* %130
%132 = fsub float %123, %131
%133 = tail call float @llvm.fabs.f32(float %132)
%134 = fcmp olt float %133, %127
%135 = trunc i64 %126 to i32
%136 = select i1 %134, i32 %135, i32 %128
%137 = select i1 %134, float %133, float %127
%138 = or i64 %126, 1
%139 = getelementptr inbounds float, float* %27, i64 %138
%140 = load float, float* %139
%141 = fsub float %123, %140
%142 = tail call float @llvm.fabs.f32(float %141)
%143 = fcmp olt float %142, %137
%144 = trunc i64 %138 to i32
%145 = select i1 %143, i32 %144, i32 %136
%146 = select i1 %143, float %142, float %137
%147 = add nuw nsw i64 %126, 2
%148 = add i64 %129, 2
%149 = icmp eq i64 %148, %105
br i1 %149, label %150, label %125
150: ; preds = %125, %124
%151 = phi i32 [ undef, %124 ], [ %145, %125 ]
%152 = phi i64 [ 0, %124 ], [ %147, %125 ]
%153 = phi float [ 0x46293E5940000000, %124 ], [ %146, %125 ]
%154 = phi i32 [ -1, %124 ], [ %145, %125 ]
br i1 %106, label %163, label %155
155: ; preds = %150
%156 = getelementptr inbounds float, float* %27, i64 %152
%157 = load float, float* %156
%158 = fsub float %123, %157
%159 = tail call float @llvm.fabs.f32(float %158)
%160 = fcmp olt float %159, %153
%161 = trunc i64 %152 to i32
%162 = select i1 %160, i32 %161, i32 %154
br label %163
163: ; preds = %155, %150, %115
%164 = phi i32 [ -1, %115 ], [ %151, %150 ], [ %162, %155 ]
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i64, i64* %0, i64 %116
store i64 %165, i64* %166
%167 = add nuw nsw i64 %116, 1
%168 = icmp eq i64 %167, %1
br i1 %168, label %169, label %115
169: ; preds = %163, %99
ret void
}