#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 M_PI;
float sin(float);
int /*<<< orphan*/ wrap(float *, int);
void weightfunct(float *weight, float k, float dx, int nkx, float alfa1,
                 float alfa2, float scale) {
  int ikx, ikxmax1, ikxmin1;
  float kxnyq, dkx, kxfmax, kxfmin;
  float kpos, kneg;
  kneg = k * sin(M_PI * alfa1 / 180);
  kpos = k * sin(M_PI * alfa2 / 180);
  kxnyq = M_PI / dx;
  dkx = 2.0 * M_PI / (nkx * dx);
  if (kneg > kxnyq)
    return;
  if (kpos > 0.85 * kxnyq)
    kpos = 0.85 * kxnyq;
  if (kneg < -0.85 * kxnyq)
    kneg = -0.85 * kxnyq;
  kxfmax = ((kpos) < (kxnyq) ? (kpos) : (kxnyq));
  kxfmin = ((kneg) > (-kxnyq) ? (kneg) : (-kxnyq));
  ikxmin1 = (int)(kxfmin / dkx);
  ikxmax1 = (int)(kxfmax / dkx);
  for (ikx = -(nkx / 2) + 1; ikx <= ikxmin1; ikx++)
    weight[(nkx / 2) - 1 + ikx] = scale;
  for (ikx = ikxmin1 + 1; ikx < ikxmax1; ikx++)
    weight[(nkx / 2) - 1 + ikx] = 1.0;
  for (ikx = ikxmax1; ikx <= nkx / 2; ikx++)
    weight[(nkx / 2) - 1 + ikx] = scale;
  wrap(weight, nkx);
  return;
}


x86 assembly (clang, -O0):
<weightfunct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movss  %xmm2,-0x18(%rbp)
movss  %xmm3,-0x1c(%rbp)
movss  %xmm4,-0x20(%rbp)
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    0x2e8c(%rip),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  0xeab(%rip),%xmm1
divss  %xmm1,%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    0x2e50(%rip),%rax
movss  (%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  0xe6f(%rip),%xmm1
divss  %xmm1,%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    0x2e1e(%rip),%rax
movss  (%rax),%xmm0
divss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    0x2e09(%rip),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe11(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
mulss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x44(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jbe    1222 <weightfunct+0x102>
jmp    146f <weightfunct+0x34f>
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xdcc(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1268 <weightfunct+0x148>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdad(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xd8e(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    12ae <weightfunct+0x18e>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd6f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    12d0 <weightfunct+0x1b0>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    12da <weightfunct+0x1ba>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm1,%xmm0
jbe    1313 <weightfunct+0x1f3>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    132a <weightfunct+0x20a>
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x2c(%rbp)
movss  -0x38(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13b3 <weightfunct+0x293>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
sub    $0x1,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    136d <weightfunct+0x24d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1405 <weightfunct+0x2e5>
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
sub    $0x1,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  0xc2a(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13bc <weightfunct+0x29c>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
cmp    %ecx,%eax
jg     1463 <weightfunct+0x343>
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
sub    $0x1,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    140b <weightfunct+0x2eb>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1030 <wrap@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<weightfunct>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
movaps %xmm4,0x10(%rsp)
movss  %xmm3,0x8(%rsp)
mov    %esi,%r14d
movss  %xmm1,0xc(%rsp)
movss  %xmm0,(%rsp)
mov    %rdi,%rbx
mov    0x2e9d(%rip),%rbp
mulss  0x0(%rbp),%xmm2
divss  0xea8(%rip),%xmm2
movaps %xmm2,%xmm0
call   1040 <sin@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x8(%rsp),%xmm0
mulss  0x0(%rbp),%xmm0
divss  0xe82(%rip),%xmm0
call   1040 <sin@plt>
movss  0xc(%rsp),%xmm4
movss  0x4(%rsp),%xmm6
movss  0x0(%rbp),%xmm2
movaps %xmm2,%xmm1
divss  %xmm4,%xmm1
ucomiss %xmm1,%xmm6
jbe    11a9 <weightfunct+0x89>
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
mulss  (%rsp),%xmm0
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
xorps  %xmm3,%xmm3
cvtsi2ss %r14d,%xmm3
mulss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm2
cvtss2sd %xmm0,%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm1,%xmm3
movsd  0xe2b(%rip),%xmm4
mulsd  %xmm3,%xmm4
ucomisd %xmm4,%xmm5
jbe    11ee <weightfunct+0xce>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
cvtsd2ss %xmm2,%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm6,%xmm4
mulsd  0xe0f(%rip),%xmm3
ucomisd %xmm4,%xmm3
jbe    120e <weightfunct+0xee>
xorps  %xmm6,%xmm6
cvtsd2ss %xmm3,%xmm6
movaps 0x10(%rsp),%xmm3
minss  %xmm1,%xmm0
xorps  0xe02(%rip),%xmm1
maxss  %xmm1,%xmm6
divss  %xmm2,%xmm6
cvttss2si %xmm6,%edx
divss  %xmm2,%xmm0
cvttss2si %xmm0,%r11d
mov    %r14d,%ecx
shr    $0x1f,%ecx
add    %r14d,%ecx
sar    %ecx
mov    $0x1,%eax
sub    %ecx,%eax
cmp    %edx,%eax
jle    1252 <weightfunct+0x132>
lea    0x1(%rdx),%r10d
jmp    133d <weightfunct+0x21d>
mov    %ecx,%eax
neg    %eax
movslq %eax,%rdi
add    $0x1,%rdi
lea    0x1(%rdx),%r10d
lea    (%rcx,%rdx,1),%r9d
add    $0xffffffff,%r9d
cmp    $0x7,%r9d
jb     131a <weightfunct+0x1fa>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rax
jae    12a3 <weightfunct+0x183>
xor    %eax,%eax
jmp    12e1 <weightfunct+0x1c1>
and    $0xfffffffffffffffc,%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movups %xmm0,(%rbx,%rax,4)
movups %xmm0,0x10(%rbx,%rax,4)
movups %xmm0,0x20(%rbx,%rax,4)
movups %xmm0,0x30(%rbx,%rax,4)
movups %xmm0,0x40(%rbx,%rax,4)
movups %xmm0,0x50(%rbx,%rax,4)
movups %xmm0,0x60(%rbx,%rax,4)
movups %xmm0,0x70(%rbx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rsi
jne    12b0 <weightfunct+0x190>
test   %rbp,%rbp
je     1312 <weightfunct+0x1f2>
lea    (%rbx,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm0,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    1300 <weightfunct+0x1e0>
cmp    %r8,%r9
je     133d <weightfunct+0x21d>
add    %r8,%rdi
lea    -0x1(%rcx),%eax
cltq
lea    (%rbx,%rax,4),%rax
mov    %r10d,%esi
cs nopw 0x0(%rax,%rax,1)
movss  %xmm3,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%esi
jne    1330 <weightfunct+0x210>
cmp    %r11d,%r10d
jge    13cd <weightfunct+0x2ad>
mov    %r10d,%edi
mov    %r11d,%ebp
sub    %r10d,%ebp
mov    %r10d,%esi
not    %esi
add    %r11d,%esi
and    $0x3,%ebp
je     1381 <weightfunct+0x261>
neg    %ebp
xor    %eax,%eax
add    %ecx,%edx
movslq %edx,%rdx
movl   $0x3f800000,(%rbx,%rdx,4)
mov    %edi,%edx
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
cmp    %eax,%ebp
jne    1360 <weightfunct+0x240>
not    %eax
add    %r10d,%eax
mov    %eax,%edx
cmp    $0x3,%esi
jb     13cd <weightfunct+0x2ad>
cs nopw 0x0(%rax,%rax,1)
add    %ecx,%edx
movslq %edx,%rax
movl   $0x3f800000,(%rbx,%rax,4)
lea    (%rcx,%rdi,1),%eax
cltq
movl   $0x3f800000,(%rbx,%rax,4)
lea    0x1(%rcx,%rdi,1),%eax
cltq
movl   $0x3f800000,(%rbx,%rax,4)
lea    0x2(%rcx,%rdi,1),%eax
cltq
movl   $0x3f800000,(%rbx,%rax,4)
lea    0x3(%rdi),%edx
add    $0x4,%edi
cmp    %edi,%r11d
jne    1390 <weightfunct+0x270>
mov    %ecx,%r9d
sub    %r11d,%r9d
jl     14bd <weightfunct+0x39d>
add    $0xffffffff,%ecx
movslq %r11d,%rax
movslq %ecx,%rcx
cmp    $0x7,%r9d
jb     149a <weightfunct+0x37a>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdx
jae    141c <weightfunct+0x2fc>
xor    %esi,%esi
jmp    1461 <weightfunct+0x341>
and    $0xfffffffffffffffc,%rdi
lea    (%rcx,%rax,1),%rdx
lea    (%rbx,%rdx,4),%rdx
add    $0x70,%rdx
xor    %esi,%esi
xchg   %ax,%ax
movups %xmm0,-0x70(%rdx,%rsi,4)
movups %xmm0,-0x60(%rdx,%rsi,4)
movups %xmm0,-0x50(%rdx,%rsi,4)
movups %xmm0,-0x40(%rdx,%rsi,4)
movups %xmm0,-0x30(%rdx,%rsi,4)
movups %xmm0,-0x20(%rdx,%rsi,4)
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm0,(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1430 <weightfunct+0x310>
test   %rbp,%rbp
je     1492 <weightfunct+0x372>
add    %rax,%rsi
add    %rcx,%rsi
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    1480 <weightfunct+0x360>
cmp    %r8,%r9
je     14bd <weightfunct+0x39d>
add    %r8,%rax
lea    (%rbx,%rcx,4),%rdx
add    $0x2,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm3,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %eax,%ecx
jne    14b0 <weightfunct+0x390>
mov    %rbx,%rdi
mov    %r14d,%esi
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <wrap@plt>

LLVM IR (-O0):
@M_PI = global float 0.000000e+00
define void @weightfunct(float* %0, float %1, float %2, i32 %3, float %4, float %5, float %6) {
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca i32
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store float* %0, float** %8
store float %1, float* %9
store float %2, float* %10
store i32 %3, i32* %11
store float %4, float* %12
store float %5, float* %13
store float %6, float* %14
%24 = load float, float* %9
%25 = load float, float* @M_PI
%26 = load float, float* %12
%27 = fmul float %25, %26
%28 = fdiv float %27, 1.800000e+02
%29 = call float @sin(float %28)
%30 = fmul float %24, %29
store float %30, float* %23
%31 = load float, float* %9
%32 = load float, float* @M_PI
%33 = load float, float* %13
%34 = fmul float %32, %33
%35 = fdiv float %34, 1.800000e+02
%36 = call float @sin(float %35)
%37 = fmul float %31, %36
store float %37, float* %22
%38 = load float, float* @M_PI
%39 = load float, float* %10
%40 = fdiv float %38, %39
store float %40, float* %18
%41 = load float, float* @M_PI
%42 = fpext float %41 to double
%43 = fmul double 2.000000e+00, %42
%44 = load i32, i32* %11
%45 = sitofp i32 %44 to float
%46 = load float, float* %10
%47 = fmul float %45, %46
%48 = fpext float %47 to double
%49 = fdiv double %43, %48
%50 = fptrunc double %49 to float
store float %50, float* %19
%51 = load float, float* %23
%52 = load float, float* %18
%53 = fcmp ogt float %51, %52
br i1 %53, label %54, label %55
54: ; preds = %7
br label %172
55: ; preds = %7
%56 = load float, float* %22
%57 = fpext float %56 to double
%58 = load float, float* %18
%59 = fpext float %58 to double
%60 = fmul double 8.500000e-01, %59
%61 = fcmp ogt double %57, %60
br i1 %61, label %62, label %67
62: ; preds = %55
%63 = load float, float* %18
%64 = fpext float %63 to double
%65 = fmul double 8.500000e-01, %64
%66 = fptrunc double %65 to float
store float %66, float* %22
br label %67
67: ; preds = %62, %55
%68 = load float, float* %23
%69 = fpext float %68 to double
%70 = load float, float* %18
%71 = fpext float %70 to double
%72 = fmul double -8.500000e-01, %71
%73 = fcmp olt double %69, %72
br i1 %73, label %74, label %79
74: ; preds = %67
%75 = load float, float* %18
%76 = fpext float %75 to double
%77 = fmul double -8.500000e-01, %76
%78 = fptrunc double %77 to float
store float %78, float* %23
br label %79
79: ; preds = %74, %67
%80 = load float, float* %22
%81 = load float, float* %18
%82 = fcmp olt float %80, %81
br i1 %82, label %83, label %85
83: ; preds = %79
%84 = load float, float* %22
br label %87
85: ; preds = %79
%86 = load float, float* %18
br label %87
87: ; preds = %85, %83
%88 = phi float [ %84, %83 ], [ %86, %85 ]
store float %88, float* %20
%89 = load float, float* %23
%90 = load float, float* %18
%91 = fneg float %90
%92 = fcmp ogt float %89, %91
br i1 %92, label %93, label %95
93: ; preds = %87
%94 = load float, float* %23
br label %98
95: ; preds = %87
%96 = load float, float* %18
%97 = fneg float %96
br label %98
98: ; preds = %95, %93
%99 = phi float [ %94, %93 ], [ %97, %95 ]
store float %99, float* %21
%100 = load float, float* %21
%101 = load float, float* %19
%102 = fdiv float %100, %101
%103 = fptosi float %102 to i32
store i32 %103, i32* %17
%104 = load float, float* %20
%105 = load float, float* %19
%106 = fdiv float %104, %105
%107 = fptosi float %106 to i32
store i32 %107, i32* %16
%108 = load i32, i32* %11
%109 = sdiv i32 %108, 2
%110 = sub nsw i32 0, %109
%111 = add nsw i32 %110, 1
store i32 %111, i32* %15
br label %112
112: ; preds = %126, %98
%113 = load i32, i32* %15
%114 = load i32, i32* %17
%115 = icmp sle i32 %113, %114
br i1 %115, label %116, label %129
116: ; preds = %112
%117 = load float, float* %14
%118 = load float*, float** %8
%119 = load i32, i32* %11
%120 = sdiv i32 %119, 2
%121 = sub nsw i32 %120, 1
%122 = load i32, i32* %15
%123 = add nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %118, i64 %124
store float %117, float* %125
br label %126
126: ; preds = %116
%127 = load i32, i32* %15
%128 = add nsw i32 %127, 1
store i32 %128, i32* %15
br label %112
129: ; preds = %112
%130 = load i32, i32* %17
%131 = add nsw i32 %130, 1
store i32 %131, i32* %15
br label %132
132: ; preds = %145, %129
%133 = load i32, i32* %15
%134 = load i32, i32* %16
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %148
136: ; preds = %132
%137 = load float*, float** %8
%138 = load i32, i32* %11
%139 = sdiv i32 %138, 2
%140 = sub nsw i32 %139, 1
%141 = load i32, i32* %15
%142 = add nsw i32 %140, %141
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %137, i64 %143
store float 1.000000e+00, float* %144
br label %145
145: ; preds = %136
%146 = load i32, i32* %15
%147 = add nsw i32 %146, 1
store i32 %147, i32* %15
br label %132
148: ; preds = %132
%149 = load i32, i32* %16
store i32 %149, i32* %15
br label %150
150: ; preds = %165, %148
%151 = load i32, i32* %15
%152 = load i32, i32* %11
%153 = sdiv i32 %152, 2
%154 = icmp sle i32 %151, %153
br i1 %154, label %155, label %168
155: ; preds = %150
%156 = load float, float* %14
%157 = load float*, float** %8
%158 = load i32, i32* %11
%159 = sdiv i32 %158, 2
%160 = sub nsw i32 %159, 1
%161 = load i32, i32* %15
%162 = add nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %157, i64 %163
store float %156, float* %164
br label %165
165: ; preds = %155
%166 = load i32, i32* %15
%167 = add nsw i32 %166, 1
store i32 %167, i32* %15
br label %150
168: ; preds = %150
%169 = load float*, float** %8
%170 = load i32, i32* %11
%171 = call i32 @wrap(float* %169, i32 %170)
br label %172
172: ; preds = %168, %54
ret void
}

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