void dradf2(long ido, long l1, const double *cc, double *ch,
            const double *wa1) {
  long i, k;
  double ti2, tr2;
  long t0, t1, t2, t3, t4, t5, t6;
  t1 = 0;
  t0 = (t2 = l1 * ido);
  t3 = ido << 1;
  for (k = 0; k < l1; k++) {
    ch[t1 << 1] = cc[t1] + cc[t2];
    ch[(t1 << 1) + t3 - 1] = cc[t1] - cc[t2];
    t1 += ido;
    t2 += ido;
  }
  if (ido < 2)
    return;
  if (ido == 2)
    goto L105;
  t1 = 0;
  t2 = t0;
  for (k = 0; k < l1; k++) {
    t3 = t2;
    t4 = (t1 << 1) + (ido << 1);
    t5 = t1;
    t6 = t1 + t1;
    for (i = 2; i < ido; i += 2) {
      t3 += 2;
      t4 -= 2;
      t5 += 2;
      t6 += 2;
      tr2 = wa1[i - 2] * cc[t3 - 1] + wa1[i - 1] * cc[t3];
      ti2 = wa1[i - 2] * cc[t3] - wa1[i - 1] * cc[t3 - 1];
      ch[t6] = cc[t5] + ti2;
      ch[t4] = ti2 - cc[t5];
      ch[t6 - 1] = cc[t5 - 1] + tr2;
      ch[t4 - 1] = cc[t5 - 1] - tr2;
    }
    t1 += ido;
    t2 += ido;
  }
  if (ido % 2 == 1)
    return;
L105:
  t3 = (t2 = (t1 = ido) - 1);
  t2 += t0;
  for (k = 0; k < l1; k++) {
    ch[t1] = -cc[t2];
    ch[t1 - 1] = cc[t3];
    t1 += ido << 1;
    t2 += ido;
    t3 += ido;
  }
}


x86 assembly (clang, -O0):
<dradf2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x68(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    11da <dradf2+0xda>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
add    -0x68(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1145 <dradf2+0x45>
cmpq   $0x2,-0x8(%rbp)
jge    11ea <dradf2+0xea>
jmp    14f0 <dradf2+0x3f0>
cmpq   $0x2,-0x8(%rbp)
jne    11fa <dradf2+0xfa>
jmp    1432 <dradf2+0x332>
movq   $0x0,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1410 <dradf2+0x310>
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
movq   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    13e7 <dradf2+0x2e7>
mov    -0x68(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    $0x1,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    125b <dradf2+0x15b>
mov    -0x8(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1212 <dradf2+0x112>
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x1,%rdx
jne    142d <dradf2+0x32d>
jmp    14f0 <dradf2+0x3f0>
jmp    1432 <dradf2+0x332>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
sub    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    14f0 <dradf2+0x3f0>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    145a <dradf2+0x35a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradf2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r12
mov    %rdx,%r9
mov    %rsi,%r14
imul   %rdi,%r14
lea    (%rdi,%rdi,1),%r13
test   %rsi,%rsi
jle    119a <dradf2+0x9a>
cmp    $0x1,%rsi
jne    1475 <dradf2+0x375>
xor    %r10d,%r10d
mov    %r14,%rax
xor    %r15d,%r15d
lea    (%r9,%rax,8),%rax
lea    0x0(,%rdi,8),%r11
lea    (%r9,%r10,8),%rbp
lea    (%r10,%rdi,1),%rcx
shl    $0x4,%rcx
lea    (%rcx,%r12,1),%rbx
add    $0xfffffffffffffff8,%rbx
shl    $0x4,%r10
add    %r12,%r10
mov    %rsi,%rdx
sub    %r15,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,1),%xmm0
addsd  (%rax,%rcx,1),%xmm0
movsd  %xmm0,(%r10,%rcx,2)
movsd  0x0(%rbp,%rcx,1),%xmm0
subsd  (%rax,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rcx,2)
add    %r11,%rcx
add    $0xffffffffffffffff,%rdx
jne    1170 <dradf2+0x70>
cmp    $0x2,%rdi
jl     1788 <dradf2+0x688>
je     12b9 <dradf2+0x1b9>
mov    %r14,-0x28(%rsp)
mov    %r13,%r11
mov    %r12,%r10
test   %rsi,%rsi
jle    1290 <dradf2+0x190>
mov    %rdi,%r15
shl    $0x4,%r15
lea    0x0(,%rdi,8),%r12
lea    -0x2(%r11),%r14
mov    -0x28(%rsp),%rax
lea    (%r9,%rax,8),%rbx
xor    %r13d,%r13d
mov    %r9,%rdx
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x2,%ebp
mov    %r14,%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x10(%r8,%rbp,8),%xmm0
movsd  -0x8(%r8,%rbp,8),%xmm1
movsd  -0x8(%rbx,%rbp,8),%xmm2
movsd  (%rbx,%rbp,8),%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm1,%xmm4
mulsd  %xmm3,%xmm0
subsd  %xmm2,%xmm0
movsd  (%rdx,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbp,8)
subsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x8(%rdx,%rbp,8),%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,-0x8(%rax,%rbp,8)
movsd  -0x8(%rdx,%rbp,8),%xmm0
subsd  %xmm4,%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
add    $0x2,%rbp
add    $0xfffffffffffffffe,%rcx
cmp    %rdi,%rbp
jl     1200 <dradf2+0x100>
add    $0x1,%r13
add    %r15,%rax
add    %r12,%rdx
add    %r12,%rbx
cmp    %rsi,%r13
jne    11f0 <dradf2+0xf0>
mov    %rdi,%rax
shr    $0x3f,%rax
add    %rdi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rdi,%rcx
sub    %rax,%rcx
cmp    $0x1,%rcx
mov    %r10,%r12
mov    %r11,%r13
mov    -0x28(%rsp),%r14
je     1788 <dradf2+0x688>
test   %rsi,%rsi
jle    1788 <dradf2+0x688>
lea    -0x1(%rdi),%r15
add    %r15,%r14
xor    %r8d,%r8d
cmp    $0x1,%rsi
je     1601 <dradf2+0x501>
cmp    $0x1,%rdi
jne    1601 <dradf2+0x501>
mov    %r14,-0x28(%rsp)
mov    %r13,-0x20(%rsp)
mov    %rsi,%rax
shl    $0x4,%rax
lea    -0x8(%rax),%rcx
imul   %rdi,%rcx
lea    (%r12,%rcx,1),%rbp
add    $0xfffffffffffffff8,%rbp
mov    %r15,-0x10(%rsp)
lea    (%r12,%r15,8),%rdx
cmp    %rdx,%rbp
mov    %rdx,%r8
cmovb  %rbp,%r8
cmovbe %rdx,%rbp
add    $0x8,%rbp
add    %r9,%rax
add    %r12,%rcx
mov    %r12,-0x18(%rsp)
lea    (%r12,%rdi,8),%rbx
cmp    %rbx,%rcx
mov    %rbx,%r14
cmovb  %rcx,%r14
lea    (%r9,%rsi,8),%r12
cmovbe %rbx,%rcx
add    $0x8,%rcx
cmp    %r12,%r8
setb   %r13b
cmp    %r9,%rbp
seta   %r15b
cmp    %rax,%r8
setb   %bl
cmp    %r12,%rbp
seta   %r11b
cmp    %r12,%r14
setb   %r10b
cmp    %r9,%rcx
seta   %bpl
cmp    %rax,%r14
setb   %al
cmp    %r12,%rcx
seta   %cl
xor    %r8d,%r8d
test   %r15b,%r13b
jne    17af <dradf2+0x6af>
and    %r11b,%bl
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r13
mov    -0x28(%rsp),%r14
mov    -0x10(%rsp),%r15
jne    1601 <dradf2+0x501>
and    %bpl,%r10b
jne    1601 <dradf2+0x501>
and    %cl,%al
jne    1601 <dradf2+0x501>
mov    %rsi,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rax
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,-0x8(%rsp)
je     1730 <dradf2+0x630>
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rdi,2),%rcx
mov    %r12,%rbp
lea    (%r9,%rcx,8),%r12
add    $0xfffffffffffffff8,%r12
mov    %rdi,%r13
shl    $0x5,%r13
lea    0x3(%rsi),%rcx
imul   %rdi,%rcx
lea    (%r9,%rcx,8),%r10
add    $0xfffffffffffffff8,%r10
lea    (%rdi,%rdi,4),%rcx
lea    -0x8(%rbp,%rcx,8),%rbp
lea    (%r9,%r14,8),%r11
lea    (%r9,%r15,8),%rcx
xor    %r14d,%r14d
movaps 0xbe5(%rip),%xmm0
xor    %ebx,%ebx
nopl   (%rax)
movups (%r11,%r14,1),%xmm1
xorps  %xmm0,%xmm1
movups (%rcx,%r14,1),%xmm2
movaps %xmm2,%xmm3
movlhps %xmm1,%xmm3
movhlps %xmm2,%xmm1
movups %xmm1,0x10(%rdx,%r14,2)
movups %xmm3,(%rdx,%r14,2)
movups (%r10,%r14,1),%xmm1
xorps  %xmm0,%xmm1
movups (%r12,%r14,1),%xmm2
movaps %xmm2,%xmm3
movlhps %xmm1,%xmm3
movhlps %xmm2,%xmm1
movups %xmm1,0x10(%rbp,%r14,2)
movups %xmm3,0x0(%rbp,%r14,2)
add    $0x4,%rbx
add    %r13,%r14
add    $0xfffffffffffffffe,%rax
jne    1420 <dradf2+0x320>
jmp    1732 <dradf2+0x632>
lea    -0x1(%rsi),%rax
mov    $0x10,%ecx
mul    %rcx
seto   %cl
xor    %r10d,%r10d
cmp    $0x1,%rdi
jne    112d <dradf2+0x2d>
lea    (%r12,%rax,1),%rdx
cmp    %r12,%rdx
jb     112d <dradf2+0x2d>
test   %cl,%cl
jne    112d <dradf2+0x2d>
lea    0x8(%r12),%rdx
add    %r12,%rax
add    $0x8,%rax
cmp    %rdx,%rax
jb     112d <dradf2+0x2d>
mov    %r14,%rax
mov    $0x0,%r15d
test   %cl,%cl
jne    1133 <dradf2+0x33>
mov    %rsi,%rax
shl    $0x4,%rax
lea    (%r12,%rax,1),%rdx
lea    (%r9,%rsi,8),%rcx
add    %r9,%rax
cmp    %r12,%rax
seta   %al
cmp    %rdx,%rcx
setb   %bl
cmp    %r12,%rcx
seta   %cl
cmp    %r9,%rdx
seta   %dl
xor    %r10d,%r10d
test   %bl,%al
jne    112d <dradf2+0x2d>
mov    %r14,%rax
mov    $0x0,%r15d
and    %dl,%cl
jne    1133 <dradf2+0x33>
mov    %r13,-0x20(%rsp)
mov    %r12,-0x18(%rsp)
mov    %rsi,%r15
and    $0xfffffffffffffffe,%r15
lea    -0x2(%r15),%rax
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,-0x28(%rsp)
je     16be <dradf2+0x5be>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x2(%rsi),%rax
imul   %rdi,%rax
lea    (%r9,%rax,8),%r12
mov    %rdi,%r13
shl    $0x5,%r13
lea    (%rdi,%rdi,2),%rax
shl    $0x4,%rax
mov    -0x18(%rsp),%rcx
add    %rcx,%rax
add    $0xfffffffffffffff0,%rax
mov    -0x20(%rsp),%rbx
lea    (%r9,%rbx,8),%rbp
lea    (%rcx,%rbx,8),%r10
add    $0xfffffffffffffff0,%r10
mov    %r14,%rcx
lea    (%r9,%r14,8),%r14
xor    %r11d,%r11d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%r9,%r11,1),%xmm0
movupd (%r14,%r11,1),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movapd %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm2,%xmm0
movups %xmm0,0x10(%r10,%r11,2)
movupd %xmm1,(%r10,%r11,2)
movupd 0x0(%rbp,%r11,1),%xmm0
movupd (%r12,%r11,1),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movapd %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm2,%xmm0
movups %xmm0,0x10(%rax,%r11,2)
movupd %xmm1,(%rax,%r11,2)
add    $0x4,%rbx
add    %r13,%r11
add    $0xfffffffffffffffe,%rdx
jne    1590 <dradf2+0x490>
jmp    16c3 <dradf2+0x5c3>
mov    %rdi,%r10
mov    %r8,%rax
not    %rax
test   $0x1,%sil
je     163c <dradf2+0x53c>
movsd  (%r9,%r14,8),%xmm0
xorps  0x9e3(%rip),%xmm0
movlps %xmm0,(%r12,%r10,8)
movsd  (%r9,%r15,8),%xmm0
movsd  %xmm0,-0x8(%r12,%r10,8)
add    %r13,%r10
add    %rdi,%r14
add    %rdi,%r15
or     $0x1,%r8
add    %rsi,%rax
je     1788 <dradf2+0x688>
lea    (%r9,%r15,8),%r11
mov    %rdi,%rcx
shl    $0x4,%rcx
add    %rdi,%r15
mov    %r14,%rax
lea    (%r9,%r15,8),%r14
lea    (%r9,%rax,8),%rbx
add    %rdi,%rax
lea    (%r9,%rax,8),%rdi
lea    (%r12,%r10,8),%rdx
add    %r10,%r13
lea    (%r12,%r13,8),%rax
sub    %r8,%rsi
xor    %ebp,%ebp
movaps 0x984(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rbx,%rbp,1),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rdx,%rbp,2)
movsd  (%r11,%rbp,1),%xmm1
movsd  %xmm1,-0x8(%rdx,%rbp,2)
movsd  (%rdi,%rbp,1),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rax,%rbp,2)
movsd  (%r14,%rbp,1),%xmm1
movsd  %xmm1,-0x8(%rax,%rbp,2)
add    %rcx,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1680 <dradf2+0x580>
jmp    1788 <dradf2+0x688>
mov    %r14,%rcx
xor    %ebx,%ebx
testb  $0x1,-0x28(%rsp)
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r13
mov    %rcx,%r14
je     1717 <dradf2+0x617>
lea    -0x1(%r13),%rax
imul   %rdi,%rbx
lea    (%r14,%rbx,1),%rcx
movupd (%r9,%rbx,8),%xmm0
movupd (%r9,%rcx,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
lea    (%rax,%rbx,2),%rax
movapd %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm2,%xmm0
movups %xmm0,0x8(%r12,%rax,8)
movupd %xmm1,-0x8(%r12,%rax,8)
cmp    %rsi,%r15
je     119a <dradf2+0x9a>
mov    %r15,%r10
imul   %rdi,%r10
lea    (%r14,%r10,1),%rax
jmp    1133 <dradf2+0x33>
xor    %ebx,%ebx
testb  $0x1,-0x8(%rsp)
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r13
mov    -0x28(%rsp),%r14
je     1783 <dradf2+0x683>
mov    %rbx,%rax
imul   %rdi,%rax
lea    (%r15,%rax,1),%rcx
add    %r14,%rax
imul   %r13,%rbx
add    %rdi,%rbx
movups (%r9,%rax,8),%xmm0
xorps  0x897(%rip),%xmm0
movups (%r9,%rcx,8),%xmm1
movaps %xmm1,%xmm2
movlhps %xmm0,%xmm2
movhlps %xmm1,%xmm0
movups %xmm0,0x8(%r12,%rbx,8)
movups %xmm2,-0x8(%r12,%rbx,8)
cmp    %rsi,%r8
jne    1793 <dradf2+0x693>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rax
imul   %rdi,%rax
mov    %r8,%r10
imul   %r13,%r10
add    %rax,%r15
add    %rax,%r14
add    %rdi,%r10
jmp    1604 <dradf2+0x504>
mov    %rdi,%r10
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r13
mov    -0x28(%rsp),%r14
mov    -0x10(%rsp),%r15
jmp    1604 <dradf2+0x504>

LLVM IR (-O0):
define void @dradf2(i64 %0, i64 %1, double* %2, double* %3, double* %4) {
%6 = alloca i64
%7 = alloca i64
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i64
%12 = alloca i64
%13 = alloca double
%14 = alloca double
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
store i64 %0, i64* %6
store i64 %1, i64* %7
store double* %2, double** %8
store double* %3, double** %9
store double* %4, double** %10
store i64 0, i64* %16
%22 = load i64, i64* %7
%23 = load i64, i64* %6
%24 = mul nsw i64 %22, %23
store i64 %24, i64* %17
store i64 %24, i64* %15
%25 = load i64, i64* %6
%26 = shl i64 %25, 1
store i64 %26, i64* %18
store i64 0, i64* %12
br label %27
27: ; preds = %67, %5
%28 = load i64, i64* %12
%29 = load i64, i64* %7
%30 = icmp slt i64 %28, %29
br i1 %30, label %31, label %70
31: ; preds = %27
%32 = load double*, double** %8
%33 = load i64, i64* %16
%34 = getelementptr inbounds double, double* %32, i64 %33
%35 = load double, double* %34
%36 = load double*, double** %8
%37 = load i64, i64* %17
%38 = getelementptr inbounds double, double* %36, i64 %37
%39 = load double, double* %38
%40 = fadd double %35, %39
%41 = load double*, double** %9
%42 = load i64, i64* %16
%43 = shl i64 %42, 1
%44 = getelementptr inbounds double, double* %41, i64 %43
store double %40, double* %44
%45 = load double*, double** %8
%46 = load i64, i64* %16
%47 = getelementptr inbounds double, double* %45, i64 %46
%48 = load double, double* %47
%49 = load double*, double** %8
%50 = load i64, i64* %17
%51 = getelementptr inbounds double, double* %49, i64 %50
%52 = load double, double* %51
%53 = fsub double %48, %52
%54 = load double*, double** %9
%55 = load i64, i64* %16
%56 = shl i64 %55, 1
%57 = load i64, i64* %18
%58 = add nsw i64 %56, %57
%59 = sub nsw i64 %58, 1
%60 = getelementptr inbounds double, double* %54, i64 %59
store double %53, double* %60
%61 = load i64, i64* %6
%62 = load i64, i64* %16
%63 = add nsw i64 %62, %61
store i64 %63, i64* %16
%64 = load i64, i64* %6
%65 = load i64, i64* %17
%66 = add nsw i64 %65, %64
store i64 %66, i64* %17
br label %67
67: ; preds = %31
%68 = load i64, i64* %12
%69 = add nsw i64 %68, 1
store i64 %69, i64* %12
br label %27
70: ; preds = %27
%71 = load i64, i64* %6
%72 = icmp slt i64 %71, 2
br i1 %72, label %73, label %74
73: ; preds = %70
br label %250
74: ; preds = %70
%75 = load i64, i64* %6
%76 = icmp eq i64 %75, 2
br i1 %76, label %77, label %78
77: ; preds = %74
br label %210
78: ; preds = %74
store i64 0, i64* %16
%79 = load i64, i64* %15
store i64 %79, i64* %17
store i64 0, i64* %12
br label %80
80: ; preds = %201, %78
%81 = load i64, i64* %12
%82 = load i64, i64* %7
%83 = icmp slt i64 %81, %82
br i1 %83, label %84, label %204
84: ; preds = %80
%85 = load i64, i64* %17
store i64 %85, i64* %18
%86 = load i64, i64* %16
%87 = shl i64 %86, 1
%88 = load i64, i64* %6
%89 = shl i64 %88, 1
%90 = add nsw i64 %87, %89
store i64 %90, i64* %19
%91 = load i64, i64* %16
store i64 %91, i64* %20
%92 = load i64, i64* %16
%93 = load i64, i64* %16
%94 = add nsw i64 %92, %93
store i64 %94, i64* %21
store i64 2, i64* %11
br label %95
95: ; preds = %191, %84
%96 = load i64, i64* %11
%97 = load i64, i64* %6
%98 = icmp slt i64 %96, %97
br i1 %98, label %99, label %194
99: ; preds = %95
%100 = load i64, i64* %18
%101 = add nsw i64 %100, 2
store i64 %101, i64* %18
%102 = load i64, i64* %19
%103 = sub nsw i64 %102, 2
store i64 %103, i64* %19
%104 = load i64, i64* %20
%105 = add nsw i64 %104, 2
store i64 %105, i64* %20
%106 = load i64, i64* %21
%107 = add nsw i64 %106, 2
store i64 %107, i64* %21
%108 = load double*, double** %10
%109 = load i64, i64* %11
%110 = sub nsw i64 %109, 2
%111 = getelementptr inbounds double, double* %108, i64 %110
%112 = load double, double* %111
%113 = load double*, double** %8
%114 = load i64, i64* %18
%115 = sub nsw i64 %114, 1
%116 = getelementptr inbounds double, double* %113, i64 %115
%117 = load double, double* %116
%118 = load double*, double** %10
%119 = load i64, i64* %11
%120 = sub nsw i64 %119, 1
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = load double*, double** %8
%124 = load i64, i64* %18
%125 = getelementptr inbounds double, double* %123, i64 %124
%126 = load double, double* %125
%127 = fmul double %122, %126
%128 = call double @llvm.fmuladd.f64(double %112, double %117, double %127)
store double %128, double* %14
%129 = load double*, double** %10
%130 = load i64, i64* %11
%131 = sub nsw i64 %130, 2
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = load double*, double** %8
%135 = load i64, i64* %18
%136 = getelementptr inbounds double, double* %134, i64 %135
%137 = load double, double* %136
%138 = load double*, double** %10
%139 = load i64, i64* %11
%140 = sub nsw i64 %139, 1
%141 = getelementptr inbounds double, double* %138, i64 %140
%142 = load double, double* %141
%143 = load double*, double** %8
%144 = load i64, i64* %18
%145 = sub nsw i64 %144, 1
%146 = getelementptr inbounds double, double* %143, i64 %145
%147 = load double, double* %146
%148 = fmul double %142, %147
%149 = fneg double %148
%150 = call double @llvm.fmuladd.f64(double %133, double %137, double %149)
store double %150, double* %13
%151 = load double*, double** %8
%152 = load i64, i64* %20
%153 = getelementptr inbounds double, double* %151, i64 %152
%154 = load double, double* %153
%155 = load double, double* %13
%156 = fadd double %154, %155
%157 = load double*, double** %9
%158 = load i64, i64* %21
%159 = getelementptr inbounds double, double* %157, i64 %158
store double %156, double* %159
%160 = load double, double* %13
%161 = load double*, double** %8
%162 = load i64, i64* %20
%163 = getelementptr inbounds double, double* %161, i64 %162
%164 = load double, double* %163
%165 = fsub double %160, %164
%166 = load double*, double** %9
%167 = load i64, i64* %19
%168 = getelementptr inbounds double, double* %166, i64 %167
store double %165, double* %168
%169 = load double*, double** %8
%170 = load i64, i64* %20
%171 = sub nsw i64 %170, 1
%172 = getelementptr inbounds double, double* %169, i64 %171
%173 = load double, double* %172
%174 = load double, double* %14
%175 = fadd double %173, %174
%176 = load double*, double** %9
%177 = load i64, i64* %21
%178 = sub nsw i64 %177, 1
%179 = getelementptr inbounds double, double* %176, i64 %178
store double %175, double* %179
%180 = load double*, double** %8
%181 = load i64, i64* %20
%182 = sub nsw i64 %181, 1
%183 = getelementptr inbounds double, double* %180, i64 %182
%184 = load double, double* %183
%185 = load double, double* %14
%186 = fsub double %184, %185
%187 = load double*, double** %9
%188 = load i64, i64* %19
%189 = sub nsw i64 %188, 1
%190 = getelementptr inbounds double, double* %187, i64 %189
store double %186, double* %190
br label %191
191: ; preds = %99
%192 = load i64, i64* %11
%193 = add nsw i64 %192, 2
store i64 %193, i64* %11
br label %95
194: ; preds = %95
%195 = load i64, i64* %6
%196 = load i64, i64* %16
%197 = add nsw i64 %196, %195
store i64 %197, i64* %16
%198 = load i64, i64* %6
%199 = load i64, i64* %17
%200 = add nsw i64 %199, %198
store i64 %200, i64* %17
br label %201
201: ; preds = %194
%202 = load i64, i64* %12
%203 = add nsw i64 %202, 1
store i64 %203, i64* %12
br label %80
204: ; preds = %80
%205 = load i64, i64* %6
%206 = srem i64 %205, 2
%207 = icmp eq i64 %206, 1
br i1 %207, label %208, label %209
208: ; preds = %204
br label %250
209: ; preds = %204
br label %210
210: ; preds = %209, %77
%211 = load i64, i64* %6
store i64 %211, i64* %16
%212 = sub nsw i64 %211, 1
store i64 %212, i64* %17
store i64 %212, i64* %18
%213 = load i64, i64* %15
%214 = load i64, i64* %17
%215 = add nsw i64 %214, %213
store i64 %215, i64* %17
store i64 0, i64* %12
br label %216
216: ; preds = %247, %210
%217 = load i64, i64* %12
%218 = load i64, i64* %7
%219 = icmp slt i64 %217, %218
br i1 %219, label %220, label %250
220: ; preds = %216
%221 = load double*, double** %8
%222 = load i64, i64* %17
%223 = getelementptr inbounds double, double* %221, i64 %222
%224 = load double, double* %223
%225 = fneg double %224
%226 = load double*, double** %9
%227 = load i64, i64* %16
%228 = getelementptr inbounds double, double* %226, i64 %227
store double %225, double* %228
%229 = load double*, double** %8
%230 = load i64, i64* %18
%231 = getelementptr inbounds double, double* %229, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %9
%234 = load i64, i64* %16
%235 = sub nsw i64 %234, 1
%236 = getelementptr inbounds double, double* %233, i64 %235
store double %232, double* %236
%237 = load i64, i64* %6
%238 = shl i64 %237, 1
%239 = load i64, i64* %16
%240 = add nsw i64 %239, %238
store i64 %240, i64* %16
%241 = load i64, i64* %6
%242 = load i64, i64* %17
%243 = add nsw i64 %242, %241
store i64 %243, i64* %17
%244 = load i64, i64* %6
%245 = load i64, i64* %18
%246 = add nsw i64 %245, %244
store i64 %246, i64* %18
br label %247
247: ; preds = %220
%248 = load i64, i64* %12
%249 = add nsw i64 %248, 1
store i64 %249, i64* %12
br label %216
250: ; preds = %73, %208, %216
ret void
}

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