void dradf4(long ido, long l1, const double *cc, double *ch, const double *wa1,
            const double *wa2, const double *wa3) {
  static double hsqt2 = .70710678118654752440084436210485;
  long i, k, t0, t1, t2, t3, t4, t5, t6;
  double ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
  t0 = l1 * ido;
  t1 = t0;
  t4 = t1 << 1;
  t2 = t1 + (t1 << 1);
  t3 = 0;
  for (k = 0; k < l1; k++) {
    tr1 = cc[t1] + cc[t2];
    tr2 = cc[t3] + cc[t4];
    ch[t5 = t3 << 2] = tr1 + tr2;
    ch[(ido << 2) + t5 - 1] = tr2 - tr1;
    ch[(t5 += (ido << 1)) - 1] = cc[t3] - cc[t4];
    ch[t5] = cc[t2] - cc[t1];
    t1 += ido;
    t2 += ido;
    t3 += ido;
    t4 += ido;
  }
  if (ido < 2)
    return;
  if (ido == 2)
    goto L105;
  t1 = 0;
  for (k = 0; k < l1; k++) {
    t2 = t1;
    t4 = t1 << 2;
    t5 = (t6 = ido << 1) + t4;
    for (i = 2; i < ido; i += 2) {
      t3 = (t2 += 2);
      t4 += 2;
      t5 -= 2;
      t3 += t0;
      cr2 = wa1[i - 2] * cc[t3 - 1] + wa1[i - 1] * cc[t3];
      ci2 = wa1[i - 2] * cc[t3] - wa1[i - 1] * cc[t3 - 1];
      t3 += t0;
      cr3 = wa2[i - 2] * cc[t3 - 1] + wa2[i - 1] * cc[t3];
      ci3 = wa2[i - 2] * cc[t3] - wa2[i - 1] * cc[t3 - 1];
      t3 += t0;
      cr4 = wa3[i - 2] * cc[t3 - 1] + wa3[i - 1] * cc[t3];
      ci4 = wa3[i - 2] * cc[t3] - wa3[i - 1] * cc[t3 - 1];
      tr1 = cr2 + cr4;
      tr4 = cr4 - cr2;
      ti1 = ci2 + ci4;
      ti4 = ci2 - ci4;
      ti2 = cc[t2] + ci3;
      ti3 = cc[t2] - ci3;
      tr2 = cc[t2 - 1] + cr3;
      tr3 = cc[t2 - 1] - cr3;
      ch[t4 - 1] = tr1 + tr2;
      ch[t4] = ti1 + ti2;
      ch[t5 - 1] = tr3 - ti4;
      ch[t5] = tr4 - ti3;
      ch[t4 + t6 - 1] = ti4 + tr3;
      ch[t4 + t6] = tr4 + ti3;
      ch[t5 + t6 - 1] = tr2 - tr1;
      ch[t5 + t6] = ti1 - ti2;
    }
    t1 += ido;
  }
  if (ido % 2 == 1)
    return;
L105:
  t2 = (t1 = t0 + ido - 1) + (t0 << 1);
  t3 = ido << 2;
  t4 = ido;
  t5 = ido << 1;
  t6 = ido;
  for (k = 0; k < l1; k++) {
    ti1 = -hsqt2 * (cc[t1] + cc[t2]);
    tr1 = hsqt2 * (cc[t1] - cc[t2]);
    ch[t4 - 1] = tr1 + cc[t6 - 1];
    ch[t4 + t5 - 1] = cc[t6 - 1] - tr1;
    ch[t4] = ti1 - cc[t1 + t0];
    ch[t4 + t5] = ti1 + cc[t1 + t0];
    t1 += ido;
    t2 += ido;
    t4 += t3;
    t6 += ido;
  }
}


x86 assembly (clang, -O0):
<dradf4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x68,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12a7 <dradf4+0x1a7>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
shl    $0x2,%rcx
mov    %rcx,-0x70(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x2,%rcx
add    -0x70(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x1,%rcx
add    -0x70(%rbp),%rcx
mov    %rcx,-0x70(%rbp)
sub    $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    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
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    -0x8(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1168 <dradf4+0x68>
cmpq   $0x2,-0x8(%rbp)
jge    12b7 <dradf4+0x1b7>
jmp    1978 <dradf4+0x878>
cmpq   $0x2,-0x8(%rbp)
jne    12c7 <dradf4+0x1c7>
jmp    17bf <dradf4+0x6bf>
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    179d <dradf4+0x69d>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x78(%rbp)
add    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1780 <dradf4+0x680>
mov    -0x58(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x58(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%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,-0x80(%rbp)
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%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,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%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,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0xc0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0x78(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
add    -0x78(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
add    -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    1315 <dradf4+0x215>
mov    -0x8(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12d7 <dradf4+0x1d7>
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
cmp    $0x1,%rdx
jne    17ba <dradf4+0x6ba>
jmp    1978 <dradf4+0x878>
jmp    17bf <dradf4+0x6bf>
mov    -0x48(%rbp),%rax
add    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1978 <dradf4+0x878>
movsd  0x27fc(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x27b7(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x68(%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  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0x70(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    180e <dradf4+0x70e>
add    $0x68,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradf4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r10
mov    %rsi,%r11
mov    %rdi,-0x28(%rsp)
imul   %rdi,%r11
lea    (%r11,%r11,1),%rax
mov    %rax,-0x38(%rsp)
mov    %rsi,-0x30(%rsp)
test   %rsi,%rsi
jle    1221 <dradf4+0x121>
lea    (%r11,%r11,2),%rbp
mov    -0x28(%rsp),%rsi
lea    (%rsi,%rsi,1),%r13
mov    -0x30(%rsp),%rbx
cmp    $0x1,%rbx
jne    150a <dradf4+0x40a>
xor    %r15d,%r15d
mov    %r11,%rdx
xor    %r14d,%r14d
mov    -0x38(%rsp),%rax
mov    %rax,-0x18(%rsp)
mov    -0x30(%rsp),%rax
sub    %r15,%rax
lea    (%r10,%rdx,8),%r12
mov    -0x28(%rsp),%r15
lea    0x0(,%r15,8),%rdi
lea    (%r10,%rbp,8),%rdx
lea    (%r10,%r14,8),%rbp
lea    0x0(,%r14,4),%rsi
add    %r13,%rsi
lea    (%rcx,%rsi,8),%rbx
mov    %r14,%r13
shl    $0x5,%r13
add    %rcx,%r13
add    %r15,%r14
shl    $0x5,%r14
add    %rcx,%r14
add    $0xfffffffffffffff8,%r14
mov    -0x18(%rsp),%rsi
lea    (%r10,%rsi,8),%rsi
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%r15,1),%xmm0
addsd  (%rdx,%r15,1),%xmm0
movsd  0x0(%rbp,%r15,1),%xmm1
addsd  (%rsi,%r15,1),%xmm1
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%r13,%r15,4)
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%r15,4)
movsd  0x0(%rbp,%r15,1),%xmm0
subsd  (%rsi,%r15,1),%xmm0
movsd  %xmm0,-0x8(%rbx,%r15,4)
movsd  (%rdx,%r15,1),%xmm0
subsd  (%r12,%r15,1),%xmm0
movsd  %xmm0,(%rbx,%r15,4)
add    %rdi,%r15
add    $0xffffffffffffffff,%rax
jne    11c0 <dradf4+0xc0>
mov    -0x28(%rsp),%rdi
cmp    $0x2,%rdi
mov    -0x30(%rsp),%rbx
jl     14ff <dradf4+0x3ff>
je     1427 <dradf4+0x327>
test   %rbx,%rbx
jle    1404 <dradf4+0x304>
mov    0x38(%rsp),%r13
lea    (%rdi,%rdi,1),%rdx
xor    %esi,%esi
movapd 0xda8(%rip),%xmm8
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r14,4),%rax
lea    (%rdx,%r14,4),%rbp
mov    $0x2,%ebx
mov    %r14,%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r12,%r11,1),%rdi
add    $0x2,%rdi
movsd  -0x10(%r8,%rbx,8),%xmm3
movsd  -0x8(%r8,%rbx,8),%xmm4
movapd %xmm4,%xmm6
xorpd  %xmm8,%xmm6
movsd  -0x8(%r10,%rdi,8),%xmm1
movsd  (%r10,%rdi,8),%xmm5
lea    (%rdi,%r11,1),%r15
movsd  -0x10(%r9,%rbx,8),%xmm9
movsd  -0x8(%r9,%rbx,8),%xmm0
movapd %xmm0,%xmm7
unpcklpd %xmm1,%xmm7
movsd  -0x8(%r10,%r15,8),%xmm2
movsd  (%r10,%r15,8),%xmm10
unpcklpd %xmm10,%xmm1
unpcklpd %xmm6,%xmm10
mulpd  %xmm7,%xmm10
movapd %xmm9,%xmm6
unpcklpd %xmm3,%xmm6
unpcklpd %xmm2,%xmm4
unpcklpd %xmm5,%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm10,%xmm2
xorpd  %xmm8,%xmm0
unpcklpd %xmm0,%xmm5
mulpd  %xmm4,%xmm5
unpcklpd %xmm9,%xmm3
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
add    %r11,%r15
movsd  -0x10(%r13,%rbx,8),%xmm3
movsd  -0x8(%r13,%rbx,8),%xmm0
movsd  -0x8(%r10,%r15,8),%xmm4
movsd  (%r10,%r15,8),%xmm5
movapd %xmm3,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm0,%xmm4
mulsd  %xmm5,%xmm0
addsd  %xmm0,%xmm6
mulsd  %xmm5,%xmm3
subsd  %xmm4,%xmm3
movsd  0x8(%r10,%r12,8),%xmm4
movsd  0x10(%r10,%r12,8),%xmm0
movapd %xmm4,%xmm5
unpcklpd %xmm6,%xmm4
unpcklpd %xmm0,%xmm6
addpd  %xmm1,%xmm6
movapd %xmm2,%xmm7
shufpd $0x1,%xmm0,%xmm7
unpcklpd %xmm3,%xmm5
addpd  %xmm2,%xmm5
unpcklpd %xmm1,%xmm2
movsd  %xmm3,%xmm1
subpd  %xmm1,%xmm7
subpd  %xmm2,%xmm4
lea    0x0(,%rax,8),%rdi
or     $0x8,%rdi
movapd %xmm5,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,(%rcx,%rdi,1)
movapd %xmm4,%xmm0
subpd  %xmm7,%xmm0
movupd %xmm0,-0x18(%rcx,%rbp,8)
lea    0x2(%rax,%rdx,1),%rdi
addpd  %xmm7,%xmm4
movupd %xmm4,-0x8(%rcx,%rdi,8)
lea    -0x2(%rbp,%rdx,1),%rdi
subpd  %xmm6,%xmm5
movupd %xmm5,-0x8(%rcx,%rdi,8)
mov    -0x28(%rsp),%rdi
add    $0x2,%r12
add    $0x2,%rax
add    $0xfffffffffffffffe,%rbp
add    $0x2,%rbx
cmp    %rdi,%rbx
jl     1280 <dradf4+0x180>
add    %rdi,%r14
add    $0x1,%rsi
cmp    -0x30(%rsp),%rsi
jne    1260 <dradf4+0x160>
mov    %rdi,%rax
shr    $0x3f,%rax
add    %rdi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rdi,%rdx
sub    %rax,%rdx
cmp    $0x1,%rdx
mov    -0x30(%rsp),%rbx
je     14ff <dradf4+0x3ff>
test   %rbx,%rbx
jle    14ff <dradf4+0x3ff>
lea    (%rdi,%r11,1),%r13
add    $0xffffffffffffffff,%r13
mov    -0x38(%rsp),%rbp
add    %r13,%rbp
cmp    $0x1,%rbx
jne    1718 <dradf4+0x618>
xor    %edx,%edx
mov    %rdi,%r12
mov    %rdi,%r15
lea    (%rdi,%rdi,1),%rax
sub    %rdx,%rbx
lea    (%r10,%r13,8),%r8
shl    $0x3,%rdi
add    %r13,%r11
lea    (%r10,%r11,8),%rdx
lea    (%r10,%rbp,8),%r9
add    %r12,%rax
lea    (%rcx,%rax,8),%rsi
lea    (%rcx,%r12,8),%rcx
lea    (%r10,%r15,8),%rax
add    $0xfffffffffffffff8,%rax
xor    %ebp,%ebp
movsd  0xba7(%rip),%xmm0
movsd  0xba7(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rbp,1),%xmm2
movsd  (%r9,%rbp,1),%xmm3
movapd %xmm2,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rax,%rbp,1),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rcx,%rbp,4)
movsd  (%rax,%rbp,1),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rsi,%rbp,4)
movapd %xmm4,%xmm2
subsd  (%rdx,%rbp,1),%xmm2
movsd  %xmm2,(%rcx,%rbp,4)
addsd  (%rdx,%rbp,1),%xmm4
movsd  %xmm4,(%rsi,%rbp,4)
add    %rdi,%rbp
add    $0xffffffffffffffff,%rbx
jne    14a0 <dradf4+0x3a0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rbx),%rax
mov    $0x20,%edx
mul    %rdx
seto   %dl
xor    %r15d,%r15d
cmp    $0x1,%rsi
jne    114f <dradf4+0x4f>
lea    0x8(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x8,%rdi
cmp    %rsi,%rdi
jb     114f <dradf4+0x4f>
test   %dl,%dl
jne    114f <dradf4+0x4f>
lea    0x10(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x10,%rdi
cmp    %rsi,%rdi
jb     114f <dradf4+0x4f>
test   %dl,%dl
jne    114f <dradf4+0x4f>
lea    0x18(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x18,%rdi
cmp    %rsi,%rdi
jb     114f <dradf4+0x4f>
test   %dl,%dl
jne    114f <dradf4+0x4f>
add    %rcx,%rax
cmp    %rcx,%rax
jb     114f <dradf4+0x4f>
test   %dl,%dl
jne    114f <dradf4+0x4f>
mov    %rbp,-0x20(%rsp)
mov    %rbx,%rdx
shl    $0x5,%rdx
lea    (%rcx,%rdx,1),%rbp
mov    %rbx,%rsi
shl    $0x4,%rsi
add    %r10,%rsi
lea    (%rbx,%rbx,2),%rax
lea    (%r10,%rax,8),%rdi
lea    (%r10,%rbx,8),%rbx
add    %r10,%rdx
cmp    %rcx,%rdi
seta   %r15b
cmp    %rbp,%rsi
setb   %r12b
cmp    %rcx,%rbx
seta   %al
cmp    %r10,%rbp
seta   %r14b
cmp    %rcx,%rdx
seta   %dl
cmp    %rbp,%rdi
setb   %dil
cmp    %rcx,%rsi
seta   %sil
cmp    %rbp,%rbx
setb   %bpl
test   %r12b,%r15b
jne    1932 <dradf4+0x832>
and    %r14b,%al
mov    $0x0,%r15d
jne    190b <dradf4+0x80b>
and    %dil,%dl
jne    190b <dradf4+0x80b>
and    %bpl,%sil
jne    190b <dradf4+0x80b>
mov    -0x30(%rsp),%rdi
and    $0xfffffffffffffffe,%rdi
mov    %rdi,%r14
mov    -0x28(%rsp),%r12
imul   %r12,%r14
lea    (%r11,%r14,1),%rax
mov    %rax,-0x10(%rsp)
add    %r14,-0x20(%rsp)
mov    -0x38(%rsp),%rax
add    %r14,%rax
mov    %rax,-0x18(%rsp)
mov    %r11,%rax
shl    $0x4,%rax
mov    %r12,%rbx
shl    $0x4,%rbx
mov    %r13,-0x8(%rsp)
lea    (%rcx,%r13,8),%r15
add    $0xfffffffffffffff0,%r15
shl    $0x6,%r12
lea    0x0(,%r11,8),%rdx
lea    (%rdx,%rdx,2),%rbp
mov    %r10,%rdx
mov    %rdi,%rsi
mov    %rdi,%r13
xchg   %ax,%ax
movupd (%rdx,%r11,8),%xmm0
movupd (%rdx,%rbp,1),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%rdx),%xmm3
movupd (%rdx,%rax,1),%xmm4
movapd %xmm3,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm2,%xmm6
addpd  %xmm5,%xmm6
subpd  %xmm2,%xmm5
subpd  %xmm4,%xmm3
subpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpcklpd %xmm5,%xmm0
unpckhpd %xmm5,%xmm1
movapd %xmm6,%xmm2
unpcklpd %xmm3,%xmm2
movhlps %xmm6,%xmm3
movupd %xmm1,0x30(%r15)
movups %xmm3,0x20(%r15)
movupd %xmm0,0x10(%r15)
movupd %xmm2,(%r15)
add    %rbx,%rdx
add    %r12,%r15
add    $0xfffffffffffffffe,%r13
jne    1680 <dradf4+0x580>
mov    %rsi,%r15
cmp    -0x30(%rsp),%rsi
mov    -0x8(%rsp),%r13
mov    -0x20(%rsp),%rbp
mov    -0x10(%rsp),%rdx
mov    -0x18(%rsp),%rax
jne    115a <dradf4+0x5a>
jmp    1221 <dradf4+0x121>
lea    -0x1(%rbx),%rax
mov    $0x20,%edx
mul    %rdx
seto   %r8b
xor    %edx,%edx
cmp    $0x1,%rdi
jne    144c <dradf4+0x34c>
lea    0x18(%rcx),%rsi
add    %rcx,%rax
add    $0x18,%rax
cmp    %rsi,%rax
jb     144c <dradf4+0x34c>
test   %r8b,%r8b
jne    144c <dradf4+0x34c>
mov    %rbp,-0x38(%rsp)
mov    %rbx,%rdx
shl    $0x5,%rdx
lea    (%rcx,%rdx,1),%rbp
mov    %rbx,%rsi
shl    $0x4,%rsi
add    %r10,%rsi
lea    (%rbx,%rbx,2),%rax
lea    (%r10,%rax,8),%rdi
lea    (%r10,%rbx,8),%rbx
add    %r10,%rdx
cmp    %rcx,%rdi
seta   %r14b
cmp    %rbp,%rsi
setb   %r15b
cmp    %rcx,%rbx
seta   %al
cmp    %r10,%rbp
seta   %r9b
cmp    %rcx,%rdx
seta   %dl
cmp    %rbp,%rdi
setb   %dil
cmp    %rcx,%rsi
seta   %r12b
cmp    %rbp,%rbx
setb   %r8b
test   %r15b,%r14b
jne    194a <dradf4+0x84a>
and    %r9b,%al
jne    194a <dradf4+0x84a>
and    %dil,%dl
mov    -0x30(%rsp),%rbx
mov    -0x38(%rsp),%rbp
jne    1920 <dradf4+0x820>
and    %r8b,%r12b
jne    1920 <dradf4+0x820>
mov    -0x28(%rsp),%rdi
lea    0x0(,%rdi,4),%r12
mov    %rbx,%r14
and    $0xfffffffffffffffe,%r14
mov    %r14,%r15
imul   %rdi,%r15
lea    (%r15,%r13,1),%rax
mov    %rax,-0x18(%rsp)
lea    (%r15,%rbp,1),%rax
mov    %rax,-0x20(%rsp)
imul   %r14,%r12
add    %rdi,%r12
add    %rdi,%r15
lea    (%r10,%rdi,8),%r8
add    $0xfffffffffffffff8,%r8
mov    %rdi,%rdx
shl    $0x4,%rdx
lea    (%rdi,%rdi,2),%rax
lea    (%rcx,%rax,8),%rsi
add    $0xffffffffffffffe8,%rsi
lea    (%r10,%rbp,8),%r9
lea    (%r10,%r13,8),%r13
lea    (%rbx,%rbx,1),%rax
add    $0x1,%rax
imul   %rdi,%rax
lea    (%r10,%rax,8),%rbp
add    $0xfffffffffffffff8,%rbp
xor    %eax,%eax
movapd 0x7ba(%rip),%xmm0
movapd 0x7c2(%rip),%xmm1
mov    %r14,-0x38(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%r13,%rax,1),%xmm2
movupd (%r9,%rax,1),%xmm3
movapd %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm4
subpd  %xmm3,%xmm2
mulpd  %xmm1,%xmm2
movupd (%r8,%rax,1),%xmm3
movapd %xmm3,%xmm5
addpd  %xmm2,%xmm5
subpd  %xmm2,%xmm3
movupd 0x0(%rbp,%rax,1),%xmm2
movapd %xmm4,%xmm6
subpd  %xmm2,%xmm6
addpd  %xmm2,%xmm4
movapd %xmm5,%xmm2
unpcklpd %xmm6,%xmm2
movapd %xmm3,%xmm7
unpcklpd %xmm4,%xmm7
movhlps %xmm5,%xmm6
movhlps %xmm3,%xmm4
movups %xmm4,0x30(%rsi,%rax,4)
movups %xmm6,0x20(%rsi,%rax,4)
movupd %xmm7,0x10(%rsi,%rax,4)
movupd %xmm2,(%rsi,%rax,4)
add    %rdx,%rax
add    $0xfffffffffffffffe,%r14
jne    1870 <dradf4+0x770>
mov    -0x30(%rsp),%rbx
mov    -0x38(%rsp),%rdx
cmp    %rbx,%rdx
mov    -0x18(%rsp),%r13
mov    -0x20(%rsp),%rbp
jne    1452 <dradf4+0x352>
jmp    14ff <dradf4+0x3ff>
mov    %r11,%rdx
xor    %r14d,%r14d
mov    -0x38(%rsp),%rax
mov    -0x20(%rsp),%rbp
jmp    115a <dradf4+0x5a>
mov    -0x28(%rsp),%rdi
mov    %rdi,%r12
mov    %rdi,%r15
xor    %edx,%edx
jmp    1452 <dradf4+0x352>
mov    %r11,%rdx
xor    %r14d,%r14d
mov    -0x38(%rsp),%rax
mov    -0x20(%rsp),%rbp
xor    %r15d,%r15d
jmp    115a <dradf4+0x5a>
mov    -0x38(%rsp),%rbp
mov    -0x28(%rsp),%rdi
mov    %rdi,%r12
mov    %rdi,%r15
mov    -0x30(%rsp),%rbx
xor    %edx,%edx
jmp    1452 <dradf4+0x352>

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

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