#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 M_PI;
int /*<<< orphan*/ blackman(unsigned int, float *);
int /*<<< orphan*/ boxcar(unsigned int, float *);
int /*<<< orphan*/ flattop(unsigned int, float *);
int /*<<< orphan*/ hamming(unsigned int, float *);
int /*<<< orphan*/ hanning(unsigned int, float *);
int /*<<< orphan*/ kaiser(unsigned int, float *, float);
int sin(float);
int /*<<< orphan*/ triang(unsigned int, float *);
int design_fir(unsigned int n, float *w, float *fc, unsigned int flags,
               float opt) {
  unsigned int o = n & 1;
  unsigned int end = ((n + 1) >> 1) - o;
  unsigned int i;
  float k1 = 2 * M_PI;
  float k2 = 0.5 * (float)(1 - o);
  float k3;
  float g = 0.0;
  float t1, t2, t3;
  float fc1, fc2;
  if (!w || (n == 0))
    return -1;
  switch (flags & 0x0000001F) {
  case (0x00000001):
    boxcar(n, w);
    break;
  case (0x00000002):
    triang(n, w);
    break;
  case (0x00000004):
    hamming(n, w);
    break;
  case (0x00000008):
    hanning(n, w);
    break;
  case (0x00000010):
    blackman(n, w);
    break;
  case (0x00000011):
    flattop(n, w);
    break;
  case (0x00000012):
    kaiser(n, w, opt);
    break;
  default:
    return -1;
  }
  if (flags & (0x00010000 | 0x00020000)) {
    fc1 = *fc;
    fc1 = ((fc1 <= 1.0) && (fc1 > 0.0)) ? fc1 / 2 : 0.25;
    k1 *= fc1;
    if (flags & 0x00010000) {
      if (o) {
        w[end] = fc1 * w[end] * 2.0;
        g = w[end];
      }
      for (i = 0; i < end; i++) {
        t1 = (float)(i + 1) - k2;
        w[end - i - 1] = w[n - end + i] =
            w[end - i - 1] * sin(k1 * t1) / (M_PI * t1);
        g += 2 * w[end - i - 1];
      }
    } else {
      if (!o)
        return -1;
      w[end] = 1.0 - (fc1 * w[end] * 2.0);
      g = w[end];
      for (i = 0; i < end; i++) {
        t1 = (float)(i + 1);
        w[end - i - 1] = w[n - end + i] =
            -1 * w[end - i - 1] * sin(k1 * t1) / (M_PI * t1);
        g += ((i & 1) ? (2 * w[end - i - 1]) : (-2 * w[end - i - 1]));
      }
    }
  }
  if (flags & (0x00040000 | 0x00080000)) {
    fc1 = fc[0];
    fc2 = fc[1];
    fc1 = ((fc1 <= 1.0) && (fc1 > 0.0)) ? fc1 / 2 : 0.25;
    fc2 = ((fc2 <= 1.0) && (fc2 > 0.0)) ? fc2 / 2 : 0.25;
    k3 = k1 * fc2;
    k1 *= fc1;
    if (flags & 0x00040000) {
      if (o) {
        g = w[end] * (fc1 + fc2);
        w[end] = (fc2 - fc1) * w[end] * 2.0;
      }
      for (i = 0; i < end; i++) {
        t1 = (float)(i + 1) - k2;
        t2 = sin(k3 * t1) / (M_PI * t1);
        t3 = sin(k1 * t1) / (M_PI * t1);
        g += w[end - i - 1] * (t3 + t2);
        w[end - i - 1] = w[n - end + i] = w[end - i - 1] * (t2 - t3);
      }
    } else {
      if (!o)
        return -1;
      w[end] = 1.0 - (fc2 - fc1) * w[end] * 2.0;
      g = w[end];
      for (i = 0; i < end; i++) {
        t1 = (float)(i + 1);
        t2 = sin(k1 * t1) / (M_PI * t1);
        t3 = sin(k3 * t1) / (M_PI * t1);
        w[end - i - 1] = w[n - end + i] = w[end - i - 1] * (t2 - t3);
        g += 2 * w[end - i - 1];
      }
    }
  }
  g = 1 / g;
  for (i = 0; i < n; i++)
    w[i] *= g;
  return 0;
}


x86 assembly (clang, -O0):
<design_fir>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
shr    %eax
mov    -0x24(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    0x2e2a(%rip),%rax
mov    (%rax),%eax
add    %eax,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%ecx
mov    $0x1,%eax
sub    %ecx,%eax
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe1a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1210 <design_fir+0x90>
cmpl   $0x0,-0x8(%rbp)
jne    121c <design_fir+0x9c>
movl   $0xffffffff,-0x4(%rbp)
jmp    1a9a <design_fir+0x91a>
mov    -0x1c(%rbp),%eax
and    $0x1f,%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0x11,%eax
ja     12c4 <design_fir+0x144>
mov    -0x58(%rbp),%rax
lea    0xdf1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <boxcar@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1050 <triang@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1080 <hamming@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1090 <hanning@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1060 <blackman@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   10a0 <flattop@plt>
jmp    12d0 <design_fir+0x150>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
movss  -0x20(%rbp),%xmm0
call   1040 <kaiser@plt>
jmp    12d0 <design_fir+0x150>
movl   $0xffffffff,-0x4(%rbp)
jmp    1a9a <design_fir+0x91a>
mov    -0x1c(%rbp),%eax
and    $0x30000,%eax
cmp    $0x0,%eax
je     1628 <design_fir+0x4a8>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd09(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     133e <design_fir+0x1be>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    133e <design_fir+0x1be>
movss  -0x4c(%rbp),%xmm0
movss  0xcf4(%rip),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1350 <design_fir+0x1d0>
movsd  0xcca(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1350 <design_fir+0x1d0>
movsd  -0x60(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x10000,%eax
cmp    $0x0,%eax
je     149c <design_fir+0x31c>
cmpl   $0x0,-0x24(%rbp)
je     13ca <design_fir+0x24a>
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc73(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1497 <design_fir+0x317>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %rax,%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
movss  -0x64(%rbp),%xmm0
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
mov    0x2bba(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x3c(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d1 <design_fir+0x251>
jmp    1623 <design_fir+0x4a3>
cmpl   $0x0,-0x24(%rbp)
jne    14b2 <design_fir+0x332>
movl   $0xffffffff,-0x4(%rbp)
jmp    1a9a <design_fir+0x91a>
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  %xmm0,%xmm0
movsd  0xb1e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    161e <design_fir+0x49e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  0xadb(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
movss  -0x68(%rbp),%xmm0
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
mov    0x2a72(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     15e0 <design_fir+0x460>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  0xa4f(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1601 <design_fir+0x481>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  0xa31(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1516 <design_fir+0x396>
jmp    1623 <design_fir+0x4a3>
jmp    1628 <design_fir+0x4a8>
mov    -0x1c(%rbp),%eax
and    $0xc0000,%eax
cmp    $0x0,%eax
je     1a4a <design_fir+0x8ca>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x9a3(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     16a4 <design_fir+0x524>
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16a4 <design_fir+0x524>
movss  -0x4c(%rbp),%xmm0
movss  0x98e(%rip),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    16b6 <design_fir+0x536>
movsd  0x964(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    16b6 <design_fir+0x536>
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x933(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1714 <design_fir+0x594>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1714 <design_fir+0x594>
movss  -0x50(%rbp),%xmm0
movss  0x91e(%rip),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1726 <design_fir+0x5a6>
movsd  0x8f4(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1726 <design_fir+0x5a6>
movsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x40000,%eax
cmp    $0x0,%eax
je     18cf <design_fir+0x74f>
cmpl   $0x0,-0x24(%rbp)
je     17c2 <design_fir+0x642>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm1
addss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x86a(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    18ca <design_fir+0x74a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %rax,%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
cvtsi2ss %eax,%xmm0
mov    0x27e4(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
cvtsi2ss %eax,%xmm0
mov    0x27b8(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x48(%rbp),%xmm2
addss  -0x44(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x44(%rbp),%xmm1
subss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17c9 <design_fir+0x649>
jmp    1a45 <design_fir+0x8c5>
cmpl   $0x0,-0x24(%rbp)
jne    18e5 <design_fir+0x765>
movl   $0xffffffff,-0x4(%rbp)
jmp    1a9a <design_fir+0x91a>
movss  -0x50(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  %xmm0,%xmm0
movsd  0x6e6(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1a40 <design_fir+0x8c0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
cvtsi2ss %eax,%xmm0
mov    0x2664(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1070 <sin@plt>
cvtsi2ss %eax,%xmm0
mov    0x2638(%rip),%rax
cvtsi2ssl (%rax),%xmm1
mulss  -0x40(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x44(%rbp),%xmm1
subss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x3c(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    194e <design_fir+0x7ce>
jmp    1a45 <design_fir+0x8c5>
jmp    1a4a <design_fir+0x8ca>
movss  0x5da(%rip),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1a93 <design_fir+0x913>
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a63 <design_fir+0x8e3>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<design_fir>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    $0xffffffff,%r12d
test   %edi,%edi
je     18fc <design_fir+0x77c>
mov    %rsi,%r14
test   %rsi,%rsi
je     18fc <design_fir+0x77c>
mov    %ecx,%r13d
mov    %ecx,%eax
and    $0x1f,%eax
add    $0xffffffff,%eax
cmp    $0x11,%eax
ja     18fc <design_fir+0x77c>
mov    %edi,%ebx
mov    0x2e20(%rip),%r15
mov    (%r15),%ebp
lea    0xe5e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
mov    %rdx,0x10(%rsp)
jmp    *%rax
mov    %ebx,%edi
mov    %r14,%rsi
call   1030 <boxcar@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   1050 <triang@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   1080 <hamming@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   1090 <hanning@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   1060 <blackman@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   10a0 <flattop@plt>
jmp    1232 <design_fir+0xb2>
mov    %ebx,%edi
mov    %r14,%rsi
call   1040 <kaiser@plt>
mov    %ebx,%ecx
and    $0x1,%ecx
lea    0x1(%rbx),%edx
shr    %edx
mov    %edx,%esi
add    %ebp,%ebp
cvtsi2ss %ebp,%xmm3
mov    %ecx,%eax
xor    $0x1,%eax
cvtsi2ss %eax,%xmm6
sub    %ecx,%esi
mulss  0xda9(%rip),%xmm6
test   $0x30000,%r13d
movss  %xmm6,0x80(%rsp)
mov    0x10(%rsp),%rax
mov    %rbx,0x68(%rsp)
je     13fc <design_fir+0x27c>
movss  (%rax),%xmm0
movss  0xd7d(%rip),%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm7,%xmm7
xorps  %xmm2,%xmm2
cmpltss %xmm0,%xmm2
andps  %xmm2,%xmm1
movss  0xd67(%rip),%xmm4
andnps %xmm4,%xmm2
orps   %xmm1,%xmm2
cmpless 0xd5c(%rip),%xmm0
andps  %xmm0,%xmm2
andnps %xmm4,%xmm0
orps   %xmm2,%xmm0
mulss  %xmm0,%xmm3
test   $0x10000,%r13d
movaps %xmm3,0x70(%rsp)
jne    1404 <design_fir+0x284>
test   %ecx,%ecx
je     18fc <design_fir+0x77c>
mov    %esi,%edi
movss  (%r14,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
addsd  %xmm0,%xmm0
movsd  0xd1e(%rip),%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm7,%xmm7
cvtsd2ss %xmm1,%xmm7
movss  %xmm7,(%r14,%rdi,4)
test   %esi,%esi
je     1519 <design_fir+0x399>
mov    %esi,0x1c(%rsp)
mov    %r13d,0x24(%rsp)
lea    (%rbx,%rcx,1),%eax
sub    %edx,%eax
mov    %rax,0x40(%rsp)
mov    %rcx,0x28(%rsp)
mov    %ecx,%ebp
not    %ebp
mov    %edx,0x20(%rsp)
add    %edx,%ebp
xor    %r15d,%r15d
movss  %xmm7,0xc(%rsp)
lea    0x1(%r15),%r12
mov    %r12d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
movss  %xmm1,0x50(%rsp)
mov    %ebp,%ebx
movss  (%r14,%rbx,4),%xmm0
xorps  0xcc6(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm3,%xmm0
mulss  %xmm1,%xmm0
mov    %rdi,%r13
call   1070 <sin@plt>
mov    %r13,%rdi
movaps 0x70(%rsp),%xmm3
movss  0xc(%rsp),%xmm7
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x2c5e(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2ssl (%rax),%xmm1
mulss  0x30(%rsp),%xmm0
mulss  0x50(%rsp),%xmm1
divss  %xmm1,%xmm0
mov    0x40(%rsp),%rax
add    %r15d,%eax
movss  %xmm0,(%r14,%rax,4)
movss  %xmm0,(%r14,%rbx,4)
xor    %eax,%eax
test   $0x1,%r15b
sete   %al
lea    0xc53(%rip),%rcx
mulss  (%rcx,%rax,4),%xmm0
addss  %xmm0,%xmm7
add    $0xffffffff,%ebp
mov    %r12,%r15
cmp    %r12,%r13
jne    1330 <design_fir+0x1b0>
mov    0x68(%rsp),%rbx
mov    0x2bff(%rip),%r15
mov    0x28(%rsp),%rcx
movss  0x80(%rsp),%xmm6
jmp    1501 <design_fir+0x381>
xorps  %xmm7,%xmm7
jmp    1519 <design_fir+0x399>
mov    %esi,%edi
test   %ecx,%ecx
je     141e <design_fir+0x29e>
movss  (%r14,%rdi,4),%xmm7
mulss  %xmm0,%xmm7
addss  %xmm7,%xmm7
movss  %xmm7,(%r14,%rdi,4)
test   %esi,%esi
je     1519 <design_fir+0x399>
mov    %esi,0x1c(%rsp)
mov    %r13d,0x24(%rsp)
lea    (%rbx,%rcx,1),%eax
sub    %edx,%eax
mov    %rax,0x40(%rsp)
mov    %rcx,0x28(%rsp)
mov    %ecx,%ebp
not    %ebp
mov    %edx,0x20(%rsp)
add    %edx,%ebp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movss  %xmm7,0xc(%rsp)
lea    0x1(%rbx),%r13
mov    %r13d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
subss  %xmm6,%xmm1
movss  %xmm1,0x30(%rsp)
mov    %ebp,%r12d
movss  (%r14,%r12,4),%xmm0
movss  %xmm0,0x50(%rsp)
movaps %xmm3,%xmm0
mulss  %xmm1,%xmm0
mov    %rdi,%r15
call   1070 <sin@plt>
mov    %r15,%rdi
movaps 0x70(%rsp),%xmm3
movss  0x80(%rsp),%xmm6
movss  0xc(%rsp),%xmm7
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x50(%rsp),%xmm0
mov    0x2b30(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2ssl (%rax),%xmm1
mulss  0x30(%rsp),%xmm1
divss  %xmm1,%xmm0
add    0x40(%rsp),%ebx
movss  %xmm0,(%r14,%rbx,4)
movss  %xmm0,(%r14,%r12,4)
addss  %xmm0,%xmm0
addss  %xmm0,%xmm7
add    $0xffffffff,%ebp
mov    %r13,%rbx
cmp    %r13,%r15
jne    1450 <design_fir+0x2d0>
mov    0x68(%rsp),%rbx
mov    0x2aec(%rip),%r15
mov    0x28(%rsp),%rcx
mov    $0xffffffff,%r12d
mov    0x24(%rsp),%r13d
mov    0x20(%rsp),%edx
mov    0x1c(%rsp),%esi
mov    0x10(%rsp),%rax
test   $0xc0000,%r13d
je     1821 <design_fir+0x6a1>
movss  (%rax),%xmm9
movss  0x4(%rax),%xmm0
movss  0xac8(%rip),%xmm1
movaps %xmm9,%xmm4
mulss  %xmm1,%xmm4
xorps  %xmm2,%xmm2
xorps  %xmm5,%xmm5
cmpltss %xmm9,%xmm5
andps  %xmm5,%xmm4
movss  0xaac(%rip),%xmm8
andnps %xmm8,%xmm5
orps   %xmm4,%xmm5
movss  0xaa1(%rip),%xmm4
cmpless %xmm4,%xmm9
andps  %xmm9,%xmm5
andnps %xmm8,%xmm9
orps   %xmm5,%xmm9
mulss  %xmm0,%xmm1
cmpltss %xmm0,%xmm2
andps  %xmm2,%xmm1
andnps %xmm8,%xmm2
orps   %xmm1,%xmm2
cmpless %xmm4,%xmm0
andps  %xmm0,%xmm2
andnps %xmm8,%xmm0
orps   %xmm2,%xmm0
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm4
movaps %xmm9,%xmm5
mulss  %xmm3,%xmm5
test   $0x40000,%r13d
jne    16ef <design_fir+0x56f>
test   %ecx,%ecx
je     18fc <design_fir+0x77c>
subss  %xmm9,%xmm0
mov    %esi,%eax
mulss  (%r14,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
movsd  0xa34(%rip),%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm7,%xmm7
cvtsd2ss %xmm1,%xmm7
movss  %xmm7,(%r14,%rax,4)
test   %esi,%esi
je     1821 <design_fir+0x6a1>
lea    (%rbx,%rcx,1),%esi
sub    %edx,%esi
mov    %rsi,0x50(%rsp)
not    %ecx
add    %edx,%ecx
xor    %ebp,%ebp
movaps %xmm4,0x70(%rsp)
movaps %xmm5,0x40(%rsp)
mov    %rax,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm7,0xc(%rsp)
lea    0x1(%rbp),%r15
mov    %r15d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
movaps %xmm1,0x30(%rsp)
movaps 0x40(%rsp),%xmm0
mulss  %xmm1,%xmm0
mov    %rcx,%r12
call   1070 <sin@plt>
mov    %eax,%r13d
movaps 0x70(%rsp),%xmm0
mulss  0x30(%rsp),%xmm0
mov    0x2988(%rip),%rbx
movss  (%rbx),%xmm1
movaps %xmm1,0x80(%rsp)
call   1070 <sin@plt>
movss  0xc(%rsp),%xmm7
mov    %r12,%rcx
movd   %r13d,%xmm0
movd   %eax,%xmm1
punpckldq %xmm1,%xmm0
movss  (%rbx),%xmm1
movaps 0x80(%rsp),%xmm2
unpcklps %xmm1,%xmm2
cvtdq2ps %xmm2,%xmm1
cvtdq2ps %xmm0,%xmm0
movaps 0x30(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
divps  %xmm2,%xmm0
mov    %ecx,%eax
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
subss  %xmm1,%xmm0
mulss  (%r14,%rax,4),%xmm0
add    0x50(%rsp),%ebp
movss  %xmm0,(%r14,%rbp,4)
movss  %xmm0,(%r14,%rax,4)
mov    0x10(%rsp),%rax
addss  %xmm0,%xmm0
addss  %xmm0,%xmm7
add    $0xffffffff,%ecx
mov    %r15,%rbp
cmp    %r15,%rax
jne    1620 <design_fir+0x4a0>
jmp    1821 <design_fir+0x6a1>
test   %ecx,%ecx
je     171a <design_fir+0x59a>
mov    %esi,%eax
movss  (%r14,%rax,4),%xmm2
movaps %xmm9,%xmm7
addss  %xmm0,%xmm7
mulss  %xmm2,%xmm7
subss  %xmm9,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm0,%xmm0
movss  %xmm0,(%r14,%rax,4)
test   %esi,%esi
je     1821 <design_fir+0x6a1>
mov    %esi,%eax
mov    %rax,0x10(%rsp)
lea    (%rbx,%rcx,1),%eax
sub    %edx,%eax
mov    %rax,0x28(%rsp)
not    %ecx
add    %edx,%ecx
xor    %r13d,%r13d
mov    %r15,%rbx
movaps %xmm4,0x70(%rsp)
movaps %xmm5,0x40(%rsp)
nopw   0x0(%rax,%rax,1)
movss  %xmm7,0xc(%rsp)
lea    0x1(%r13),%r15
mov    %r15d,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
subss  %xmm6,%xmm1
movaps %xmm1,0x30(%rsp)
movaps 0x70(%rsp),%xmm0
mulss  %xmm1,%xmm0
mov    %rcx,%r12
call   1070 <sin@plt>
mov    %eax,%ebp
movaps 0x40(%rsp),%xmm0
mulss  0x30(%rsp),%xmm0
movss  (%rbx),%xmm1
movaps %xmm1,0x50(%rsp)
call   1070 <sin@plt>
movss  0x80(%rsp),%xmm6
movss  0xc(%rsp),%xmm7
mov    %r12,%rcx
movd   %ebp,%xmm0
movd   %eax,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2ps %xmm0,%xmm0
movss  (%rbx),%xmm1
movaps 0x50(%rsp),%xmm2
unpcklps %xmm1,%xmm2
cvtdq2ps %xmm2,%xmm1
movaps 0x30(%rsp),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
divps  %xmm2,%xmm0
mov    %ecx,%eax
movss  (%r14,%rax,4),%xmm1
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
movaps %xmm0,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  %xmm3,%xmm7
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
add    0x28(%rsp),%r13d
movss  %xmm0,(%r14,%r13,4)
movss  %xmm0,(%r14,%rax,4)
add    $0xffffffff,%ecx
mov    %r15,%r13
cmp    %r15,0x10(%rsp)
jne    1750 <design_fir+0x5d0>
movss  0x7df(%rip),%xmm0
divss  %xmm7,%xmm0
mov    0x68(%rsp),%rcx
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1840 <design_fir+0x6c0>
xor    %ecx,%ecx
jmp    18e0 <design_fir+0x760>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1911 <design_fir+0x791>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   (%rax)
movups (%r14,%rdx,4),%xmm2
movups 0x10(%r14,%rdx,4),%xmm3
movups 0x20(%r14,%rdx,4),%xmm4
movups 0x30(%r14,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r14,%rdx,4)
movups %xmm3,0x10(%r14,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%r14,%rdx,4)
movups %xmm5,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1870 <design_fir+0x6f0>
test   $0x1,%sil
je     18d6 <design_fir+0x756>
movups (%r14,%rdx,4),%xmm2
movups 0x10(%r14,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r14,%rdx,4)
movups %xmm3,0x10(%r14,%rdx,4)
xor    %r12d,%r12d
cmp    %rax,%rcx
je     18fc <design_fir+0x77c>
xchg   %ax,%ax
movss  (%r14,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    18e0 <design_fir+0x760>
xor    %r12d,%r12d
mov    %r12d,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    18ba <design_fir+0x73a>
jmp    18d6 <design_fir+0x756>

LLVM IR (-O0):
@M_PI = global i32 0
define i32 @design_fir(i32 %0, float* %1, float* %2, i32 %3, float %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca float
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store float* %2, float** %9
store i32 %3, i32* %10
store float %4, float* %11
%24 = load i32, i32* %7
%25 = and i32 %24, 1
store i32 %25, i32* %12
%26 = load i32, i32* %7
%27 = add i32 %26, 1
%28 = lshr i32 %27, 1
%29 = load i32, i32* %12
%30 = sub i32 %28, %29
store i32 %30, i32* %13
%31 = load i32, i32* @M_PI
%32 = mul nsw i32 2, %31
%33 = sitofp i32 %32 to float
store float %33, float* %15
%34 = load i32, i32* %12
%35 = sub i32 1, %34
%36 = uitofp i32 %35 to float
%37 = fpext float %36 to double
%38 = fmul double 5.000000e-01, %37
%39 = fptrunc double %38 to float
store float %39, float* %16
store float 0.000000e+00, float* %18
%40 = load float*, float** %8
%41 = icmp ne float* %40, null
br i1 %41, label %42, label %45
42: ; preds = %5
%43 = load i32, i32* %7
%44 = icmp eq i32 %43, 0
br i1 %44, label %45, label %46
45: ; preds = %42, %5
store i32 -1, i32* %6
br label %559
46: ; preds = %42
%47 = load i32, i32* %10
%48 = and i32 %47, 31
switch i32 %48, label %78 [
i32 1, label %49
i32 2, label %53
i32 4, label %57
i32 8, label %61
i32 16, label %65
i32 17, label %69
i32 18, label %73
]
49: ; preds = %46
%50 = load i32, i32* %7
%51 = load float*, float** %8
%52 = call i32 @boxcar(i32 %50, float* %51)
br label %79
53: ; preds = %46
%54 = load i32, i32* %7
%55 = load float*, float** %8
%56 = call i32 @triang(i32 %54, float* %55)
br label %79
57: ; preds = %46
%58 = load i32, i32* %7
%59 = load float*, float** %8
%60 = call i32 @hamming(i32 %58, float* %59)
br label %79
61: ; preds = %46
%62 = load i32, i32* %7
%63 = load float*, float** %8
%64 = call i32 @hanning(i32 %62, float* %63)
br label %79
65: ; preds = %46
%66 = load i32, i32* %7
%67 = load float*, float** %8
%68 = call i32 @blackman(i32 %66, float* %67)
br label %79
69: ; preds = %46
%70 = load i32, i32* %7
%71 = load float*, float** %8
%72 = call i32 @flattop(i32 %70, float* %71)
br label %79
73: ; preds = %46
%74 = load i32, i32* %7
%75 = load float*, float** %8
%76 = load float, float* %11
%77 = call i32 @kaiser(i32 %74, float* %75, float %76)
br label %79
78: ; preds = %46
store i32 -1, i32* %6
br label %559
79: ; preds = %73, %69, %65, %61, %57, %53, %49
%80 = load i32, i32* %10
%81 = and i32 %80, 196608
%82 = icmp ne i32 %81, 0
br i1 %82, label %83, label %289
83: ; preds = %79
%84 = load float*, float** %9
%85 = load float, float* %84
store float %85, float* %22
%86 = load float, float* %22
%87 = fpext float %86 to double
%88 = fcmp ole double %87, 1.000000e+00
br i1 %88, label %89, label %97
89: ; preds = %83
%90 = load float, float* %22
%91 = fpext float %90 to double
%92 = fcmp ogt double %91, 0.000000e+00
br i1 %92, label %93, label %97
93: ; preds = %89
%94 = load float, float* %22
%95 = fdiv float %94, 2.000000e+00
%96 = fpext float %95 to double
br label %98
97: ; preds = %89, %83
br label %98
98: ; preds = %97, %93
%99 = phi double [ %96, %93 ], [ 2.500000e-01, %97 ]
%100 = fptrunc double %99 to float
store float %100, float* %22
%101 = load float, float* %22
%102 = load float, float* %15
%103 = fmul float %102, %101
store float %103, float* %15
%104 = load i32, i32* %10
%105 = and i32 %104, 65536
%106 = icmp ne i32 %105, 0
br i1 %106, label %107, label %189
107: ; preds = %98
%108 = load i32, i32* %12
%109 = icmp ne i32 %108, 0
br i1 %109, label %110, label %130
110: ; preds = %107
%111 = load float, float* %22
%112 = load float*, float** %8
%113 = load i32, i32* %13
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds float, float* %112, i64 %114
%116 = load float, float* %115
%117 = fmul float %111, %116
%118 = fpext float %117 to double
%119 = fmul double %118, 2.000000e+00
%120 = fptrunc double %119 to float
%121 = load float*, float** %8
%122 = load i32, i32* %13
%123 = zext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
store float %120, float* %124
%125 = load float*, float** %8
%126 = load i32, i32* %13
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
%129 = load float, float* %128
store float %129, float* %18
br label %130
130: ; preds = %110, %107
store i32 0, i32* %14
br label %131
131: ; preds = %185, %130
%132 = load i32, i32* %14
%133 = load i32, i32* %13
%134 = icmp ult i32 %132, %133
br i1 %134, label %135, label %188
135: ; preds = %131
%136 = load i32, i32* %14
%137 = add i32 %136, 1
%138 = uitofp i32 %137 to float
%139 = load float, float* %16
%140 = fsub float %138, %139
store float %140, float* %19
%141 = load float*, float** %8
%142 = load i32, i32* %13
%143 = load i32, i32* %14
%144 = sub i32 %142, %143
%145 = sub i32 %144, 1
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds float, float* %141, i64 %146
%148 = load float, float* %147
%149 = load float, float* %15
%150 = load float, float* %19
%151 = fmul float %149, %150
%152 = call i32 @sin(float %151)
%153 = sitofp i32 %152 to float
%154 = fmul float %148, %153
%155 = load i32, i32* @M_PI
%156 = sitofp i32 %155 to float
%157 = load float, float* %19
%158 = fmul float %156, %157
%159 = fdiv float %154, %158
%160 = load float*, float** %8
%161 = load i32, i32* %7
%162 = load i32, i32* %13
%163 = sub i32 %161, %162
%164 = load i32, i32* %14
%165 = add i32 %163, %164
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds float, float* %160, i64 %166
store float %159, float* %167
%168 = load float*, float** %8
%169 = load i32, i32* %13
%170 = load i32, i32* %14
%171 = sub i32 %169, %170
%172 = sub i32 %171, 1
%173 = zext i32 %172 to i64
%174 = getelementptr inbounds float, float* %168, i64 %173
store float %159, float* %174
%175 = load float*, float** %8
%176 = load i32, i32* %13
%177 = load i32, i32* %14
%178 = sub i32 %176, %177
%179 = sub i32 %178, 1
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds float, float* %175, i64 %180
%182 = load float, float* %181
%183 = load float, float* %18
%184 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %182, float %183)
store float %184, float* %18
br label %185
185: ; preds = %135
%186 = load i32, i32* %14
%187 = add i32 %186, 1
store i32 %187, i32* %14
br label %131
188: ; preds = %131
br label %288
189: ; preds = %98
%190 = load i32, i32* %12
%191 = icmp ne i32 %190, 0
br i1 %191, label %193, label %192
192: ; preds = %189
store i32 -1, i32* %6
br label %559
193: ; preds = %189
%194 = load float, float* %22
%195 = load float*, float** %8
%196 = load i32, i32* %13
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds float, float* %195, i64 %197
%199 = load float, float* %198
%200 = fmul float %194, %199
%201 = fpext float %200 to double
%202 = fneg double %201
%203 = call double @llvm.fmuladd.f64(double %202, double 2.000000e+00, double 1.000000e+00)
%204 = fptrunc double %203 to float
%205 = load float*, float** %8
%206 = load i32, i32* %13
%207 = zext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
store float %204, float* %208
%209 = load float*, float** %8
%210 = load i32, i32* %13
%211 = zext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
store float %213, float* %18
store i32 0, i32* %14
br label %214
214: ; preds = %284, %193
%215 = load i32, i32* %14
%216 = load i32, i32* %13
%217 = icmp ult i32 %215, %216
br i1 %217, label %218, label %287
218: ; preds = %214
%219 = load i32, i32* %14
%220 = add i32 %219, 1
%221 = uitofp i32 %220 to float
store float %221, float* %19
%222 = load float*, float** %8
%223 = load i32, i32* %13
%224 = load i32, i32* %14
%225 = sub i32 %223, %224
%226 = sub i32 %225, 1
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds float, float* %222, i64 %227
%229 = load float, float* %228
%230 = fmul float -1.000000e+00, %229
%231 = load float, float* %15
%232 = load float, float* %19
%233 = fmul float %231, %232
%234 = call i32 @sin(float %233)
%235 = sitofp i32 %234 to float
%236 = fmul float %230, %235
%237 = load i32, i32* @M_PI
%238 = sitofp i32 %237 to float
%239 = load float, float* %19
%240 = fmul float %238, %239
%241 = fdiv float %236, %240
%242 = load float*, float** %8
%243 = load i32, i32* %7
%244 = load i32, i32* %13
%245 = sub i32 %243, %244
%246 = load i32, i32* %14
%247 = add i32 %245, %246
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds float, float* %242, i64 %248
store float %241, float* %249
%250 = load float*, float** %8
%251 = load i32, i32* %13
%252 = load i32, i32* %14
%253 = sub i32 %251, %252
%254 = sub i32 %253, 1
%255 = zext i32 %254 to i64
%256 = getelementptr inbounds float, float* %250, i64 %255
store float %241, float* %256
%257 = load i32, i32* %14
%258 = and i32 %257, 1
%259 = icmp ne i32 %258, 0
br i1 %259, label %260, label %270
260: ; preds = %218
%261 = load float*, float** %8
%262 = load i32, i32* %13
%263 = load i32, i32* %14
%264 = sub i32 %262, %263
%265 = sub i32 %264, 1
%266 = zext i32 %265 to i64
%267 = getelementptr inbounds float, float* %261, i64 %266
%268 = load float, float* %267
%269 = fmul float 2.000000e+00, %268
br label %280
270: ; preds = %218
%271 = load float*, float** %8
%272 = load i32, i32* %13
%273 = load i32, i32* %14
%274 = sub i32 %272, %273
%275 = sub i32 %274, 1
%276 = zext i32 %275 to i64
%277 = getelementptr inbounds float, float* %271, i64 %276
%278 = load float, float* %277
%279 = fmul float -2.000000e+00, %278
br label %280
280: ; preds = %270, %260
%281 = phi float [ %269, %260 ], [ %279, %270 ]
%282 = load float, float* %18
%283 = fadd float %282, %281
store float %283, float* %18
br label %284
284: ; preds = %280
%285 = load i32, i32* %14
%286 = add i32 %285, 1
store i32 %286, i32* %14
br label %214
287: ; preds = %214
br label %288
288: ; preds = %287, %188
br label %289
289: ; preds = %288, %79
%290 = load i32, i32* %10
%291 = and i32 %290, 786432
%292 = icmp ne i32 %291, 0
br i1 %292, label %293, label %540
293: ; preds = %289
%294 = load float*, float** %9
%295 = getelementptr inbounds float, float* %294, i64 0
%296 = load float, float* %295
store float %296, float* %22
%297 = load float*, float** %9
%298 = getelementptr inbounds float, float* %297, i64 1
%299 = load float, float* %298
store float %299, float* %23
%300 = load float, float* %22
%301 = fpext float %300 to double
%302 = fcmp ole double %301, 1.000000e+00
br i1 %302, label %303, label %311
303: ; preds = %293
%304 = load float, float* %22
%305 = fpext float %304 to double
%306 = fcmp ogt double %305, 0.000000e+00
br i1 %306, label %307, label %311
307: ; preds = %303
%308 = load float, float* %22
%309 = fdiv float %308, 2.000000e+00
%310 = fpext float %309 to double
br label %312
311: ; preds = %303, %293
br label %312
312: ; preds = %311, %307
%313 = phi double [ %310, %307 ], [ 2.500000e-01, %311 ]
%314 = fptrunc double %313 to float
store float %314, float* %22
%315 = load float, float* %23
%316 = fpext float %315 to double
%317 = fcmp ole double %316, 1.000000e+00
br i1 %317, label %318, label %326
318: ; preds = %312
%319 = load float, float* %23
%320 = fpext float %319 to double
%321 = fcmp ogt double %320, 0.000000e+00
br i1 %321, label %322, label %326
322: ; preds = %318
%323 = load float, float* %23
%324 = fdiv float %323, 2.000000e+00
%325 = fpext float %324 to double
br label %327
326: ; preds = %318, %312
br label %327
327: ; preds = %326, %322
%328 = phi double [ %325, %322 ], [ 2.500000e-01, %326 ]
%329 = fptrunc double %328 to float
store float %329, float* %23
%330 = load float, float* %15
%331 = load float, float* %23
%332 = fmul float %330, %331
store float %332, float* %17
%333 = load float, float* %22
%334 = load float, float* %15
%335 = fmul float %334, %333
store float %335, float* %15
%336 = load i32, i32* %10
%337 = and i32 %336, 262144
%338 = icmp ne i32 %337, 0
br i1 %338, label %339, label %443
339: ; preds = %327
%340 = load i32, i32* %12
%341 = icmp ne i32 %340, 0
br i1 %341, label %342, label %368
342: ; preds = %339
%343 = load float*, float** %8
%344 = load i32, i32* %13
%345 = zext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
%348 = load float, float* %22
%349 = load float, float* %23
%350 = fadd float %348, %349
%351 = fmul float %347, %350
store float %351, float* %18
%352 = load float, float* %23
%353 = load float, float* %22
%354 = fsub float %352, %353
%355 = load float*, float** %8
%356 = load i32, i32* %13
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds float, float* %355, i64 %357
%359 = load float, float* %358
%360 = fmul float %354, %359
%361 = fpext float %360 to double
%362 = fmul double %361, 2.000000e+00
%363 = fptrunc double %362 to float
%364 = load float*, float** %8
%365 = load i32, i32* %13
%366 = zext i32 %365 to i64
%367 = getelementptr inbounds float, float* %364, i64 %366
store float %363, float* %367
br label %368
368: ; preds = %342, %339
store i32 0, i32* %14
br label %369
369: ; preds = %439, %368
%370 = load i32, i32* %14
%371 = load i32, i32* %13
%372 = icmp ult i32 %370, %371
br i1 %372, label %373, label %442
373: ; preds = %369
%374 = load i32, i32* %14
%375 = add i32 %374, 1
%376 = uitofp i32 %375 to float
%377 = load float, float* %16
%378 = fsub float %376, %377
store float %378, float* %19
%379 = load float, float* %17
%380 = load float, float* %19
%381 = fmul float %379, %380
%382 = call i32 @sin(float %381)
%383 = sitofp i32 %382 to float
%384 = load i32, i32* @M_PI
%385 = sitofp i32 %384 to float
%386 = load float, float* %19
%387 = fmul float %385, %386
%388 = fdiv float %383, %387
store float %388, float* %20
%389 = load float, float* %15
%390 = load float, float* %19
%391 = fmul float %389, %390
%392 = call i32 @sin(float %391)
%393 = sitofp i32 %392 to float
%394 = load i32, i32* @M_PI
%395 = sitofp i32 %394 to float
%396 = load float, float* %19
%397 = fmul float %395, %396
%398 = fdiv float %393, %397
store float %398, float* %21
%399 = load float*, float** %8
%400 = load i32, i32* %13
%401 = load i32, i32* %14
%402 = sub i32 %400, %401
%403 = sub i32 %402, 1
%404 = zext i32 %403 to i64
%405 = getelementptr inbounds float, float* %399, i64 %404
%406 = load float, float* %405
%407 = load float, float* %21
%408 = load float, float* %20
%409 = fadd float %407, %408
%410 = load float, float* %18
%411 = call float @llvm.fmuladd.f32(float %406, float %409, float %410)
store float %411, float* %18
%412 = load float*, float** %8
%413 = load i32, i32* %13
%414 = load i32, i32* %14
%415 = sub i32 %413, %414
%416 = sub i32 %415, 1
%417 = zext i32 %416 to i64
%418 = getelementptr inbounds float, float* %412, i64 %417
%419 = load float, float* %418
%420 = load float, float* %20
%421 = load float, float* %21
%422 = fsub float %420, %421
%423 = fmul float %419, %422
%424 = load float*, float** %8
%425 = load i32, i32* %7
%426 = load i32, i32* %13
%427 = sub i32 %425, %426
%428 = load i32, i32* %14
%429 = add i32 %427, %428
%430 = zext i32 %429 to i64
%431 = getelementptr inbounds float, float* %424, i64 %430
store float %423, float* %431
%432 = load float*, float** %8
%433 = load i32, i32* %13
%434 = load i32, i32* %14
%435 = sub i32 %433, %434
%436 = sub i32 %435, 1
%437 = zext i32 %436 to i64
%438 = getelementptr inbounds float, float* %432, i64 %437
store float %423, float* %438
br label %439
439: ; preds = %373
%440 = load i32, i32* %14
%441 = add i32 %440, 1
store i32 %441, i32* %14
br label %369
442: ; preds = %369
br label %539
443: ; preds = %327
%444 = load i32, i32* %12
%445 = icmp ne i32 %444, 0
br i1 %445, label %447, label %446
446: ; preds = %443
store i32 -1, i32* %6
br label %559
447: ; preds = %443
%448 = load float, float* %23
%449 = load float, float* %22
%450 = fsub float %448, %449
%451 = load float*, float** %8
%452 = load i32, i32* %13
%453 = zext i32 %452 to i64
%454 = getelementptr inbounds float, float* %451, i64 %453
%455 = load float, float* %454
%456 = fmul float %450, %455
%457 = fpext float %456 to double
%458 = fneg double %457
%459 = call double @llvm.fmuladd.f64(double %458, double 2.000000e+00, double 1.000000e+00)
%460 = fptrunc double %459 to float
%461 = load float*, float** %8
%462 = load i32, i32* %13
%463 = zext i32 %462 to i64
%464 = getelementptr inbounds float, float* %461, i64 %463
store float %460, float* %464
%465 = load float*, float** %8
%466 = load i32, i32* %13
%467 = zext i32 %466 to i64
%468 = getelementptr inbounds float, float* %465, i64 %467
%469 = load float, float* %468
store float %469, float* %18
store i32 0, i32* %14
br label %470
470: ; preds = %535, %447
%471 = load i32, i32* %14
%472 = load i32, i32* %13
%473 = icmp ult i32 %471, %472
br i1 %473, label %474, label %538
474: ; preds = %470
%475 = load i32, i32* %14
%476 = add i32 %475, 1
%477 = uitofp i32 %476 to float
store float %477, float* %19
%478 = load float, float* %15
%479 = load float, float* %19
%480 = fmul float %478, %479
%481 = call i32 @sin(float %480)
%482 = sitofp i32 %481 to float
%483 = load i32, i32* @M_PI
%484 = sitofp i32 %483 to float
%485 = load float, float* %19
%486 = fmul float %484, %485
%487 = fdiv float %482, %486
store float %487, float* %20
%488 = load float, float* %17
%489 = load float, float* %19
%490 = fmul float %488, %489
%491 = call i32 @sin(float %490)
%492 = sitofp i32 %491 to float
%493 = load i32, i32* @M_PI
%494 = sitofp i32 %493 to float
%495 = load float, float* %19
%496 = fmul float %494, %495
%497 = fdiv float %492, %496
store float %497, float* %21
%498 = load float*, float** %8
%499 = load i32, i32* %13
%500 = load i32, i32* %14
%501 = sub i32 %499, %500
%502 = sub i32 %501, 1
%503 = zext i32 %502 to i64
%504 = getelementptr inbounds float, float* %498, i64 %503
%505 = load float, float* %504
%506 = load float, float* %20
%507 = load float, float* %21
%508 = fsub float %506, %507
%509 = fmul float %505, %508
%510 = load float*, float** %8
%511 = load i32, i32* %7
%512 = load i32, i32* %13
%513 = sub i32 %511, %512
%514 = load i32, i32* %14
%515 = add i32 %513, %514
%516 = zext i32 %515 to i64
%517 = getelementptr inbounds float, float* %510, i64 %516
store float %509, float* %517
%518 = load float*, float** %8
%519 = load i32, i32* %13
%520 = load i32, i32* %14
%521 = sub i32 %519, %520
%522 = sub i32 %521, 1
%523 = zext i32 %522 to i64
%524 = getelementptr inbounds float, float* %518, i64 %523
store float %509, float* %524
%525 = load float*, float** %8
%526 = load i32, i32* %13
%527 = load i32, i32* %14
%528 = sub i32 %526, %527
%529 = sub i32 %528, 1
%530 = zext i32 %529 to i64
%531 = getelementptr inbounds float, float* %525, i64 %530
%532 = load float, float* %531
%533 = load float, float* %18
%534 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %532, float %533)
store float %534, float* %18
br label %535
535: ; preds = %474
%536 = load i32, i32* %14
%537 = add i32 %536, 1
store i32 %537, i32* %14
br label %470
538: ; preds = %470
br label %539
539: ; preds = %538, %442
br label %540
540: ; preds = %539, %289
%541 = load float, float* %18
%542 = fdiv float 1.000000e+00, %541
store float %542, float* %18
store i32 0, i32* %14
br label %543
543: ; preds = %555, %540
%544 = load i32, i32* %14
%545 = load i32, i32* %7
%546 = icmp ult i32 %544, %545
br i1 %546, label %547, label %558
547: ; preds = %543
%548 = load float, float* %18
%549 = load float*, float** %8
%550 = load i32, i32* %14
%551 = zext i32 %550 to i64
%552 = getelementptr inbounds float, float* %549, i64 %551
%553 = load float, float* %552
%554 = fmul float %553, %548
store float %554, float* %552
br label %555
555: ; preds = %547
%556 = load i32, i32* %14
%557 = add i32 %556, 1
store i32 %557, i32* %14
br label %543
558: ; preds = %543
store i32 0, i32* %6
br label %559
559: ; preds = %558, %446, %192, %78, %45
%560 = load i32, i32* %6
ret i32 %560
}

LLVM IR (-O2):
@M_PI = global i32 0
define i32 @design_fir(i32 %0, float* %1, float* nocapture %2, i32 %3, float %4) {
%6 = and i32 %0, 1
%7 = add i32 %0, 1
%8 = lshr i32 %7, 1
%9 = sub nsw i32 %8, %6
%10 = load i32, i32* @M_PI
%11 = shl nsw i32 %10, 1
%12 = sitofp i32 %11 to float
%13 = xor i32 %6, 1
%14 = uitofp i32 %13 to float
%15 = fmul float %14, 5.000000e-01
%16 = icmp eq float* %1, null
%17 = icmp eq i32 %0, 0
%18 = or i1 %17, %16
br i1 %18, label %331, label %19
19: ; preds = %5
%20 = and i32 %3, 31
switch i32 %20, label %331 [
i32 1, label %21
i32 2, label %23
i32 4, label %25
i32 8, label %27
i32 16, label %29
i32 17, label %31
i32 18, label %33
]
21: ; preds = %19
%22 = tail call i32 @boxcar(i32 %0, float* %1)
br label %35
23: ; preds = %19
%24 = tail call i32 @triang(i32 %0, float* %1)
br label %35
25: ; preds = %19
%26 = tail call i32 @hamming(i32 %0, float* %1)
br label %35
27: ; preds = %19
%28 = tail call i32 @hanning(i32 %0, float* %1)
br label %35
29: ; preds = %19
%30 = tail call i32 @blackman(i32 %0, float* %1)
br label %35
31: ; preds = %19
%32 = tail call i32 @flattop(i32 %0, float* %1)
br label %35
33: ; preds = %19
%34 = tail call i32 @kaiser(i32 %0, float* %1, float %4)
br label %35
35: ; preds = %33, %31, %29, %27, %25, %23, %21
%36 = and i32 %3, 196608
%37 = icmp eq i32 %36, 0
br i1 %37, label %131, label %38
38: ; preds = %35
%39 = load float, float* %2
%40 = fcmp ole float %39, 1.000000e+00
%41 = fcmp ogt float %39, 0.000000e+00
%42 = and i1 %40, %41
%43 = fmul float %39, 5.000000e-01
%44 = select i1 %42, float %43, float 2.500000e-01
%45 = fmul float %44, %12
%46 = and i32 %3, 65536
%47 = icmp eq i32 %46, 0
%48 = icmp eq i32 %6, 0
br i1 %47, label %88, label %49
49: ; preds = %38
br i1 %48, label %56, label %50
50: ; preds = %49
%51 = zext i32 %9 to i64
%52 = getelementptr inbounds float, float* %1, i64 %51
%53 = load float, float* %52
%54 = fmul float %44, %53
%55 = fmul float %54, 2.000000e+00
store float %55, float* %52
br label %56
56: ; preds = %50, %49
%57 = phi float [ %55, %50 ], [ 0.000000e+00, %49 ]
%58 = icmp eq i32 %9, 0
br i1 %58, label %131, label %59
59: ; preds = %56
%60 = sub i32 %0, %9
%61 = zext i32 %9 to i64
br label %62
62: ; preds = %59, %62
%63 = phi i64 [ 0, %59 ], [ %66, %62 ]
%64 = phi float [ %57, %59 ], [ %86, %62 ]
%65 = trunc i64 %63 to i32
%66 = add nuw nsw i64 %63, 1
%67 = trunc i64 %66 to i32
%68 = uitofp i32 %67 to float
%69 = fsub float %68, %15
%70 = xor i32 %65, -1
%71 = add i32 %9, %70
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds float, float* %1, i64 %72
%74 = load float, float* %73
%75 = fmul float %45, %69
%76 = tail call i32 @sin(float %75)
%77 = sitofp i32 %76 to float
%78 = fmul float %74, %77
%79 = load i32, i32* @M_PI
%80 = sitofp i32 %79 to float
%81 = fmul float %69, %80
%82 = fdiv float %78, %81
%83 = add i32 %60, %65
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds float, float* %1, i64 %84
store float %82, float* %85
store float %82, float* %73
%86 = tail call float @llvm.fmuladd.f32(float %82, float 2.000000e+00, float %64)
%87 = icmp eq i64 %66, %61
br i1 %87, label %131, label %62
88: ; preds = %38
br i1 %48, label %331, label %89
89: ; preds = %88
%90 = zext i32 %9 to i64
%91 = getelementptr inbounds float, float* %1, i64 %90
%92 = load float, float* %91
%93 = fmul float %44, %92
%94 = fpext float %93 to double
%95 = fneg double %94
%96 = tail call double @llvm.fmuladd.f64(double %95, double 2.000000e+00, double 1.000000e+00)
%97 = fptrunc double %96 to float
store float %97, float* %91
%98 = icmp eq i32 %9, 0
br i1 %98, label %131, label %99
99: ; preds = %89
%100 = sub i32 %0, %9
br label %101
101: ; preds = %99, %101
%102 = phi i64 [ 0, %99 ], [ %105, %101 ]
%103 = phi float [ %97, %99 ], [ %129, %101 ]
%104 = trunc i64 %102 to i32
%105 = add nuw nsw i64 %102, 1
%106 = trunc i64 %105 to i32
%107 = uitofp i32 %106 to float
%108 = xor i32 %104, -1
%109 = add i32 %9, %108
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds float, float* %1, i64 %110
%112 = load float, float* %111
%113 = fneg float %112
%114 = fmul float %45, %107
%115 = tail call i32 @sin(float %114)
%116 = sitofp i32 %115 to float
%117 = fmul float %113, %116
%118 = load i32, i32* @M_PI
%119 = sitofp i32 %118 to float
%120 = fmul float %107, %119
%121 = fdiv float %117, %120
%122 = add i32 %100, %104
%123 = zext i32 %122 to i64
%124 = getelementptr inbounds float, float* %1, i64 %123
store float %121, float* %124
store float %121, float* %111
%125 = and i32 %104, 1
%126 = icmp eq i32 %125, 0
%127 = select i1 %126, float -2.000000e+00, float 2.000000e+00
%128 = fmul float %127, %121
%129 = fadd float %103, %128
%130 = icmp eq i64 %105, %90
br i1 %130, label %131, label %101
131: ; preds = %62, %101, %56, %89, %35
%132 = phi float [ %12, %35 ], [ %45, %89 ], [ %45, %56 ], [ %45, %101 ], [ %45, %62 ]
%133 = phi float [ 0.000000e+00, %35 ], [ %97, %89 ], [ %57, %56 ], [ %129, %101 ], [ %86, %62 ]
%134 = and i32 %3, 786432
%135 = icmp eq i32 %134, 0
br i1 %135, label %261, label %136
136: ; preds = %131
%137 = load float, float* %2
%138 = getelementptr inbounds float, float* %2, i64 1
%139 = load float, float* %138
%140 = fcmp ole float %137, 1.000000e+00
%141 = fcmp ogt float %137, 0.000000e+00
%142 = and i1 %140, %141
%143 = fmul float %137, 5.000000e-01
%144 = select i1 %142, float %143, float 2.500000e-01
%145 = fcmp ole float %139, 1.000000e+00
%146 = fcmp ogt float %139, 0.000000e+00
%147 = and i1 %145, %146
%148 = fmul float %139, 5.000000e-01
%149 = select i1 %147, float %148, float 2.500000e-01
%150 = fmul float %132, %149
%151 = fmul float %132, %144
%152 = and i32 %3, 262144
%153 = icmp eq i32 %152, 0
%154 = icmp eq i32 %6, 0
br i1 %153, label %210, label %155
155: ; preds = %136
br i1 %154, label %165, label %156
156: ; preds = %155
%157 = zext i32 %9 to i64
%158 = getelementptr inbounds float, float* %1, i64 %157
%159 = load float, float* %158
%160 = fadd float %144, %149
%161 = fmul float %160, %159
%162 = fsub float %149, %144
%163 = fmul float %162, %159
%164 = fmul float %163, 2.000000e+00
store float %164, float* %158
br label %165
165: ; preds = %156, %155
%166 = phi float [ %161, %156 ], [ %133, %155 ]
%167 = icmp eq i32 %9, 0
br i1 %167, label %261, label %168
168: ; preds = %165
%169 = sub i32 %0, %9
%170 = zext i32 %9 to i64
br label %171
171: ; preds = %168, %171
%172 = phi i64 [ 0, %168 ], [ %175, %171 ]
%173 = phi float [ %166, %168 ], [ %203, %171 ]
%174 = trunc i64 %172 to i32
%175 = add nuw nsw i64 %172, 1
%176 = trunc i64 %175 to i32
%177 = uitofp i32 %176 to float
%178 = fsub float %177, %15
%179 = fmul float %150, %178
%180 = tail call i32 @sin(float %179)
%181 = load i32, i32* @M_PI
%182 = fmul float %151, %178
%183 = tail call i32 @sin(float %182)
%184 = insertelement <2 x i32> poison, i32 %180, i64 0
%185 = insertelement <2 x i32> %184, i32 %183, i64 1
%186 = sitofp <2 x i32> %185 to <2 x float>
%187 = load i32, i32* @M_PI
%188 = insertelement <2 x i32> poison, i32 %181, i64 0
%189 = insertelement <2 x i32> %188, i32 %187, i64 1
%190 = sitofp <2 x i32> %189 to <2 x float>
%191 = insertelement <2 x float> poison, float %178, i64 0
%192 = shufflevector <2 x float> %191, <2 x float> poison, <2 x i32> zeroinitializer
%193 = fmul <2 x float> %192, %190
%194 = fdiv <2 x float> %186, %193
%195 = xor i32 %174, -1
%196 = add i32 %9, %195
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds float, float* %1, i64 %197
%199 = load float, float* %198
%200 = extractelement <2 x float> %194, i64 0
%201 = extractelement <2 x float> %194, i64 1
%202 = fadd float %200, %201
%203 = tail call float @llvm.fmuladd.f32(float %199, float %202, float %173)
%204 = fsub float %200, %201
%205 = fmul float %199, %204
%206 = add i32 %169, %174
%207 = zext i32 %206 to i64
%208 = getelementptr inbounds float, float* %1, i64 %207
store float %205, float* %208
store float %205, float* %198
%209 = icmp eq i64 %175, %170
br i1 %209, label %261, label %171
210: ; preds = %136
br i1 %154, label %331, label %211
211: ; preds = %210
%212 = fsub float %149, %144
%213 = zext i32 %9 to i64
%214 = getelementptr inbounds float, float* %1, i64 %213
%215 = load float, float* %214
%216 = fmul float %212, %215
%217 = fpext float %216 to double
%218 = fneg double %217
%219 = tail call double @llvm.fmuladd.f64(double %218, double 2.000000e+00, double 1.000000e+00)
%220 = fptrunc double %219 to float
store float %220, float* %214
%221 = icmp eq i32 %9, 0
br i1 %221, label %261, label %222
222: ; preds = %211
%223 = sub i32 %0, %9
br label %224
224: ; preds = %222, %224
%225 = phi i64 [ 0, %222 ], [ %228, %224 ]
%226 = phi float [ %220, %222 ], [ %259, %224 ]
%227 = trunc i64 %225 to i32
%228 = add nuw nsw i64 %225, 1
%229 = trunc i64 %228 to i32
%230 = uitofp i32 %229 to float
%231 = fmul float %151, %230
%232 = tail call i32 @sin(float %231)
%233 = load i32, i32* @M_PI
%234 = fmul float %150, %230
%235 = tail call i32 @sin(float %234)
%236 = insertelement <2 x i32> poison, i32 %232, i64 0
%237 = insertelement <2 x i32> %236, i32 %235, i64 1
%238 = sitofp <2 x i32> %237 to <2 x float>
%239 = load i32, i32* @M_PI
%240 = insertelement <2 x i32> poison, i32 %233, i64 0
%241 = insertelement <2 x i32> %240, i32 %239, i64 1
%242 = sitofp <2 x i32> %241 to <2 x float>
%243 = insertelement <2 x float> poison, float %230, i64 0
%244 = shufflevector <2 x float> %243, <2 x float> poison, <2 x i32> zeroinitializer
%245 = fmul <2 x float> %244, %242
%246 = fdiv <2 x float> %238, %245
%247 = xor i32 %227, -1
%248 = add i32 %9, %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds float, float* %1, i64 %249
%251 = load float, float* %250
%252 = shufflevector <2 x float> %246, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%253 = fsub <2 x float> %246, %252
%254 = extractelement <2 x float> %253, i64 0
%255 = fmul float %251, %254
%256 = add i32 %223, %227
%257 = zext i32 %256 to i64
%258 = getelementptr inbounds float, float* %1, i64 %257
store float %255, float* %258
store float %255, float* %250
%259 = tail call float @llvm.fmuladd.f32(float %255, float 2.000000e+00, float %226)
%260 = icmp eq i64 %228, %213
br i1 %260, label %261, label %224
261: ; preds = %171, %224, %131, %211, %165
%262 = phi float [ %133, %131 ], [ %220, %211 ], [ %166, %165 ], [ %259, %224 ], [ %203, %171 ]
%263 = fdiv float 1.000000e+00, %262
%264 = zext i32 %0 to i64
%265 = icmp ult i32 %0, 8
br i1 %265, label %322, label %266
266: ; preds = %261
%267 = and i64 %264, 4294967288
%268 = insertelement <4 x float> poison, float %263, i64 0
%269 = shufflevector <4 x float> %268, <4 x float> poison, <4 x i32> zeroinitializer
%270 = insertelement <4 x float> poison, float %263, i64 0
%271 = shufflevector <4 x float> %270, <4 x float> poison, <4 x i32> zeroinitializer
%272 = add nsw i64 %267, -8
%273 = lshr exact i64 %272, 3
%274 = add nuw nsw i64 %273, 1
%275 = and i64 %274, 1
%276 = icmp eq i64 %272, 0
br i1 %276, label %306, label %277
277: ; preds = %266
%278 = and i64 %274, 4611686018427387902
br label %279
279: ; preds = %279, %277
%280 = phi i64 [ 0, %277 ], [ %303, %279 ]
%281 = phi i64 [ 0, %277 ], [ %304, %279 ]
%282 = getelementptr inbounds float, float* %1, i64 %280
%283 = bitcast float* %282 to <4 x float>*
%284 = load <4 x float>, <4 x float>* %283
%285 = getelementptr inbounds float, float* %282, i64 4
%286 = bitcast float* %285 to <4 x float>*
%287 = load <4 x float>, <4 x float>* %286
%288 = fmul <4 x float> %269, %284
%289 = fmul <4 x float> %271, %287
%290 = bitcast float* %282 to <4 x float>*
store <4 x float> %288, <4 x float>* %290
%291 = bitcast float* %285 to <4 x float>*
store <4 x float> %289, <4 x float>* %291
%292 = or i64 %280, 8
%293 = getelementptr inbounds float, float* %1, i64 %292
%294 = bitcast float* %293 to <4 x float>*
%295 = load <4 x float>, <4 x float>* %294
%296 = getelementptr inbounds float, float* %293, i64 4
%297 = bitcast float* %296 to <4 x float>*
%298 = load <4 x float>, <4 x float>* %297
%299 = fmul <4 x float> %269, %295
%300 = fmul <4 x float> %271, %298
%301 = bitcast float* %293 to <4 x float>*
store <4 x float> %299, <4 x float>* %301
%302 = bitcast float* %296 to <4 x float>*
store <4 x float> %300, <4 x float>* %302
%303 = add nuw i64 %280, 16
%304 = add i64 %281, 2
%305 = icmp eq i64 %304, %278
br i1 %305, label %306, label %279
306: ; preds = %279, %266
%307 = phi i64 [ 0, %266 ], [ %303, %279 ]
%308 = icmp eq i64 %275, 0
br i1 %308, label %320, label %309
309: ; preds = %306
%310 = getelementptr inbounds float, float* %1, i64 %307
%311 = bitcast float* %310 to <4 x float>*
%312 = load <4 x float>, <4 x float>* %311
%313 = getelementptr inbounds float, float* %310, i64 4
%314 = bitcast float* %313 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = fmul <4 x float> %269, %312
%317 = fmul <4 x float> %271, %315
%318 = bitcast float* %310 to <4 x float>*
store <4 x float> %316, <4 x float>* %318
%319 = bitcast float* %313 to <4 x float>*
store <4 x float> %317, <4 x float>* %319
br label %320
320: ; preds = %306, %309
%321 = icmp eq i64 %267, %264
br i1 %321, label %331, label %322
322: ; preds = %261, %320
%323 = phi i64 [ 0, %261 ], [ %267, %320 ]
br label %324
324: ; preds = %322, %324
%325 = phi i64 [ %329, %324 ], [ %323, %322 ]
%326 = getelementptr inbounds float, float* %1, i64 %325
%327 = load float, float* %326
%328 = fmul float %263, %327
store float %328, float* %326
%329 = add nuw nsw i64 %325, 1
%330 = icmp eq i64 %329, %264
br i1 %330, label %331, label %324
331: ; preds = %324, %320, %210, %88, %19, %5
%332 = phi i32 [ -1, %5 ], [ -1, %19 ], [ -1, %88 ], [ -1, %210 ], [ 0, %320 ], [ 0, %324 ]
ret i32 %332
}