#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 mp_mul_rcmul_nt_in1_add(int n, double *a, double *b, double *badd) {
  int i, i0, j, k;
  double ec, w1r, w1i, wkr, wki, wdr, wdi, ss;
  double xr, xi, yr, yi, bjr, bji, bkr, bki;
  ec = 2 * ((double)1.570796326794896619231321691639751442098584) / 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;
  xr = a[i];
  xi = a[i + 1];
  yr = b[i];
  yi = b[i + 1];
  badd[i] += xr * yr - xi * yi;
  badd[i + 1] += xr * yi + xi * yr;
  for (;;) {
    i0 = i - 4 * 64;
    if (i0 < 2) {
      i0 = 2;
    }
    for (j = i - 2; j >= i0; j -= 2) {
      k = n - j;
      xr = wkr + ss * wdi;
      xi = wki + ss * (((double)0.5) - wdr);
      wkr = wdr;
      wki = wdi;
      wdr = xr;
      wdi = xi;
      xr = b[j] - b[k];
      xi = b[j + 1] + b[k + 1];
      yr = wkr * xr - wki * xi;
      yi = wkr * xi + wki * xr;
      xr = b[j] - yr;
      xi = b[j + 1] - yi;
      yr = b[k] + yr;
      yi = b[k + 1] - yi;
      bjr = badd[j] + (a[j] * xr - a[j + 1] * xi);
      bji = badd[j + 1] + (a[j] * xi + a[j + 1] * xr);
      bkr = badd[k] + (a[k] * yr - a[k + 1] * yi);
      bki = badd[k + 1] + (a[k] * yi + a[k + 1] * yr);
      xr = bjr - bkr;
      xi = bji + bki;
      yr = wkr * xr + wki * xi;
      yi = wkr * xi - wki * xr;
      badd[j] = bjr - yr;
      badd[j + 1] = bji - yi;
      badd[k] = bkr + yr;
      badd[k + 1] = bki - yi;
    }
    if (i0 == 2) {
      break;
    }
    wkr = ((double)0.5) * sin(ec * i0);
    wki = ((double)0.5) * cos(ec * i0);
    wdr = ((double)0.5) - (wkr * w1r - wki * w1i);
    wdi = wkr * w1i + wki * w1r;
    wkr = ((double)0.5) - wkr;
    i = i0;
  }
}


x86 assembly (clang, -O0):
<mp_mul_rcmul_nt_in1_add>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
cvtsi2sdl -0x4(%rbp),%xmm1
movsd  0xec9(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
addsd  %xmm1,%xmm1
movsd  0xe5b(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe42(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xe30(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    12db <mp_mul_rcmul_nt_in1_add+0x1bb>
movl   $0x2,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1701 <mp_mul_rcmul_nt_in1_add+0x5e1>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  0xcf1(%rip),%xmm2
subsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x80(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x78(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm3
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12e4 <mp_mul_rcmul_nt_in1_add+0x1c4>
cmpl   $0x2,-0x28(%rbp)
jne    1710 <mp_mul_rcmul_nt_in1_add+0x5f0>
jmp    17e0 <mp_mul_rcmul_nt_in1_add+0x6c0>
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  0x8ea(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1040 <cos@plt>
movaps %xmm0,%xmm1
movsd  0x8c3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x87f(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x84d(%rip),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    12bf <mp_mul_rcmul_nt_in1_add+0x19f>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mp_mul_rcmul_nt_in1_add>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x40,%rsp
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %edi,%ebp
cvtsi2sd %edi,%xmm1
movsd  0xebd(%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),%xmm13
mulsd  %xmm0,%xmm13
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe85(%rip),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x30(%rsp)
movapd %xmm13,%xmm1
addsd  %xmm13,%xmm1
movsd  %xmm1,0x28(%rsp)
movapd %xmm1,%xmm14
addsd  %xmm1,%xmm14
mov    %ebp,%eax
sar    %eax
movslq %eax,%rcx
movupd (%r14,%rcx,8),%xmm1
movsd  (%r15,%rcx,8),%xmm2
movsd  0x8(%r15,%rcx,8),%xmm3
movapd 0xe57(%rip),%xmm4
xorpd  %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm1,%xmm2
movupd (%rbx,%rcx,8),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rbx,%rcx,8)
movslq %ebp,%r12
add    $0x2,%r12
xorpd  %xmm1,%xmm1
movsd  0xe08(%rip),%xmm15
movapd 0xe0f(%rip),%xmm10
xorpd  %xmm4,%xmm4
movsd  %xmm14,0x20(%rsp)
nopl   0x0(%rax)
cmp    $0x103,%eax
mov    $0x102,%ecx
cmovge %eax,%ecx
lea    -0x100(%rcx),%ebp
add    $0xffffff02,%ecx
cmp    %ecx,%eax
jl     13ee <mp_mul_rcmul_nt_in1_add+0x2ce>
cltq
mov    %ebp,%ecx
mov    %r12,%rdx
sub    %rax,%rdx
add    $0xfffffffffffffffe,%rax
nop
movapd %xmm14,%xmm8
mulsd  %xmm13,%xmm8
addsd  %xmm4,%xmm8
movapd %xmm15,%xmm12
subsd  %xmm0,%xmm12
mulsd  %xmm14,%xmm12
addsd  %xmm1,%xmm12
movupd (%r14,%rax,8),%xmm5
movupd (%r14,%rdx,8),%xmm3
movapd %xmm5,%xmm2
subpd  %xmm3,%xmm2
movapd %xmm5,%xmm6
addpd  %xmm3,%xmm6
movapd %xmm6,%xmm4
movsd  %xmm2,%xmm4
shufpd $0x1,%xmm13,%xmm6
movapd %xmm13,%xmm9
xorpd  %xmm10,%xmm9
movapd %xmm9,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
mulpd  %xmm11,%xmm4
addpd  %xmm7,%xmm4
subpd  %xmm4,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
movapd %xmm3,%xmm2
addpd  %xmm4,%xmm2
subpd  %xmm4,%xmm3
movsd  (%r15,%rax,8),%xmm4
movsd  0x8(%r15,%rax,8),%xmm10
movapd %xmm6,%xmm7
mulsd  %xmm10,%xmm7
mulsd  %xmm4,%xmm6
mulsd  %xmm5,%xmm4
subsd  %xmm7,%xmm4
movapd %xmm13,%xmm7
mulsd  %xmm10,%xmm5
movapd 0xd0c(%rip),%xmm10
movapd %xmm3,%xmm1
movsd  %xmm2,%xmm1
addsd  (%rbx,%rax,8),%xmm4
addsd  %xmm5,%xmm6
addsd  0x8(%rbx,%rax,8),%xmm6
movsd  0x8(%r15,%rdx,8),%xmm5
shufpd $0x1,%xmm2,%xmm3
movapd %xmm5,%xmm2
xorpd  %xmm10,%xmm2
unpcklpd %xmm5,%xmm2
movsd  (%r15,%rdx,8),%xmm5
mulpd  %xmm3,%xmm2
movupd (%rbx,%rdx,8),%xmm3
unpcklpd %xmm5,%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm5,%xmm1
movsd  %xmm4,%xmm1
movapd %xmm5,%xmm2
unpcklpd %xmm6,%xmm2
movapd %xmm1,%xmm3
subpd  %xmm2,%xmm3
addpd  %xmm1,%xmm2
movapd %xmm2,%xmm1
movsd  %xmm3,%xmm1
unpcklpd %xmm3,%xmm7
shufpd $0x1,%xmm9,%xmm2
mulpd  %xmm7,%xmm2
mulpd  %xmm11,%xmm1
addpd  %xmm2,%xmm1
subsd  %xmm1,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
movapd %xmm5,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm5
unpckhpd %xmm1,%xmm1
subsd  %xmm1,%xmm6
movsd  %xmm6,0x8(%rbx,%rax,8)
movsd  %xmm2,%xmm5
movupd %xmm5,(%rbx,%rdx,8)
movapd %xmm0,%xmm4
movapd %xmm13,%xmm1
add    $0xfffffffffffffffe,%rax
add    $0x2,%rdx
movapd %xmm12,%xmm13
movapd %xmm8,%xmm0
cmp    %rcx,%rax
jge    1250 <mp_mul_rcmul_nt_in1_add+0x130>
cmp    $0x2,%ebp
je     149e <mp_mul_rcmul_nt_in1_add+0x37e>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
call   1030 <sin@plt>
mulsd  0xbf9(%rip),%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x38(%rsp),%xmm0
call   1040 <cos@plt>
movapd 0xbef(%rip),%xmm10
movsd  0xbd6(%rip),%xmm15
movsd  0x20(%rsp),%xmm14
movapd 0x10(%rsp),%xmm13
movapd %xmm0,%xmm1
mulsd  %xmm15,%xmm1
movsd  0x28(%rsp),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm13,%xmm2
movsd  0x30(%rsp),%xmm3
mulsd  %xmm3,%xmm2
subsd  %xmm0,%xmm2
movapd %xmm15,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm15,%xmm4
subsd  %xmm13,%xmm4
mulsd  %xmm5,%xmm13
addsd  %xmm2,%xmm13
mov    %ebp,%eax
jmp    1220 <mp_mul_rcmul_nt_in1_add+0x100>
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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