#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 */
double sin(double);
void four1(float *data, int *nn, int *isign) {
  int n, mmax, m, j, i;
  double wtemp, wr, wpr, wpi, wi, theta, wpin;
  double tempr, tempi, datar, datai, data1r, data1i;
  n = *nn * 2;
  j = 0;
  for (i = 0; i < n; i += 2) {
    if (j > i) {
      tempr = data[j];
      data[j] = data[i];
      data[i] = tempr;
      tempr = data[j + 1];
      data[j + 1] = data[i + 1];
      data[i + 1] = tempr;
    }
    m = *nn;
    while (m >= 2 && j >= m) {
      j -= m;
      m >>= 1;
    }
    j += m;
  }
  theta = 3.141592653589795 * .5;
  if (*isign < 0)
    theta = -theta;
  wpin = 0;
  for (mmax = 2; n > mmax; mmax *= 2) {
    wpi = wpin;
    wpin = sin(theta);
    wpr = 1 - wpin * wpin - wpin * wpin;
    theta *= .5;
    wr = 1;
    wi = 0;
    for (m = 0; m < mmax; m += 2) {
      j = m + mmax;
      tempr = (double)wr * (data1r = data[j]);
      tempi = (double)wi * (data1i = data[j + 1]);
      for (i = m; i < n - mmax * 2; i += mmax * 2) {
        tempr -= tempi;
        tempi = (double)wr * data1i + (double)wi * data1r;
        data1r = data[j + mmax * 2];
        data1i = data[j + mmax * 2 + 1];
        data[i] = (datar = data[i]) + tempr;
        data[i + 1] = (datai = data[i + 1]) + tempi;
        data[j] = datar - tempr;
        data[j + 1] = datai - tempi;
        tempr = (double)wr * data1r;
        tempi = (double)wi * data1i;
        j += mmax * 2;
      }
      tempr -= tempi;
      tempi = (double)wr * data1i + (double)wi * data1r;
      data[i] = (datar = data[i]) + tempr;
      data[i + 1] = (datai = data[i + 1]) + tempi;
      data[j] = datar - tempr;
      data[j + 1] = datai - tempi;
      wr = (wtemp = wr) * wpr - wi * wpi;
      wi = wtemp * wpi + wi * wpr;
    }
  }
}


x86 assembly (clang, -O0):
<four1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1266 <four1+0x156>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    11f9 <four1+0xe9>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x2,-0x24(%rbp)
mov    %al,-0x99(%rbp)
jl     1223 <four1+0x113>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
setge  %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    1236 <four1+0x126>
jmp    124f <four1+0x13f>
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1202 <four1+0xf2>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1141 <four1+0x31>
movsd  0xd92(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jge    12a1 <four1+0x191>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x2,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    16a9 <four1+0x599>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xd06(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xcd4(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xcba(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1696 <four1+0x586>
mov    -0x24(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x90(%rbp)
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,-0x98(%rbp)
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
cmp    %ecx,%eax
jge    154d <four1+0x43d>
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
addsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
addsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x80(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    13d0 <four1+0x2c0>
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
addsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
addsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x80(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1362 <four1+0x252>
jmp    169b <four1+0x58b>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12b0 <four1+0x1a0>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<four1>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20,%rsp
movslq (%rsi),%r8
test   %r8,%r8
jle    143d <four1+0x32d>
mov    %rdi,%rbx
mov    %r8,%r14
add    %r8,%r14
xor    %ecx,%ecx
xor    %esi,%esi
jmp    114b <four1+0x3b>
nopl   0x0(%rax,%rax,1)
add    %edi,%esi
add    $0x2,%rcx
cmp    %r14,%rcx
jge    11b1 <four1+0xa1>
movslq %esi,%rdi
cmp    %rdi,%rcx
jge    1189 <four1+0x79>
movss  (%rbx,%rdi,4),%xmm0
lea    0x0(,%rcx,4),%rax
movss  (%rbx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rdi,4)
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rbx,%rdi,4),%xmm0
or     $0x4,%rax
movss  (%rbx,%rax,1),%xmm1
movss  %xmm1,0x4(%rbx,%rdi,4)
movss  %xmm0,(%rbx,%rax,1)
mov    %r8d,%edi
cmp    $0x1,%r8d
je     1140 <four1+0x30>
cmp    %r8d,%esi
jl     1140 <four1+0x30>
nopw   0x0(%rax,%rax,1)
mov    %edi,%eax
sub    %edi,%esi
shr    %edi
cmp    $0x4,%eax
jb     1140 <four1+0x30>
cmp    %edi,%esi
jge    11a0 <four1+0x90>
jmp    1140 <four1+0x30>
cmp    $0x2,%r8d
jl     143d <four1+0x32d>
mov    (%rdx),%eax
shr    $0x1f,%eax
lea    0xe39(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm1
mov    $0x2,%r8d
xorpd  %xmm0,%xmm0
jmp    11f7 <four1+0xe7>
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rsp),%xmm1
mulsd  0xe3a(%rip),%xmm1
cmp    %r8d,%r14d
jle    143d <four1+0x32d>
mov    %r8d,%r15d
movapd %xmm0,0x10(%rsp)
movsd  %xmm1,0x8(%rsp)
movapd %xmm1,%xmm0
call   1030 <sin@plt>
movapd 0x10(%rsp),%xmm11
movapd 0xdf1(%rip),%xmm10
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm2
addsd  0xde8(%rip),%xmm2
addsd  %xmm1,%xmm2
lea    (%r15,%r15,1),%r8d
mov    %r14d,%eax
sub    %r8d,%eax
movslq %r15d,%r10
movslq %r8d,%r13
movslq %eax,%r12
mov    %r10d,%r9d
movapd %xmm2,%xmm8
unpcklpd %xmm11,%xmm8
unpcklpd %xmm2,%xmm11
xor    %r15d,%r15d
mov    %r10,%r11
movsd  0xdb1(%rip),%xmm2
jmp    133c <four1+0x22c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %esi,%rcx
or     $0x1,%rcx
mov    %r15,%rax
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
subsd  %xmm1,%xmm4
movapd %xmm9,%xmm1
mulsd  %xmm5,%xmm1
unpckhpd %xmm5,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm1,%xmm5
cltq
movss  (%rbx,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
movapd %xmm4,%xmm3
addsd  %xmm1,%xmm3
cvtsd2ss %xmm3,%xmm3
lea    0x0(,%rax,4),%rdx
movss  %xmm3,(%rbx,%rax,4)
or     $0x4,%rdx
movss  (%rbx,%rdx,1),%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm5,%xmm6
addsd  %xmm3,%xmm6
cvtsd2ss %xmm6,%xmm6
subsd  %xmm4,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm6,(%rbx,%rdx,1)
movslq %esi,%rax
movss  %xmm1,(%rbx,%rax,4)
subsd  %xmm5,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
xorpd  %xmm10,%xmm9
shufpd $0x2,%xmm2,%xmm9
mulpd  %xmm11,%xmm9
unpcklpd %xmm2,%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm9,%xmm2
add    $0x2,%r15
add    $0x2,%r11
cmp    %r9,%r15
jae    11e0 <four1+0xd0>
lea    (%r15,%r10,1),%rsi
cvtps2pd (%rbx,%rsi,4),%xmm5
movapd %xmm2,%xmm4
mulpd  %xmm5,%xmm4
movapd %xmm2,%xmm9
unpckhpd %xmm2,%xmm9
cmp    %r12,%r15
jge    1280 <four1+0x170>
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
mov    %r15,%rax
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
subsd  %xmm7,%xmm4
mulsd  %xmm9,%xmm5
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
lea    (%rdi,%r13,1),%rsi
movslq %esi,%rcx
or     $0x1,%rcx
lea    0x0(,%rax,4),%rdx
movss  (%rbx,%rax,4),%xmm5
cvtss2sd %xmm5,%xmm5
movapd %xmm4,%xmm7
addsd  %xmm5,%xmm7
cvtsd2ss %xmm7,%xmm7
movss  (%rbx,%rsi,4),%xmm1
movss  (%rbx,%rcx,4),%xmm3
unpcklps %xmm3,%xmm1
movss  %xmm7,(%rbx,%rax,4)
or     $0x4,%rdx
movss  (%rbx,%rdx,1),%xmm3
cvtss2sd %xmm3,%xmm3
movapd %xmm6,%xmm7
addsd  %xmm3,%xmm7
cvtsd2ss %xmm7,%xmm7
movss  %xmm7,(%rbx,%rdx,1)
subsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
movss  %xmm4,(%rbx,%rdi,4)
shl    $0x2,%rdi
subsd  %xmm6,%xmm3
cvtsd2ss %xmm3,%xmm3
or     $0x4,%rdi
movss  %xmm3,(%rbx,%rdi,1)
add    %r13,%rax
cvtps2pd %xmm1,%xmm5
movapd %xmm2,%xmm4
mulpd  %xmm5,%xmm4
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
mov    %rsi,%rdi
cmp    %r12,%rax
jl     1380 <four1+0x270>
jmp    128a <four1+0x17a>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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