#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int k;
typedef int ic;
typedef int i;

/* Variables and functions */
void radf4(size_t ido, size_t l1, const double *cc, double *ch,
           const double *wa) {
  const size_t cdim = 4;
  static const double hsqt2 = 0.70710678118654752440;
  size_t i, k, ic;
  double ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
  for (k = 0; k < l1; k++) {
    {
      tr1 = cc[(0) + ido * ((k) + l1 * (3))] + cc[(0) + ido * ((k) + l1 * (1))];
      ch[(0) + ido * ((2) + cdim * (k))] =
          cc[(0) + ido * ((k) + l1 * (3))] - cc[(0) + ido * ((k) + l1 * (1))];
    }
    {
      tr2 = cc[(0) + ido * ((k) + l1 * (0))] + cc[(0) + ido * ((k) + l1 * (2))];
      ch[(ido - 1) + ido * ((1) + cdim * (k))] =
          cc[(0) + ido * ((k) + l1 * (0))] - cc[(0) + ido * ((k) + l1 * (2))];
    }
    {
      ch[(0) + ido * ((0) + cdim * (k))] = tr2 + tr1;
      ch[(ido - 1) + ido * ((3) + cdim * (k))] = tr2 - tr1;
    }
  }
  if ((ido & 1) == 0)
    for (k = 0; k < l1; k++) {
      ti1 = -hsqt2 * (cc[(ido - 1) + ido * ((k) + l1 * (1))] +
                      cc[(ido - 1) + ido * ((k) + l1 * (3))]);
      tr1 = hsqt2 * (cc[(ido - 1) + ido * ((k) + l1 * (1))] -
                     cc[(ido - 1) + ido * ((k) + l1 * (3))]);
      {
        ch[(ido - 1) + ido * ((0) + cdim * (k))] =
            cc[(ido - 1) + ido * ((k) + l1 * (0))] + tr1;
        ch[(ido - 1) + ido * ((2) + cdim * (k))] =
            cc[(ido - 1) + ido * ((k) + l1 * (0))] - tr1;
      }
      {
        ch[(0) + ido * ((3) + cdim * (k))] =
            ti1 + cc[(ido - 1) + ido * ((k) + l1 * (2))];
        ch[(0) + ido * ((1) + cdim * (k))] =
            ti1 - cc[(ido - 1) + ido * ((k) + l1 * (2))];
      }
    }
  if (ido <= 2)
    return;
  for (k = 0; k < l1; k++)
    for (i = 2; i < ido; i += 2) {
      ic = ido - i;
      {
        cr2 = wa[(i - 2) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))] +
              wa[(i - 1) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))];
        ci2 = wa[(i - 2) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))] -
              wa[(i - 1) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))];
      }
      {
        cr3 = wa[(i - 2) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))] +
              wa[(i - 1) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))];
        ci3 = wa[(i - 2) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))] -
              wa[(i - 1) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))];
      }
      {
        cr4 = wa[(i - 2) + (2) * ido] * cc[(i - 1) + ido * ((k) + l1 * (3))] +
              wa[(i - 1) + (2) * ido] * cc[(i) + ido * ((k) + l1 * (3))];
        ci4 = wa[(i - 2) + (2) * ido] * cc[(i) + ido * ((k) + l1 * (3))] -
              wa[(i - 1) + (2) * ido] * cc[(i - 1) + ido * ((k) + l1 * (3))];
      }
      {
        tr1 = cr4 + cr2;
        tr4 = cr4 - cr2;
      }
      {
        ti1 = ci2 + ci4;
        ti4 = ci2 - ci4;
      }
      {
        tr2 = cc[(i - 1) + ido * ((k) + l1 * (0))] + cr3;
        tr3 = cc[(i - 1) + ido * ((k) + l1 * (0))] - cr3;
      }
      {
        ti2 = cc[(i) + ido * ((k) + l1 * (0))] + ci3;
        ti3 = cc[(i) + ido * ((k) + l1 * (0))] - ci3;
      }
      {
        ch[(i - 1) + ido * ((0) + cdim * (k))] = tr2 + tr1;
        ch[(ic - 1) + ido * ((3) + cdim * (k))] = tr2 - tr1;
      }
      {
        ch[(i) + ido * ((0) + cdim * (k))] = ti1 + ti2;
        ch[(ic) + ido * ((3) + cdim * (k))] = ti1 - ti2;
      }
      {
        ch[(i - 1) + ido * ((2) + cdim * (k))] = tr3 + ti4;
        ch[(ic - 1) + ido * ((1) + cdim * (k))] = tr3 - ti4;
      }
      {
        ch[(i) + ido * ((2) + cdim * (k))] = tr4 + ti3;
        ch[(ic) + ido * ((1) + cdim * (k))] = tr4 - ti3;
      }
    }
}


x86 assembly (clang, -O0):
<radf4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x4,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1321 <radf4+0x221>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x3,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x0,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x3,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x0,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x2,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x0,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x0,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112c <radf4+0x2c>
mov    -0x8(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    157c <radf4+0x47c>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1577 <radf4+0x477>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xc64(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xbf8(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x3,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x1,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    133b <radf4+0x23b>
jmp    157c <radf4+0x47c>
cmpq   $0x2,-0x8(%rbp)
ja     158c <radf4+0x48c>
jmp    1c5d <radf4+0xb5d>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1c5d <radf4+0xb5d>
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1c47 <radf4+0xb47>
mov    -0x8(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%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,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%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,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%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,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x50(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    15aa <radf4+0x4aa>
jmp    1c4c <radf4+0xb4c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1594 <radf4+0x494>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radf4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x18(%rsp)
mov    %rdx,%r9
test   %rsi,%rsi
mov    %rdi,-0x40(%rsp)
je     12d7 <radf4+0x1d7>
lea    (%rsi,%rsi,2),%r12
lea    (%rsi,%rsi,1),%r8
mov    %rsi,%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%r15
lea    (%rdx,%rdx,2),%rax
shl    $0x4,%rdx
add    %r9,%rdx
lea    0x0(,%rdi,8),%r10
mov    %rdi,%r11
lea    (%r9,%rax,8),%r14
mov    %rdi,%rax
shl    $0x5,%rax
lea    (%rax,%rcx,1),%rdi
add    $0xfffffffffffffff8,%rdi
shl    $0x4,%r11
lea    (%rcx,%r11,1),%rbp
xor    %ebx,%ebx
mov    %rsi,%rax
nopl   0x0(%rax)
movsd  (%r14,%rbx,1),%xmm0
movsd  (%r15,%rbx,1),%xmm1
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,4)
movsd  (%r9,%rbx,1),%xmm0
movsd  (%rdx,%rbx,1),%xmm1
movapd %xmm0,%xmm3
addsd  %xmm1,%xmm3
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp,%rbx,4)
movapd %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rbx,4)
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rdi,%rbx,4)
add    %r10,%rbx
add    $0xffffffffffffffff,%rax
jne    1170 <radf4+0x70>
mov    $0x1,%r14b
mov    -0x40(%rsp),%rdi
test   $0x1,%dil
jne    12da <radf4+0x1da>
cmp    $0x2,%rsi
jae    1573 <radf4+0x473>
xor    %r15d,%r15d
mov    %rsi,%rax
sub    %r15,%rax
lea    (%r15,%r8,1),%rdx
add    $0x1,%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%r11
add    $0xfffffffffffffff8,%r11
lea    0x1(%r15),%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%r8
add    $0xfffffffffffffff8,%r8
lea    (%r15,%r12,1),%rdx
add    $0x1,%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%r12
add    $0xfffffffffffffff8,%r12
lea    (%r15,%rsi,1),%rdx
add    $0x1,%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%r13
add    $0xfffffffffffffff8,%r13
lea    0x1(,%r15,4),%rdx
imul   %rdi,%rdx
lea    (%rcx,%rdx,8),%rbp
lea    0x3(,%r15,4),%rdx
imul   %rdi,%rdx
lea    (%rcx,%rdx,8),%rbx
xor    %edx,%edx
movsd  0xdbb(%rip),%xmm0
movsd  0xdbb(%rip),%xmm1
nopl   (%rax)
movsd  0x0(%r13,%rdx,1),%xmm2
movsd  (%r12,%rdx,1),%xmm3
movapd %xmm2,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movsd  (%r8,%rdx,1),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rbp,%rdx,4)
movsd  (%r8,%rdx,1),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rbx,%rdx,4)
movsd  (%r11,%rdx,1),%xmm2
addsd  %xmm4,%xmm2
movsd  %xmm2,(%rbx,%rdx,4)
subsd  (%r11,%rdx,1),%xmm4
movsd  %xmm4,0x0(%rbp,%rdx,4)
add    %r10,%rdx
add    $0xffffffffffffffff,%rax
jne    1270 <radf4+0x170>
jmp    12da <radf4+0x1da>
xor    %r14d,%r14d
cmp    $0x3,%rdi
jb     1568 <radf4+0x468>
test   %r14b,%r14b
je     1568 <radf4+0x468>
lea    (%rsi,%rsi,1),%rax
mov    %rax,-0x28(%rsp)
lea    (%rdi,%rdi,1),%rbx
lea    (%rsi,%rsi,2),%rax
mov    %rax,-0x30(%rsp)
xor    %edx,%edx
mov    %rsi,-0x20(%rsp)
mov    -0x18(%rsp),%r8
nop
lea    (%rdx,%rsi,1),%rax
imul   %rdi,%rax
mov    %rax,-0x48(%rsp)
mov    -0x28(%rsp),%rax
add    %rdx,%rax
imul   %rdi,%rax
mov    %rax,-0x38(%rsp)
mov    -0x30(%rsp),%rax
add    %rdx,%rax
imul   %rdi,%rax
mov    %rax,-0x8(%rsp)
mov    %rdx,%r13
imul   %rdi,%r13
lea    0x0(,%rdx,4),%r15
imul   %rdi,%r15
lea    0x3(,%rdx,4),%rbp
imul   %rdi,%rbp
lea    0x2(,%rdx,4),%r10
imul   %rdi,%r10
mov    %rdx,-0x10(%rsp)
lea    0x1(,%rdx,4),%rsi
imul   %rdi,%rsi
mov    $0x2,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdi,%r12
sub    %r11,%r12
mov    -0x48(%rsp),%rdx
lea    (%r11,%rdx,1),%r14
add    $0xffffffffffffffff,%r14
movsd  (%r9,%r14,8),%xmm1
mov    -0x40(%rsp),%rdi
movsd  -0x10(%r8,%r11,8),%xmm9
movsd  -0x8(%r8,%r11,8),%xmm2
lea    (%r11,%rdx,1),%rdx
movsd  (%r9,%rdx,8),%xmm4
movapd %xmm9,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm1
mulsd  %xmm4,%xmm2
addsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm9
subsd  %xmm1,%xmm9
lea    -0x2(%r11,%rdi,1),%rdx
movsd  (%r8,%rdx,8),%xmm0
mov    -0x38(%rsp),%rax
lea    -0x1(%r11,%rax,1),%rdx
movsd  (%r9,%rdx,8),%xmm1
lea    -0x1(%r11,%rdi,1),%rdx
movsd  (%r8,%rdx,8),%xmm5
lea    (%r11,%rax,1),%rdx
movsd  (%r9,%rdx,8),%xmm6
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm5,%xmm1
mulsd  %xmm6,%xmm5
addsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm0
subsd  %xmm1,%xmm0
lea    -0x2(%r11,%rbx,1),%rdx
movsd  (%r8,%rdx,8),%xmm5
mov    -0x8(%rsp),%rax
lea    -0x1(%r11,%rax,1),%rdx
movsd  (%r9,%rdx,8),%xmm6
lea    -0x1(%r11,%rbx,1),%rdx
movsd  (%r8,%rdx,8),%xmm7
lea    (%r11,%rax,1),%rdx
movsd  (%r9,%rdx,8),%xmm8
movapd %xmm5,%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm6
mulsd  %xmm8,%xmm7
addsd  %xmm7,%xmm1
mulsd  %xmm8,%xmm5
subsd  %xmm6,%xmm5
movapd %xmm3,%xmm6
addsd  %xmm1,%xmm6
subsd  %xmm3,%xmm1
movapd %xmm9,%xmm7
addsd  %xmm5,%xmm7
subsd  %xmm5,%xmm9
lea    -0x1(%r11,%r13,1),%rdx
movsd  (%r9,%rdx,8),%xmm5
movapd %xmm2,%xmm4
addsd  %xmm5,%xmm4
subsd  %xmm2,%xmm5
lea    (%r11,%r13,1),%rdx
movsd  (%r9,%rdx,8),%xmm3
movapd %xmm0,%xmm2
addsd  %xmm3,%xmm2
subsd  %xmm0,%xmm3
movapd %xmm4,%xmm0
addsd  %xmm6,%xmm0
lea    -0x1(%r11,%r15,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
subsd  %xmm6,%xmm4
lea    -0x1(%r12,%rbp,1),%rdx
movsd  %xmm4,(%rcx,%rdx,8)
movapd %xmm7,%xmm0
addsd  %xmm2,%xmm0
lea    (%r11,%r15,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
subsd  %xmm2,%xmm7
lea    (%r12,%rbp,1),%rdx
movsd  %xmm7,(%rcx,%rdx,8)
movapd %xmm5,%xmm0
addsd  %xmm9,%xmm0
lea    -0x1(%r11,%r10,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
subsd  %xmm9,%xmm5
lea    -0x1(%r12,%rsi,1),%rdx
movsd  %xmm5,(%rcx,%rdx,8)
movapd %xmm1,%xmm0
addsd  %xmm3,%xmm0
lea    (%r11,%r10,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
subsd  %xmm3,%xmm1
add    %rsi,%r12
movsd  %xmm1,(%rcx,%r12,8)
add    $0x2,%r11
cmp    %rdi,%r11
jb     1390 <radf4+0x290>
mov    -0x10(%rsp),%rdx
add    $0x1,%rdx
mov    -0x20(%rsp),%rsi
cmp    %rsi,%rdx
jne    1310 <radf4+0x210>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rsi),%rax
mov    $0x20,%edx
mul    %rdx
seto   %dl
xor    %r15d,%r15d
cmp    $0x1,%rdi
jne    11e9 <radf4+0xe9>
lea    0x18(%rcx),%rbx
lea    (%rcx,%rax,1),%rbp
add    $0x18,%rbp
cmp    %rbx,%rbp
jb     11e9 <radf4+0xe9>
test   %dl,%dl
jne    11e9 <radf4+0xe9>
lea    0x8(%rcx),%rbx
lea    (%rcx,%rax,1),%rbp
add    $0x8,%rbp
cmp    %rbx,%rbp
jb     11e9 <radf4+0xe9>
test   %dl,%dl
jne    11e9 <radf4+0xe9>
lea    0x10(%rcx),%rbx
lea    (%rcx,%rax,1),%rbp
add    $0x10,%rbp
cmp    %rbx,%rbp
jb     11e9 <radf4+0xe9>
test   %dl,%dl
jne    11e9 <radf4+0xe9>
add    %rcx,%rax
cmp    %rcx,%rax
jb     11e9 <radf4+0xe9>
test   %dl,%dl
jne    11e9 <radf4+0xe9>
mov    %rsi,%rdx
shl    $0x5,%rdx
lea    (%rcx,%rdx,1),%rbp
lea    (%r9,%r8,8),%rbx
mov    %r12,-0x48(%rsp)
lea    (%r9,%r12,8),%rdi
lea    (%r9,%rsi,8),%rax
add    %r9,%rdx
cmp    %rcx,%rdi
seta   -0x38(%rsp)
cmp    %rbp,%rbx
setb   %r12b
cmp    %rcx,%rax
seta   %r14b
cmp    %r9,%rbp
seta   %r13b
cmp    %rcx,%rdx
seta   %dl
cmp    %rbp,%rdi
setb   %dil
cmp    %rcx,%rbx
seta   %bl
cmp    %rbp,%rax
setb   %bpl
xor    %r15d,%r15d
test   %r12b,-0x38(%rsp)
jne    1785 <radf4+0x685>
and    %r13b,%r14b
jne    1785 <radf4+0x685>
and    %dil,%dl
mov    -0x40(%rsp),%rdi
mov    $0x1,%r14b
mov    -0x48(%rsp),%r12
jne    11e9 <radf4+0xe9>
and    %bpl,%bl
jne    11e9 <radf4+0xe9>
lea    -0x1(%rdi),%rbx
mov    %rsi,%r15
and    $0xfffffffffffffffe,%r15
lea    0x1(%rsi),%rax
imul   %rdi,%rax
mov    %r8,%rdx
lea    (%r9,%rax,8),%r8
add    $0xfffffffffffffff8,%r8
lea    0x1(%r12),%rax
imul   %rdi,%rax
lea    (%r9,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
lea    (%r9,%rbx,8),%rbp
lea    (%rcx,%rbx,8),%rbx
mov    %rdx,-0x38(%rsp)
add    $0x1,%rdx
imul   %rdi,%rdx
lea    (%r9,%rdx,8),%rdx
add    $0xfffffffffffffff8,%rdx
xor    %r12d,%r12d
movapd 0x923(%rip),%xmm0
movapd 0x92b(%rip),%xmm1
mov    %r15,%r13
nopl   0x0(%rax,%rax,1)
movupd (%r8,%r12,1),%xmm2
movupd (%rax,%r12,1),%xmm3
movapd %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm4
subpd  %xmm3,%xmm2
mulpd  %xmm1,%xmm2
movupd 0x0(%rbp,%r12,1),%xmm3
movapd %xmm3,%xmm5
addpd  %xmm2,%xmm5
subpd  %xmm2,%xmm3
movupd (%rdx,%r12,1),%xmm2
movapd %xmm4,%xmm6
addpd  %xmm2,%xmm6
subpd  %xmm2,%xmm4
movapd %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movapd %xmm3,%xmm7
unpcklpd %xmm6,%xmm7
movhlps %xmm5,%xmm4
movhlps %xmm3,%xmm6
movups %xmm6,0x30(%rbx,%r12,4)
movups %xmm4,0x20(%rbx,%r12,4)
movupd %xmm7,0x10(%rbx,%r12,4)
movupd %xmm2,(%rbx,%r12,4)
add    %r11,%r12
add    $0xfffffffffffffffe,%r13
jne    16f0 <radf4+0x5f0>
cmp    %rsi,%r15
mov    -0x48(%rsp),%r12
mov    -0x38(%rsp),%r8
jne    11e9 <radf4+0xe9>
jmp    12da <radf4+0x1da>
mov    -0x40(%rsp),%rdi
mov    $0x1,%r14b
mov    -0x48(%rsp),%r12
jmp    11e9 <radf4+0xe9>

LLVM IR (-O0):
@radf4.hsqt2 = internal constant double 0x3FE6A09E667F3BCD
define void @radf4(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 i64
%14 = alloca i64
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
store 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 4, i64* %11
store i64 0, i64* %13
br label %29
29: ; preds = %160, %5
%30 = load i64, i64* %13
%31 = load i64, i64* %7
%32 = icmp ult i64 %30, %31
br i1 %32, label %33, label %163
33: ; preds = %29
%34 = load double*, double** %8
%35 = load i64, i64* %6
%36 = load i64, i64* %13
%37 = load i64, i64* %7
%38 = mul i64 %37, 3
%39 = add i64 %36, %38
%40 = mul i64 %35, %39
%41 = add i64 0, %40
%42 = getelementptr inbounds double, double* %34, i64 %41
%43 = load double, double* %42
%44 = load double*, double** %8
%45 = load i64, i64* %6
%46 = load i64, i64* %13
%47 = load i64, i64* %7
%48 = mul i64 %47, 1
%49 = add i64 %46, %48
%50 = mul i64 %45, %49
%51 = add i64 0, %50
%52 = getelementptr inbounds double, double* %44, i64 %51
%53 = load double, double* %52
%54 = fadd double %43, %53
store double %54, double* %25
%55 = load double*, double** %8
%56 = load i64, i64* %6
%57 = load i64, i64* %13
%58 = load i64, i64* %7
%59 = mul i64 %58, 3
%60 = add i64 %57, %59
%61 = mul i64 %56, %60
%62 = add i64 0, %61
%63 = getelementptr inbounds double, double* %55, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %8
%66 = load i64, i64* %6
%67 = load i64, i64* %13
%68 = load i64, i64* %7
%69 = mul i64 %68, 1
%70 = add i64 %67, %69
%71 = mul i64 %66, %70
%72 = add i64 0, %71
%73 = getelementptr inbounds double, double* %65, i64 %72
%74 = load double, double* %73
%75 = fsub double %64, %74
%76 = load double*, double** %9
%77 = load i64, i64* %6
%78 = load i64, i64* %13
%79 = mul i64 4, %78
%80 = add i64 2, %79
%81 = mul i64 %77, %80
%82 = add i64 0, %81
%83 = getelementptr inbounds double, double* %76, i64 %82
store double %75, double* %83
%84 = load double*, double** %8
%85 = load i64, i64* %6
%86 = load i64, i64* %13
%87 = load i64, i64* %7
%88 = mul i64 %87, 0
%89 = add i64 %86, %88
%90 = mul i64 %85, %89
%91 = add i64 0, %90
%92 = getelementptr inbounds double, double* %84, i64 %91
%93 = load double, double* %92
%94 = load double*, double** %8
%95 = load i64, i64* %6
%96 = load i64, i64* %13
%97 = load i64, i64* %7
%98 = mul i64 %97, 2
%99 = add i64 %96, %98
%100 = mul i64 %95, %99
%101 = add i64 0, %100
%102 = getelementptr inbounds double, double* %94, i64 %101
%103 = load double, double* %102
%104 = fadd double %93, %103
store double %104, double* %26
%105 = load double*, double** %8
%106 = load i64, i64* %6
%107 = load i64, i64* %13
%108 = load i64, i64* %7
%109 = mul i64 %108, 0
%110 = add i64 %107, %109
%111 = mul i64 %106, %110
%112 = add i64 0, %111
%113 = getelementptr inbounds double, double* %105, i64 %112
%114 = load double, double* %113
%115 = load double*, double** %8
%116 = load i64, i64* %6
%117 = load i64, i64* %13
%118 = load i64, i64* %7
%119 = mul i64 %118, 2
%120 = add i64 %117, %119
%121 = mul i64 %116, %120
%122 = add i64 0, %121
%123 = getelementptr inbounds double, double* %115, i64 %122
%124 = load double, double* %123
%125 = fsub double %114, %124
%126 = load double*, double** %9
%127 = load i64, i64* %6
%128 = sub i64 %127, 1
%129 = load i64, i64* %6
%130 = load i64, i64* %13
%131 = mul i64 4, %130
%132 = add i64 1, %131
%133 = mul i64 %129, %132
%134 = add i64 %128, %133
%135 = getelementptr inbounds double, double* %126, i64 %134
store double %125, double* %135
%136 = load double, double* %26
%137 = load double, double* %25
%138 = fadd double %136, %137
%139 = load double*, double** %9
%140 = load i64, i64* %6
%141 = load i64, i64* %13
%142 = mul i64 4, %141
%143 = add i64 0, %142
%144 = mul i64 %140, %143
%145 = add i64 0, %144
%146 = getelementptr inbounds double, double* %139, i64 %145
store double %138, double* %146
%147 = load double, double* %26
%148 = load double, double* %25
%149 = fsub double %147, %148
%150 = load double*, double** %9
%151 = load i64, i64* %6
%152 = sub i64 %151, 1
%153 = load i64, i64* %6
%154 = load i64, i64* %13
%155 = mul i64 4, %154
%156 = add i64 3, %155
%157 = mul i64 %153, %156
%158 = add i64 %152, %157
%159 = getelementptr inbounds double, double* %150, i64 %158
store double %149, double* %159
br label %160
160: ; preds = %33
%161 = load i64, i64* %13
%162 = add i64 %161, 1
store i64 %162, i64* %13
br label %29
163: ; preds = %29
%164 = load i64, i64* %6
%165 = and i64 %164, 1
%166 = icmp eq i64 %165, 0
br i1 %166, label %167, label %321
167: ; preds = %163
store i64 0, i64* %13
br label %168
168: ; preds = %317, %167
%169 = load i64, i64* %13
%170 = load i64, i64* %7
%171 = icmp ult i64 %169, %170
br i1 %171, label %172, label %320
172: ; preds = %168
%173 = load double*, double** %8
%174 = load i64, i64* %6
%175 = sub i64 %174, 1
%176 = load i64, i64* %6
%177 = load i64, i64* %13
%178 = load i64, i64* %7
%179 = mul i64 %178, 1
%180 = add i64 %177, %179
%181 = mul i64 %176, %180
%182 = add i64 %175, %181
%183 = getelementptr inbounds double, double* %173, i64 %182
%184 = load double, double* %183
%185 = load double*, double** %8
%186 = load i64, i64* %6
%187 = sub i64 %186, 1
%188 = load i64, i64* %6
%189 = load i64, i64* %13
%190 = load i64, i64* %7
%191 = mul i64 %190, 3
%192 = add i64 %189, %191
%193 = mul i64 %188, %192
%194 = add i64 %187, %193
%195 = getelementptr inbounds double, double* %185, i64 %194
%196 = load double, double* %195
%197 = fadd double %184, %196
%198 = fmul double 0xBFE6A09E667F3BCD, %197
store double %198, double* %21
%199 = load double*, double** %8
%200 = load i64, i64* %6
%201 = sub i64 %200, 1
%202 = load i64, i64* %6
%203 = load i64, i64* %13
%204 = load i64, i64* %7
%205 = mul i64 %204, 1
%206 = add i64 %203, %205
%207 = mul i64 %202, %206
%208 = add i64 %201, %207
%209 = getelementptr inbounds double, double* %199, i64 %208
%210 = load double, double* %209
%211 = load double*, double** %8
%212 = load i64, i64* %6
%213 = sub i64 %212, 1
%214 = load i64, i64* %6
%215 = load i64, i64* %13
%216 = load i64, i64* %7
%217 = mul i64 %216, 3
%218 = add i64 %215, %217
%219 = mul i64 %214, %218
%220 = add i64 %213, %219
%221 = getelementptr inbounds double, double* %211, i64 %220
%222 = load double, double* %221
%223 = fsub double %210, %222
%224 = fmul double 0x3FE6A09E667F3BCD, %223
store double %224, double* %25
%225 = load double*, double** %8
%226 = load i64, i64* %6
%227 = sub i64 %226, 1
%228 = load i64, i64* %6
%229 = load i64, i64* %13
%230 = load i64, i64* %7
%231 = mul i64 %230, 0
%232 = add i64 %229, %231
%233 = mul i64 %228, %232
%234 = add i64 %227, %233
%235 = getelementptr inbounds double, double* %225, i64 %234
%236 = load double, double* %235
%237 = load double, double* %25
%238 = fadd double %236, %237
%239 = load double*, double** %9
%240 = load i64, i64* %6
%241 = sub i64 %240, 1
%242 = load i64, i64* %6
%243 = load i64, i64* %13
%244 = mul i64 4, %243
%245 = add i64 0, %244
%246 = mul i64 %242, %245
%247 = add i64 %241, %246
%248 = getelementptr inbounds double, double* %239, i64 %247
store double %238, double* %248
%249 = load double*, double** %8
%250 = load i64, i64* %6
%251 = sub i64 %250, 1
%252 = load i64, i64* %6
%253 = load i64, i64* %13
%254 = load i64, i64* %7
%255 = mul i64 %254, 0
%256 = add i64 %253, %255
%257 = mul i64 %252, %256
%258 = add i64 %251, %257
%259 = getelementptr inbounds double, double* %249, i64 %258
%260 = load double, double* %259
%261 = load double, double* %25
%262 = fsub double %260, %261
%263 = load double*, double** %9
%264 = load i64, i64* %6
%265 = sub i64 %264, 1
%266 = load i64, i64* %6
%267 = load i64, i64* %13
%268 = mul i64 4, %267
%269 = add i64 2, %268
%270 = mul i64 %266, %269
%271 = add i64 %265, %270
%272 = getelementptr inbounds double, double* %263, i64 %271
store double %262, double* %272
%273 = load double, double* %21
%274 = load double*, double** %8
%275 = load i64, i64* %6
%276 = sub i64 %275, 1
%277 = load i64, i64* %6
%278 = load i64, i64* %13
%279 = load i64, i64* %7
%280 = mul i64 %279, 2
%281 = add i64 %278, %280
%282 = mul i64 %277, %281
%283 = add i64 %276, %282
%284 = getelementptr inbounds double, double* %274, i64 %283
%285 = load double, double* %284
%286 = fadd double %273, %285
%287 = load double*, double** %9
%288 = load i64, i64* %6
%289 = load i64, i64* %13
%290 = mul i64 4, %289
%291 = add i64 3, %290
%292 = mul i64 %288, %291
%293 = add i64 0, %292
%294 = getelementptr inbounds double, double* %287, i64 %293
store double %286, double* %294
%295 = load double, double* %21
%296 = load double*, double** %8
%297 = load i64, i64* %6
%298 = sub i64 %297, 1
%299 = load i64, i64* %6
%300 = load i64, i64* %13
%301 = load i64, i64* %7
%302 = mul i64 %301, 2
%303 = add i64 %300, %302
%304 = mul i64 %299, %303
%305 = add i64 %298, %304
%306 = getelementptr inbounds double, double* %296, i64 %305
%307 = load double, double* %306
%308 = fsub double %295, %307
%309 = load double*, double** %9
%310 = load i64, i64* %6
%311 = load i64, i64* %13
%312 = mul i64 4, %311
%313 = add i64 1, %312
%314 = mul i64 %310, %313
%315 = add i64 0, %314
%316 = getelementptr inbounds double, double* %309, i64 %315
store double %308, double* %316
br label %317
317: ; preds = %172
%318 = load i64, i64* %13
%319 = add i64 %318, 1
store i64 %319, i64* %13
br label %168
320: ; preds = %168
br label %321
321: ; preds = %320, %163
%322 = load i64, i64* %6
%323 = icmp ule i64 %322, 2
br i1 %323, label %324, label %325
324: ; preds = %321
br label %761
325: ; preds = %321
store i64 0, i64* %13
br label %326
326: ; preds = %758, %325
%327 = load i64, i64* %13
%328 = load i64, i64* %7
%329 = icmp ult i64 %327, %328
br i1 %329, label %330, label %761
330: ; preds = %326
store i64 2, i64* %12
br label %331
331: ; preds = %754, %330
%332 = load i64, i64* %12
%333 = load i64, i64* %6
%334 = icmp ult i64 %332, %333
br i1 %334, label %335, label %757
335: ; preds = %331
%336 = load i64, i64* %6
%337 = load i64, i64* %12
%338 = sub i64 %336, %337
store i64 %338, i64* %14
%339 = load double*, double** %10
%340 = load i64, i64* %12
%341 = sub i64 %340, 2
%342 = load i64, i64* %6
%343 = mul i64 0, %342
%344 = add i64 %341, %343
%345 = getelementptr inbounds double, double* %339, i64 %344
%346 = load double, double* %345
%347 = load double*, double** %8
%348 = load i64, i64* %12
%349 = sub i64 %348, 1
%350 = load i64, i64* %6
%351 = load i64, i64* %13
%352 = load i64, i64* %7
%353 = mul i64 %352, 1
%354 = add i64 %351, %353
%355 = mul i64 %350, %354
%356 = add i64 %349, %355
%357 = getelementptr inbounds double, double* %347, i64 %356
%358 = load double, double* %357
%359 = load double*, double** %10
%360 = load i64, i64* %12
%361 = sub i64 %360, 1
%362 = load i64, i64* %6
%363 = mul i64 0, %362
%364 = add i64 %361, %363
%365 = getelementptr inbounds double, double* %359, i64 %364
%366 = load double, double* %365
%367 = load double*, double** %8
%368 = load i64, i64* %12
%369 = load i64, i64* %6
%370 = load i64, i64* %13
%371 = load i64, i64* %7
%372 = mul i64 %371, 1
%373 = add i64 %370, %372
%374 = mul i64 %369, %373
%375 = add i64 %368, %374
%376 = getelementptr inbounds double, double* %367, i64 %375
%377 = load double, double* %376
%378 = fmul double %366, %377
%379 = call double @llvm.fmuladd.f64(double %346, double %358, double %378)
store double %379, double* %18
%380 = load double*, double** %10
%381 = load i64, i64* %12
%382 = sub i64 %381, 2
%383 = load i64, i64* %6
%384 = mul i64 0, %383
%385 = add i64 %382, %384
%386 = getelementptr inbounds double, double* %380, i64 %385
%387 = load double, double* %386
%388 = load double*, double** %8
%389 = load i64, i64* %12
%390 = load i64, i64* %6
%391 = load i64, i64* %13
%392 = load i64, i64* %7
%393 = mul i64 %392, 1
%394 = add i64 %391, %393
%395 = mul i64 %390, %394
%396 = add i64 %389, %395
%397 = getelementptr inbounds double, double* %388, i64 %396
%398 = load double, double* %397
%399 = load double*, double** %10
%400 = load i64, i64* %12
%401 = sub i64 %400, 1
%402 = load i64, i64* %6
%403 = mul i64 0, %402
%404 = add i64 %401, %403
%405 = getelementptr inbounds double, double* %399, i64 %404
%406 = load double, double* %405
%407 = load double*, double** %8
%408 = load i64, i64* %12
%409 = sub i64 %408, 1
%410 = load i64, i64* %6
%411 = load i64, i64* %13
%412 = load i64, i64* %7
%413 = mul i64 %412, 1
%414 = add i64 %411, %413
%415 = mul i64 %410, %414
%416 = add i64 %409, %415
%417 = getelementptr inbounds double, double* %407, i64 %416
%418 = load double, double* %417
%419 = fmul double %406, %418
%420 = fneg double %419
%421 = call double @llvm.fmuladd.f64(double %387, double %398, double %420)
store double %421, double* %15
%422 = load double*, double** %10
%423 = load i64, i64* %12
%424 = sub i64 %423, 2
%425 = load i64, i64* %6
%426 = mul i64 1, %425
%427 = add i64 %424, %426
%428 = getelementptr inbounds double, double* %422, i64 %427
%429 = load double, double* %428
%430 = load double*, double** %8
%431 = load i64, i64* %12
%432 = sub i64 %431, 1
%433 = load i64, i64* %6
%434 = load i64, i64* %13
%435 = load i64, i64* %7
%436 = mul i64 %435, 2
%437 = add i64 %434, %436
%438 = mul i64 %433, %437
%439 = add i64 %432, %438
%440 = getelementptr inbounds double, double* %430, i64 %439
%441 = load double, double* %440
%442 = load double*, double** %10
%443 = load i64, i64* %12
%444 = sub i64 %443, 1
%445 = load i64, i64* %6
%446 = mul i64 1, %445
%447 = add i64 %444, %446
%448 = getelementptr inbounds double, double* %442, i64 %447
%449 = load double, double* %448
%450 = load double*, double** %8
%451 = load i64, i64* %12
%452 = load i64, i64* %6
%453 = load i64, i64* %13
%454 = load i64, i64* %7
%455 = mul i64 %454, 2
%456 = add i64 %453, %455
%457 = mul i64 %452, %456
%458 = add i64 %451, %457
%459 = getelementptr inbounds double, double* %450, i64 %458
%460 = load double, double* %459
%461 = fmul double %449, %460
%462 = call double @llvm.fmuladd.f64(double %429, double %441, double %461)
store double %462, double* %19
%463 = load double*, double** %10
%464 = load i64, i64* %12
%465 = sub i64 %464, 2
%466 = load i64, i64* %6
%467 = mul i64 1, %466
%468 = add i64 %465, %467
%469 = getelementptr inbounds double, double* %463, i64 %468
%470 = load double, double* %469
%471 = load double*, double** %8
%472 = load i64, i64* %12
%473 = load i64, i64* %6
%474 = load i64, i64* %13
%475 = load i64, i64* %7
%476 = mul i64 %475, 2
%477 = add i64 %474, %476
%478 = mul i64 %473, %477
%479 = add i64 %472, %478
%480 = getelementptr inbounds double, double* %471, i64 %479
%481 = load double, double* %480
%482 = load double*, double** %10
%483 = load i64, i64* %12
%484 = sub i64 %483, 1
%485 = load i64, i64* %6
%486 = mul i64 1, %485
%487 = add i64 %484, %486
%488 = getelementptr inbounds double, double* %482, i64 %487
%489 = load double, double* %488
%490 = load double*, double** %8
%491 = load i64, i64* %12
%492 = sub i64 %491, 1
%493 = load i64, i64* %6
%494 = load i64, i64* %13
%495 = load i64, i64* %7
%496 = mul i64 %495, 2
%497 = add i64 %494, %496
%498 = mul i64 %493, %497
%499 = add i64 %492, %498
%500 = getelementptr inbounds double, double* %490, i64 %499
%501 = load double, double* %500
%502 = fmul double %489, %501
%503 = fneg double %502
%504 = call double @llvm.fmuladd.f64(double %470, double %481, double %503)
store double %504, double* %16
%505 = load double*, double** %10
%506 = load i64, i64* %12
%507 = sub i64 %506, 2
%508 = load i64, i64* %6
%509 = mul i64 2, %508
%510 = add i64 %507, %509
%511 = getelementptr inbounds double, double* %505, i64 %510
%512 = load double, double* %511
%513 = load double*, double** %8
%514 = load i64, i64* %12
%515 = sub i64 %514, 1
%516 = load i64, i64* %6
%517 = load i64, i64* %13
%518 = load i64, i64* %7
%519 = mul i64 %518, 3
%520 = add i64 %517, %519
%521 = mul i64 %516, %520
%522 = add i64 %515, %521
%523 = getelementptr inbounds double, double* %513, i64 %522
%524 = load double, double* %523
%525 = load double*, double** %10
%526 = load i64, i64* %12
%527 = sub i64 %526, 1
%528 = load i64, i64* %6
%529 = mul i64 2, %528
%530 = add i64 %527, %529
%531 = getelementptr inbounds double, double* %525, i64 %530
%532 = load double, double* %531
%533 = load double*, double** %8
%534 = load i64, i64* %12
%535 = load i64, i64* %6
%536 = load i64, i64* %13
%537 = load i64, i64* %7
%538 = mul i64 %537, 3
%539 = add i64 %536, %538
%540 = mul i64 %535, %539
%541 = add i64 %534, %540
%542 = getelementptr inbounds double, double* %533, i64 %541
%543 = load double, double* %542
%544 = fmul double %532, %543
%545 = call double @llvm.fmuladd.f64(double %512, double %524, double %544)
store double %545, double* %20
%546 = load double*, double** %10
%547 = load i64, i64* %12
%548 = sub i64 %547, 2
%549 = load i64, i64* %6
%550 = mul i64 2, %549
%551 = add i64 %548, %550
%552 = getelementptr inbounds double, double* %546, i64 %551
%553 = load double, double* %552
%554 = load double*, double** %8
%555 = load i64, i64* %12
%556 = load i64, i64* %6
%557 = load i64, i64* %13
%558 = load i64, i64* %7
%559 = mul i64 %558, 3
%560 = add i64 %557, %559
%561 = mul i64 %556, %560
%562 = add i64 %555, %561
%563 = getelementptr inbounds double, double* %554, i64 %562
%564 = load double, double* %563
%565 = load double*, double** %10
%566 = load i64, i64* %12
%567 = sub i64 %566, 1
%568 = load i64, i64* %6
%569 = mul i64 2, %568
%570 = add i64 %567, %569
%571 = getelementptr inbounds double, double* %565, i64 %570
%572 = load double, double* %571
%573 = load double*, double** %8
%574 = load i64, i64* %12
%575 = sub i64 %574, 1
%576 = load i64, i64* %6
%577 = load i64, i64* %13
%578 = load i64, i64* %7
%579 = mul i64 %578, 3
%580 = add i64 %577, %579
%581 = mul i64 %576, %580
%582 = add i64 %575, %581
%583 = getelementptr inbounds double, double* %573, i64 %582
%584 = load double, double* %583
%585 = fmul double %572, %584
%586 = fneg double %585
%587 = call double @llvm.fmuladd.f64(double %553, double %564, double %586)
store double %587, double* %17
%588 = load double, double* %20
%589 = load double, double* %18
%590 = fadd double %588, %589
store double %590, double* %25
%591 = load double, double* %20
%592 = load double, double* %18
%593 = fsub double %591, %592
store double %593, double* %28
%594 = load double, double* %15
%595 = load double, double* %17
%596 = fadd double %594, %595
store double %596, double* %21
%597 = load double, double* %15
%598 = load double, double* %17
%599 = fsub double %597, %598
store double %599, double* %24
%600 = load double*, double** %8
%601 = load i64, i64* %12
%602 = sub i64 %601, 1
%603 = load i64, i64* %6
%604 = load i64, i64* %13
%605 = load i64, i64* %7
%606 = mul i64 %605, 0
%607 = add i64 %604, %606
%608 = mul i64 %603, %607
%609 = add i64 %602, %608
%610 = getelementptr inbounds double, double* %600, i64 %609
%611 = load double, double* %610
%612 = load double, double* %19
%613 = fadd double %611, %612
store double %613, double* %26
%614 = load double*, double** %8
%615 = load i64, i64* %12
%616 = sub i64 %615, 1
%617 = load i64, i64* %6
%618 = load i64, i64* %13
%619 = load i64, i64* %7
%620 = mul i64 %619, 0
%621 = add i64 %618, %620
%622 = mul i64 %617, %621
%623 = add i64 %616, %622
%624 = getelementptr inbounds double, double* %614, i64 %623
%625 = load double, double* %624
%626 = load double, double* %19
%627 = fsub double %625, %626
store double %627, double* %27
%628 = load double*, double** %8
%629 = load i64, i64* %12
%630 = load i64, i64* %6
%631 = load i64, i64* %13
%632 = load i64, i64* %7
%633 = mul i64 %632, 0
%634 = add i64 %631, %633
%635 = mul i64 %630, %634
%636 = add i64 %629, %635
%637 = getelementptr inbounds double, double* %628, i64 %636
%638 = load double, double* %637
%639 = load double, double* %16
%640 = fadd double %638, %639
store double %640, double* %22
%641 = load double*, double** %8
%642 = load i64, i64* %12
%643 = load i64, i64* %6
%644 = load i64, i64* %13
%645 = load i64, i64* %7
%646 = mul i64 %645, 0
%647 = add i64 %644, %646
%648 = mul i64 %643, %647
%649 = add i64 %642, %648
%650 = getelementptr inbounds double, double* %641, i64 %649
%651 = load double, double* %650
%652 = load double, double* %16
%653 = fsub double %651, %652
store double %653, double* %23
%654 = load double, double* %26
%655 = load double, double* %25
%656 = fadd double %654, %655
%657 = load double*, double** %9
%658 = load i64, i64* %12
%659 = sub i64 %658, 1
%660 = load i64, i64* %6
%661 = load i64, i64* %13
%662 = mul i64 4, %661
%663 = add i64 0, %662
%664 = mul i64 %660, %663
%665 = add i64 %659, %664
%666 = getelementptr inbounds double, double* %657, i64 %665
store double %656, double* %666
%667 = load double, double* %26
%668 = load double, double* %25
%669 = fsub double %667, %668
%670 = load double*, double** %9
%671 = load i64, i64* %14
%672 = sub i64 %671, 1
%673 = load i64, i64* %6
%674 = load i64, i64* %13
%675 = mul i64 4, %674
%676 = add i64 3, %675
%677 = mul i64 %673, %676
%678 = add i64 %672, %677
%679 = getelementptr inbounds double, double* %670, i64 %678
store double %669, double* %679
%680 = load double, double* %21
%681 = load double, double* %22
%682 = fadd double %680, %681
%683 = load double*, double** %9
%684 = load i64, i64* %12
%685 = load i64, i64* %6
%686 = load i64, i64* %13
%687 = mul i64 4, %686
%688 = add i64 0, %687
%689 = mul i64 %685, %688
%690 = add i64 %684, %689
%691 = getelementptr inbounds double, double* %683, i64 %690
store double %682, double* %691
%692 = load double, double* %21
%693 = load double, double* %22
%694 = fsub double %692, %693
%695 = load double*, double** %9
%696 = load i64, i64* %14
%697 = load i64, i64* %6
%698 = load i64, i64* %13
%699 = mul i64 4, %698
%700 = add i64 3, %699
%701 = mul i64 %697, %700
%702 = add i64 %696, %701
%703 = getelementptr inbounds double, double* %695, i64 %702
store double %694, double* %703
%704 = load double, double* %27
%705 = load double, double* %24
%706 = fadd double %704, %705
%707 = load double*, double** %9
%708 = load i64, i64* %12
%709 = sub i64 %708, 1
%710 = load i64, i64* %6
%711 = load i64, i64* %13
%712 = mul i64 4, %711
%713 = add i64 2, %712
%714 = mul i64 %710, %713
%715 = add i64 %709, %714
%716 = getelementptr inbounds double, double* %707, i64 %715
store double %706, double* %716
%717 = load double, double* %27
%718 = load double, double* %24
%719 = fsub double %717, %718
%720 = load double*, double** %9
%721 = load i64, i64* %14
%722 = sub i64 %721, 1
%723 = load i64, i64* %6
%724 = load i64, i64* %13
%725 = mul i64 4, %724
%726 = add i64 1, %725
%727 = mul i64 %723, %726
%728 = add i64 %722, %727
%729 = getelementptr inbounds double, double* %720, i64 %728
store double %719, double* %729
%730 = load double, double* %28
%731 = load double, double* %23
%732 = fadd double %730, %731
%733 = load double*, double** %9
%734 = load i64, i64* %12
%735 = load i64, i64* %6
%736 = load i64, i64* %13
%737 = mul i64 4, %736
%738 = add i64 2, %737
%739 = mul i64 %735, %738
%740 = add i64 %734, %739
%741 = getelementptr inbounds double, double* %733, i64 %740
store double %732, double* %741
%742 = load double, double* %28
%743 = load double, double* %23
%744 = fsub double %742, %743
%745 = load double*, double** %9
%746 = load i64, i64* %14
%747 = load i64, i64* %6
%748 = load i64, i64* %13
%749 = mul i64 4, %748
%750 = add i64 1, %749
%751 = mul i64 %747, %750
%752 = add i64 %746, %751
%753 = getelementptr inbounds double, double* %745, i64 %752
store double %744, double* %753
br label %754
754: ; preds = %335
%755 = load i64, i64* %12
%756 = add i64 %755, 2
store i64 %756, i64* %12
br label %331
757: ; preds = %331
br label %758
758: ; preds = %757
%759 = load i64, i64* %13
%760 = add i64 %759, 1
store i64 %760, i64* %13
br label %326
761: ; preds = %324, %326
ret void
}

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