#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 cos(double);
double sin(double);
void rftbsub(int n, double *a) {
  int i, i0, j, k;
  double ec, w1r, w1i, wkr, wki, wdr, wdi, ss, xr, xi, yr, yi;
  ec = 2 * 1.570796326794896619231321691639751442098584699687 / n;
  wkr = 0;
  wki = 0;
  wdi = cos(ec);
  wdr = sin(ec);
  wdi *= wdr;
  wdr *= wdr;
  w1r = 1 - 2 * wdr;
  w1i = 2 * wdi;
  ss = 2 * w1i;
  i = n >> 1;
  a[i + 1] = -a[i + 1];
  for (;;) {
    i0 = i - 4 * 64;
    if (i0 < 4) {
      i0 = 4;
    }
    for (j = i - 4; j >= i0; j -= 4) {
      k = n - j;
      xr = a[j + 2] - a[k - 2];
      xi = a[j + 3] + a[k - 1];
      yr = wdr * xr + wdi * xi;
      yi = wdr * xi - wdi * xr;
      a[j + 2] -= yr;
      a[j + 3] = yi - a[j + 3];
      a[k - 2] += yr;
      a[k - 1] = yi - a[k - 1];
      wkr += ss * wdi;
      wki += ss * (0.5 - wdr);
      xr = a[j] - a[k];
      xi = a[j + 1] + a[k + 1];
      yr = wkr * xr + wki * xi;
      yi = wkr * xi - wki * xr;
      a[j] -= yr;
      a[j + 1] = yi - a[j + 1];
      a[k] += yr;
      a[k + 1] = yi - a[k + 1];
      wdr += ss * wki;
      wdi += ss * (0.5 - wkr);
    }
    if (i0 == 4) {
      break;
    }
    wkr = 0.5 * sin(ec * i0);
    wki = 0.5 * cos(ec * i0);
    wdr = 0.5 - (wkr * w1r - wki * w1i);
    wdi = wkr * w1i + wki * w1r;
    wkr = 0.5 - wkr;
    i = i0;
  }
  xr = a[2] - a[n - 2];
  xi = a[3] + a[n - 1];
  yr = wdr * xr + wdi * xi;
  yi = wdr * xi - wdi * xr;
  a[2] -= yr;
  a[3] = yi - a[3];
  a[n - 2] += yr;
  a[n - 1] = yi - a[n - 1];
  a[1] = -a[1];
}


x86 assembly (clang, -O0):
<rftbsub>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xed1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x28(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x28(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
addsd  %xmm1,%xmm1
movsd  0xe63(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xe4a(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe38(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1232 <rftbsub+0x112>
movl   $0x4,-0x18(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     153c <rftbsub+0x41c>
mov    -0x4(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xc66(%rip),%xmm2
subsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xb01(%rip),%xmm2
subsd  -0x40(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x1c(%rbp)
jmp    123b <rftbsub+0x11b>
cmpl   $0x4,-0x18(%rbp)
jne    154b <rftbsub+0x42b>
jmp    161b <rftbsub+0x4fb>
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  0xaaf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x18(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  0xa88(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xa44(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xa12(%rip),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1216 <rftbsub+0xf6>
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rftbsub>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x40,%rsp
mov    %rsi,%rbx
mov    %edi,%ebp
cvtsi2sd %edi,%xmm1
movsd  0xec3(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0x10(%rsp),%xmm9
mulsd  %xmm0,%xmm9
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe8b(%rip),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x30(%rsp)
movapd %xmm9,%xmm1
addsd  %xmm9,%xmm1
movsd  %xmm1,0x28(%rsp)
movapd %xmm1,%xmm10
addsd  %xmm1,%xmm10
movslq %ebp,%r14
sar    %ebp
movslq %ebp,%rax
movsd  0x8(%rbx,%rax,8),%xmm1
xorpd  0xe69(%rip),%xmm1
movlpd %xmm1,0x8(%rbx,%rax,8)
lea    0x20(%rbx,%r14,8),%r15
xorpd  %xmm8,%xmm8
movsd  0xe40(%rip),%xmm11
movapd 0xe47(%rip),%xmm12
xorpd  %xmm1,%xmm1
movsd  %xmm10,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x105,%ebp
mov    $0x104,%eax
cmovge %ebp,%eax
lea    -0x100(%rax),%r12d
add    $0xffffff04,%eax
cmp    %eax,%ebp
jl     1375 <rftbsub+0x255>
movslq %ebp,%rsi
lea    -0x4(%rsi),%rax
mov    %r12d,%ecx
shl    $0x3,%rsi
mov    %r15,%rdx
sub    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
movupd 0x10(%rbx,%rax,8),%xmm3
movupd -0x10(%rdx),%xmm4
movapd %xmm3,%xmm5
subpd  %xmm4,%xmm5
addpd  %xmm3,%xmm4
movapd %xmm4,%xmm6
movsd  %xmm5,%xmm6
movapd %xmm9,%xmm7
xorpd  %xmm12,%xmm7
movapd %xmm9,%xmm2
unpcklpd %xmm5,%xmm2
shufpd $0x1,%xmm7,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm2,%xmm4
movsd  %xmm3,%xmm4
movsd  %xmm2,%xmm3
subpd  %xmm3,%xmm4
movupd %xmm4,0x10(%rbx,%rax,8)
movupd -0x10(%rdx),%xmm4
movupd (%rdx),%xmm3
movapd %xmm2,%xmm5
addpd  %xmm4,%xmm5
subpd  %xmm4,%xmm2
movsd  %xmm5,%xmm2
movupd %xmm2,-0x10(%rdx)
movapd %xmm10,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm2,%xmm8
movapd %xmm11,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm2,%xmm1
movupd (%rbx,%rax,8),%xmm2
movapd %xmm2,%xmm4
subpd  %xmm3,%xmm4
addpd  %xmm2,%xmm3
movapd %xmm3,%xmm5
movsd  %xmm4,%xmm5
movapd %xmm1,%xmm6
xorpd  %xmm12,%xmm6
movapd %xmm1,%xmm7
unpcklpd %xmm4,%xmm7
shufpd $0x1,%xmm6,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm8,%xmm4
unpcklpd %xmm8,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm3,%xmm4
movapd %xmm4,%xmm3
subpd  %xmm2,%xmm3
subpd  %xmm4,%xmm2
shufpd $0x2,%xmm3,%xmm2
movupd %xmm2,(%rbx,%rax,8)
movupd (%rdx),%xmm2
movapd %xmm4,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm4
movsd  %xmm3,%xmm4
movupd %xmm4,(%rdx)
movapd %xmm10,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
movapd %xmm11,%xmm2
subsd  %xmm8,%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm2,%xmm9
add    $0xfffffffffffffffc,%rax
add    $0x20,%rdx
cmp    %rcx,%rax
jge    1230 <rftbsub+0x110>
cmp    $0x4,%r12d
je     1428 <rftbsub+0x308>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
call   1030 <sin@plt>
mulsd  0xc70(%rip),%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x38(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0xc66(%rip),%xmm12
movsd  0xc4d(%rip),%xmm11
movsd  0x20(%rsp),%xmm10
movapd 0x10(%rsp),%xmm9
movapd %xmm0,%xmm1
mulsd  %xmm11,%xmm1
movsd  0x28(%rsp),%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm9,%xmm2
movsd  0x30(%rsp),%xmm3
mulsd  %xmm3,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm11,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm11,%xmm8
subsd  %xmm9,%xmm8
mulsd  %xmm4,%xmm9
addsd  %xmm2,%xmm9
mov    %r12d,%ebp
jmp    11f0 <rftbsub+0xd0>
movsd  0x10(%rbx),%xmm1
movsd  0x18(%rbx),%xmm2
movapd %xmm1,%xmm3
subsd  -0x10(%rbx,%r14,8),%xmm3
movsd  -0x8(%rbx,%r14,8),%xmm4
addsd  %xmm2,%xmm4
movapd %xmm9,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm0,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm9,%xmm3
mulsd  %xmm0,%xmm4
subsd  %xmm3,%xmm4
unpcklpd %xmm4,%xmm1
movapd %xmm6,%xmm0
unpcklpd %xmm2,%xmm0
subpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rbx)
addsd  -0x10(%rbx,%r14,8),%xmm6
movsd  %xmm6,-0x10(%rbx,%r14,8)
subsd  -0x8(%rbx,%r14,8),%xmm4
movsd  %xmm4,-0x8(%rbx,%r14,8)
movsd  0x8(%rbx),%xmm0
xorps  0xb79(%rip),%xmm0
movlps %xmm0,0x8(%rbx)
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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