#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 radf5(size_t ido, size_t l1, const double *cc, double *ch,
           const double *wa) {
  const size_t cdim = 5;
  static const double tr11 = 0.3090169943749474241,
                      ti11 = 0.95105651629515357212,
                      tr12 = -0.8090169943749474241,
                      ti12 = 0.58778525229247312917;
  size_t i, k, ic;
  double ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5,
      cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5;
  for (k = 0; k < l1; k++) {
    {
      cr2 = cc[(0) + ido * ((k) + l1 * (4))] + cc[(0) + ido * ((k) + l1 * (1))];
      ci5 = cc[(0) + ido * ((k) + l1 * (4))] - cc[(0) + ido * ((k) + l1 * (1))];
    }
    {
      cr3 = cc[(0) + ido * ((k) + l1 * (3))] + cc[(0) + ido * ((k) + l1 * (2))];
      ci4 = cc[(0) + ido * ((k) + l1 * (3))] - cc[(0) + ido * ((k) + l1 * (2))];
    }
    ch[(0) + ido * ((0) + cdim * (k))] =
        cc[(0) + ido * ((k) + l1 * (0))] + cr2 + cr3;
    ch[(ido - 1) + ido * ((1) + cdim * (k))] =
        cc[(0) + ido * ((k) + l1 * (0))] + tr11 * cr2 + tr12 * cr3;
    ch[(0) + ido * ((2) + cdim * (k))] = ti11 * ci5 + ti12 * ci4;
    ch[(ido - 1) + ido * ((3) + cdim * (k))] =
        cc[(0) + ido * ((k) + l1 * (0))] + tr12 * cr2 + tr11 * cr3;
    ch[(0) + ido * ((4) + cdim * (k))] = ti12 * ci5 - ti11 * ci4;
  }
  if (ido == 1)
    return;
  for (k = 0; k < l1; ++k)
    for (i = 2; i < ido; i += 2) {
      ic = ido - i;
      {
        dr2 = wa[(i - 2) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))] +
              wa[(i - 1) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))];
        di2 = wa[(i - 2) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))] -
              wa[(i - 1) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))];
      }
      {
        dr3 = wa[(i - 2) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))] +
              wa[(i - 1) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))];
        di3 = wa[(i - 2) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))] -
              wa[(i - 1) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))];
      }
      {
        dr4 = wa[(i - 2) + (2) * ido] * cc[(i - 1) + ido * ((k) + l1 * (3))] +
              wa[(i - 1) + (2) * ido] * cc[(i) + ido * ((k) + l1 * (3))];
        di4 = wa[(i - 2) + (2) * ido] * cc[(i) + ido * ((k) + l1 * (3))] -
              wa[(i - 1) + (2) * ido] * cc[(i - 1) + ido * ((k) + l1 * (3))];
      }
      {
        dr5 = wa[(i - 2) + (3) * ido] * cc[(i - 1) + ido * ((k) + l1 * (4))] +
              wa[(i - 1) + (3) * ido] * cc[(i) + ido * ((k) + l1 * (4))];
        di5 = wa[(i - 2) + (3) * ido] * cc[(i) + ido * ((k) + l1 * (4))] -
              wa[(i - 1) + (3) * ido] * cc[(i - 1) + ido * ((k) + l1 * (4))];
      }
      {
        cr2 = dr5 + dr2;
        ci5 = dr5 - dr2;
      }
      {
        ci2 = di2 + di5;
        cr5 = di2 - di5;
      }
      {
        cr3 = dr4 + dr3;
        ci4 = dr4 - dr3;
      }
      {
        ci3 = di3 + di4;
        cr4 = di3 - di4;
      }
      ch[(i - 1) + ido * ((0) + cdim * (k))] =
          cc[(i - 1) + ido * ((k) + l1 * (0))] + cr2 + cr3;
      ch[(i) + ido * ((0) + cdim * (k))] =
          cc[(i) + ido * ((k) + l1 * (0))] + ci2 + ci3;
      tr2 = cc[(i - 1) + ido * ((k) + l1 * (0))] + tr11 * cr2 + tr12 * cr3;
      ti2 = cc[(i) + ido * ((k) + l1 * (0))] + tr11 * ci2 + tr12 * ci3;
      tr3 = cc[(i - 1) + ido * ((k) + l1 * (0))] + tr12 * cr2 + tr11 * cr3;
      ti3 = cc[(i) + ido * ((k) + l1 * (0))] + tr12 * ci2 + tr11 * ci3;
      {
        tr5 = cr5 * ti11 + cr4 * ti12;
        tr4 = cr5 * ti12 - cr4 * ti11;
      }
      {
        ti5 = ci5 * ti11 + ci4 * ti12;
        ti4 = ci5 * ti12 - ci4 * ti11;
      }
      {
        ch[(i - 1) + ido * ((2) + cdim * (k))] = tr2 + tr5;
        ch[(ic - 1) + ido * ((1) + cdim * (k))] = tr2 - tr5;
      }
      {
        ch[(i) + ido * ((2) + cdim * (k))] = ti5 + ti2;
        ch[(ic) + ido * ((1) + cdim * (k))] = ti5 - ti2;
      }
      {
        ch[(i - 1) + ido * ((4) + cdim * (k))] = tr3 + tr4;
        ch[(ic - 1) + ido * ((3) + cdim * (k))] = tr3 - tr4;
      }
      {
        ch[(i) + ido * ((4) + cdim * (k))] = ti4 + ti3;
        ch[(ic) + ido * ((3) + cdim * (k))] = ti4 - ti3;
      }
    }
}


x86 assembly (clang, -O0):
<radf5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x88,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x5,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1454 <radf5+0x354>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x2,%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,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x2,%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
movsd  %xmm0,-0x68(%rbp)
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    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%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    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
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
addsd  -0x90(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x0,%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
movsd  -0x90(%rbp),%xmm1
ff
movsd  0xd1f(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
movsd  0xd0f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  0xcbd(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  0xcb8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%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
movsd  -0x90(%rbp),%xmm1
ff
movsd  0xc71(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0xc51(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  0xc0f(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xbe3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x4,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112f <radf5+0x2f>
cmpq   $0x1,-0x8(%rbp)
jne    1464 <radf5+0x364>
jmp    1ef9 <radf5+0xdf9>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1ef9 <radf5+0xdf9>
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1ee3 <radf5+0xde3>
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,-0xa0(%rbp)
ff
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,-0x58(%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,-0xa8(%rbp)
ff
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,-0x70(%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,-0xb0(%rbp)
ff
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,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x3,-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    $0x2,%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   $0x3,-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    $0x2,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x3,-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    $0x2,%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   $0x3,-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    $0x2,%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,-0x80(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xc8(%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  -0x90(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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  -0x50(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x4f2(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x4e2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%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
movsd  -0x50(%rbp),%xmm1
movsd  0x499(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x489(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%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
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x441(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x421(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%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
movsd  -0x50(%rbp),%xmm1
movsd  0x3e8(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x3c8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x398(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movsd  0x390(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x370(%rip),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x341(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  0x324(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  0x31f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  0x302(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x2d6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x4,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x4,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    1482 <radf5+0x382>
jmp    1ee8 <radf5+0xde8>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    146c <radf5+0x36c>
add    $0x88,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radf5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %rsi,%rsi
je     12d2 <radf5+0x1d2>
mov    %rdx,%r9
lea    0x0(,%rsi,4),%rax
mov    %rax,-0x40(%rsp)
lea    (%rsi,%rsi,2),%rax
mov    %rax,-0x48(%rsp)
lea    (%rsi,%rsi,1),%rax
mov    %rax,-0x50(%rsp)
cmp    $0x1,%rsi
mov    %rsi,-0x68(%rsp)
mov    %rdi,-0x58(%rsp)
jne    12dd <radf5+0x1dd>
xor    %r11d,%r11d
mov    -0x68(%rsp),%r10
mov    %r10,%rax
sub    %r11,%rax
lea    (%r11,%r11,4),%rsi
add    $0x4,%rsi
mov    -0x58(%rsp),%rbp
imul   %rbp,%rsi
lea    0x0(,%rbp,8),%r14
lea    (%r14,%r14,4),%rdx
mov    %rdx,-0x60(%rsp)
lea    (%r11,%r11,4),%rbx
add    $0x2,%rbx
imul   %rbp,%rbx
mov    %r11,%rdx
imul   %rbp,%rdx
lea    0x0(,%rdx,8),%rdi
lea    (%rdi,%rdi,4),%r15
mov    -0x50(%rsp),%rdi
lea    (%r11,%rdi,1),%r12
imul   %rbp,%r12
mov    -0x48(%rsp),%rdi
lea    (%r11,%rdi,1),%r13
imul   %rbp,%r13
lea    (%r11,%r10,1),%rdi
imul   %rbp,%rdi
add    -0x40(%rsp),%r11
imul   %rbp,%r11
movsd  0xe84(%rip),%xmm10
movsd  0xe84(%rip),%xmm1
movsd  0xe84(%rip),%xmm2
movsd  0xe83(%rip),%xmm8
movsd  0xe82(%rip),%xmm9
mov    %r9,%rbp
mov    %rcx,%r10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%r11,8),%xmm5
movsd  0x0(%rbp,%rdi,8),%xmm3
movapd %xmm5,%xmm7
addsd  %xmm3,%xmm7
subsd  %xmm3,%xmm5
movsd  0x0(%rbp,%r13,8),%xmm0
movsd  0x0(%rbp,%r12,8),%xmm4
movapd %xmm0,%xmm3
addsd  %xmm4,%xmm3
subsd  %xmm4,%xmm0
movsd  0x0(%rbp,%rdx,8),%xmm4
addsd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r10,%r15,1)
movapd %xmm7,%xmm4
mulsd  %xmm10,%xmm4
addsd  0x0(%rbp,%rdx,8),%xmm4
movapd %xmm3,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm4,%xmm6
movsd  %xmm6,-0x8(%r10,%rbx,8)
movapd %xmm0,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm5,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm4,%xmm6
movsd  %xmm6,(%r10,%rbx,8)
mulsd  %xmm1,%xmm7
addsd  0x0(%rbp,%rdx,8),%xmm7
mulsd  %xmm10,%xmm3
addsd  %xmm7,%xmm3
movsd  %xmm3,-0x8(%r10,%rsi,8)
mulsd  %xmm9,%xmm0
mulsd  %xmm2,%xmm5
addsd  %xmm0,%xmm5
movsd  %xmm5,(%r10,%rsi,8)
add    -0x60(%rsp),%r10
add    %r14,%rbp
add    $0xffffffffffffffff,%rax
jne    1200 <radf5+0x100>
mov    -0x58(%rsp),%r14
cmp    $0x1,%r14
jne    15a9 <radf5+0x4a9>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rsi),%rax
mov    $0x28,%edx
mul    %rdx
seto   %dl
cmp    $0x1,%rdi
jne    1149 <radf5+0x49>
lea    0x18(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x18,%rdi
cmp    %rsi,%rdi
jb     1149 <radf5+0x49>
test   %dl,%dl
jne    1149 <radf5+0x49>
lea    0x20(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x20,%rdi
cmp    %rsi,%rdi
jb     1149 <radf5+0x49>
test   %dl,%dl
jne    1149 <radf5+0x49>
lea    0x10(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x10,%rdi
cmp    %rsi,%rdi
jb     1149 <radf5+0x49>
test   %dl,%dl
jne    1149 <radf5+0x49>
lea    0x8(%rcx),%rsi
lea    (%rcx,%rax,1),%rdi
add    $0x8,%rdi
cmp    %rsi,%rdi
jb     1149 <radf5+0x49>
test   %dl,%dl
jne    1149 <radf5+0x49>
add    %rcx,%rax
cmp    %rcx,%rax
jb     1149 <radf5+0x49>
test   %dl,%dl
mov    $0x0,%r11d
jne    114c <radf5+0x4c>
mov    -0x68(%rsp),%rdx
lea    0x0(,%rdx,8),%rax
lea    (%rax,%rax,4),%rsi
lea    (%rcx,%rsi,1),%rbp
lea    (%r9,%rdx,8),%rdi
add    %r9,%rsi
cmp    %rcx,%rdi
seta   -0x60(%rsp)
mov    -0x50(%rsp),%rax
lea    (%r9,%rax,8),%rbx
cmp    %r9,%rbp
seta   %r12b
mov    -0x48(%rsp),%rax
lea    (%r9,%rax,8),%rdx
cmp    %rcx,%rdx
seta   %r15b
mov    -0x40(%rsp),%rax
lea    (%r9,%rax,8),%r11
cmp    %rbp,%rbx
setb   %r14b
cmp    %rcx,%r11
seta   %r13b
cmp    %rbp,%rdx
setb   %r10b
cmp    %rcx,%rbx
seta   %bl
cmp    %rbp,%rdi
setb   %dl
cmp    %rcx,%rsi
seta   %sil
cmp    %rbp,%r11
setb   %bpl
test   %r12b,-0x60(%rsp)
jne    1149 <radf5+0x49>
and    %r14b,%r15b
jne    1149 <radf5+0x49>
and    %r10b,%r13b
jne    1149 <radf5+0x49>
and    %dl,%bl
jne    1149 <radf5+0x49>
and    %bpl,%sil
mov    $0x0,%r11d
jne    114c <radf5+0x4c>
mov    -0x68(%rsp),%r10
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %r10,%rax
mov    -0x58(%rsp),%rsi
imul   %rsi,%rax
mov    %rax,%r14
shl    $0x5,%r14
mov    %rsi,%rdi
shl    $0x4,%rdi
lea    0x0(,%rax,8),%rdx
lea    (%rdx,%rdx,2),%r11
mov    %rax,%rdx
shl    $0x4,%rdx
shl    $0x5,%rsi
lea    (%rsi,%rcx,1),%rbx
add    $0xffffffffffffffe0,%rbx
lea    (%rdi,%rdi,4),%r15
movapd 0xb7a(%rip),%xmm10
movapd 0xb81(%rip),%xmm11
movapd 0xb88(%rip),%xmm12
movapd 0xb8f(%rip),%xmm8
movapd 0xb96(%rip),%xmm9
mov    %rbp,%r12
mov    %rbp,%rsi
mov    %r9,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%rbp,%r14,1),%xmm5
movupd 0x0(%rbp,%rax,8),%xmm1
movapd %xmm5,%xmm0
addpd  %xmm1,%xmm0
subpd  %xmm1,%xmm5
movupd 0x0(%rbp,%r11,1),%xmm3
movupd 0x0(%rbp,%rdx,1),%xmm1
movapd %xmm3,%xmm6
addpd  %xmm1,%xmm6
subpd  %xmm1,%xmm3
movupd 0x0(%rbp),%xmm13
movapd %xmm0,%xmm2
addpd  %xmm13,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm0,%xmm7
mulpd  %xmm10,%xmm7
addpd  %xmm13,%xmm7
movapd %xmm6,%xmm4
mulpd  %xmm11,%xmm4
addpd  %xmm7,%xmm4
movapd %xmm3,%xmm7
mulpd  %xmm12,%xmm7
movapd %xmm5,%xmm1
mulpd  %xmm8,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm11,%xmm0
addpd  %xmm13,%xmm0
mulpd  %xmm10,%xmm6
addpd  %xmm0,%xmm6
mulpd  %xmm9,%xmm3
mulpd  %xmm12,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm2,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm1,%xmm4
unpcklpd %xmm6,%xmm1
unpckhpd %xmm5,%xmm6
shufpd $0x2,%xmm2,%xmm5
movupd %xmm5,0x20(%rbx)
movupd %xmm6,0x40(%rbx)
movupd %xmm4,0x30(%rbx)
movupd %xmm1,0x10(%rbx)
movupd %xmm0,(%rbx)
add    %rdi,%rbp
add    %r15,%rbx
add    $0xfffffffffffffffe,%rsi
jne    14c0 <radf5+0x3c0>
mov    %r12,%r11
cmp    %r10,%r12
jne    114c <radf5+0x4c>
jmp    12c3 <radf5+0x1c3>
lea    (%r14,%r14,1),%rdx
lea    (%r14,%r14,2),%rsi
xor    %eax,%eax
mov    %rax,-0x38(%rsp)
movsd  0xa8f(%rip),%xmm11
movsd  0xa8e(%rip),%xmm8
movsd  0xa95(%rip),%xmm10
jmp    15fc <radf5+0x4fc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x38(%rsp),%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,-0x38(%rsp)
cmp    -0x68(%rsp),%rdi
je     12d2 <radf5+0x1d2>
cmp    $0x3,%r14
jb     15e0 <radf5+0x4e0>
mov    -0x68(%rsp),%rax
mov    -0x38(%rsp),%rdi
add    %rdi,%rax
imul   %r14,%rax
mov    %rax,-0x60(%rsp)
mov    -0x50(%rsp),%rax
add    %rdi,%rax
imul   %r14,%rax
mov    %rax,-0x8(%rsp)
mov    -0x48(%rsp),%rax
add    %rdi,%rax
imul   %r14,%rax
mov    %rax,-0x10(%rsp)
mov    -0x40(%rsp),%rax
add    %rdi,%rax
imul   %r14,%rax
mov    %rax,-0x18(%rsp)
mov    %rdi,%rax
imul   %r14,%rax
mov    %rax,-0x28(%rsp)
lea    (%rdi,%rdi,4),%rax
imul   %r14,%rax
mov    %rax,-0x20(%rsp)
lea    (%rdi,%rdi,4),%rax
add    $0x2,%rax
imul   %r14,%rax
mov    %rax,-0x30(%rsp)
lea    (%rdi,%rdi,4),%r10
add    $0x1,%r10
imul   %r14,%r10
lea    (%rdi,%rdi,4),%r11
add    $0x4,%r11
imul   %r14,%r11
lea    (%rdi,%rdi,4),%r12
add    $0x3,%r12
imul   %r14,%r12
mov    $0x2,%edi
xchg   %ax,%ax
mov    -0x60(%rsp),%rax
lea    (%rdi,%rax,1),%r13
add    $0xffffffffffffffff,%r13
movsd  -0x10(%r8,%rdi,8),%xmm15
movapd %xmm8,%xmm12
movsd  (%r9,%r13,8),%xmm8
mov    -0x58(%rsp),%r14
movsd  -0x8(%r8,%rdi,8),%xmm5
lea    (%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm2
movapd %xmm15,%xmm13
mulsd  %xmm8,%xmm13
mulsd  %xmm5,%xmm8
lea    -0x2(%rdi,%r14,1),%rbx
movsd  (%r8,%rbx,8),%xmm0
mulsd  %xmm2,%xmm5
mov    -0x8(%rsp),%rax
lea    -0x1(%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm4
lea    -0x1(%rdi,%r14,1),%rbx
mulsd  %xmm2,%xmm15
movsd  (%r8,%rbx,8),%xmm2
lea    (%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm3
movapd %xmm0,%xmm14
mulsd  %xmm4,%xmm14
mulsd  %xmm2,%xmm4
movapd %xmm2,%xmm7
lea    -0x2(%rdi,%rdx,1),%rbx
movsd  (%r8,%rbx,8),%xmm2
mulsd  %xmm3,%xmm7
mov    -0x10(%rsp),%rax
lea    -0x1(%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm6
lea    -0x1(%rdi,%rdx,1),%rbx
mulsd  %xmm3,%xmm0
movsd  (%r8,%rbx,8),%xmm1
lea    (%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm9
movapd %xmm2,%xmm3
addsd  %xmm5,%xmm13
mulsd  %xmm6,%xmm3
mulsd  %xmm1,%xmm6
mulsd  %xmm9,%xmm1
subsd  %xmm8,%xmm15
mulsd  %xmm9,%xmm2
lea    -0x2(%rdi,%rsi,1),%rbx
movsd  (%r8,%rbx,8),%xmm8
addsd  %xmm7,%xmm14
mov    -0x18(%rsp),%rax
lea    -0x1(%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm5
lea    -0x1(%rdi,%rsi,1),%rbx
subsd  %xmm4,%xmm0
movsd  (%r8,%rbx,8),%xmm4
lea    (%rdi,%rax,1),%rbx
movsd  (%r9,%rbx,8),%xmm9
movapd %xmm8,%xmm7
addsd  %xmm1,%xmm3
mulsd  %xmm5,%xmm7
mulsd  %xmm4,%xmm5
mulsd  %xmm9,%xmm4
subsd  %xmm6,%xmm2
addsd  %xmm4,%xmm7
mulsd  %xmm9,%xmm8
subsd  %xmm5,%xmm8
movapd %xmm13,%xmm1
addsd  %xmm7,%xmm1
movapd %xmm15,%xmm5
addsd  %xmm8,%xmm5
movapd %xmm14,%xmm4
mov    -0x28(%rsp),%rbp
lea    -0x1(%rdi,%rbp,1),%rbx
movsd  (%r9,%rbx,8),%xmm6
addsd  %xmm3,%xmm4
movapd %xmm0,%xmm9
addsd  %xmm1,%xmm6
addsd  %xmm4,%xmm6
mov    -0x20(%rsp),%r15
lea    -0x1(%rdi,%r15,1),%rax
addsd  %xmm2,%xmm9
movsd  %xmm6,(%rcx,%rax,8)
lea    (%rdi,%rbp,1),%rax
movsd  (%r9,%rax,8),%xmm6
addsd  %xmm5,%xmm6
addsd  %xmm9,%xmm6
mov    %rsi,%r13
mov    %rdx,%rsi
lea    (%rdi,%r15,1),%rdx
movsd  %xmm6,(%rcx,%rdx,8)
subsd  %xmm13,%xmm7
subsd  %xmm8,%xmm15
subsd  %xmm14,%xmm3
subsd  %xmm2,%xmm0
movapd %xmm1,%xmm6
movsd  (%r9,%rbx,8),%xmm8
mulsd  %xmm11,%xmm6
addsd  %xmm8,%xmm6
movapd %xmm4,%xmm2
mulsd  %xmm12,%xmm2
addsd  %xmm6,%xmm2
movsd  (%r9,%rax,8),%xmm14
movapd %xmm5,%xmm6
mulsd  %xmm11,%xmm6
movapd %xmm9,%xmm13
mulsd  %xmm12,%xmm13
addsd  %xmm14,%xmm6
addsd  %xmm6,%xmm13
mulsd  %xmm12,%xmm1
addsd  %xmm8,%xmm1
movapd %xmm12,%xmm8
movsd  0x79a(%rip),%xmm12
mulsd  %xmm11,%xmm4
mulsd  %xmm8,%xmm5
addsd  %xmm14,%xmm5
movapd %xmm0,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm1,%xmm4
movapd %xmm15,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm6,%xmm1
movsd  0x778(%rip),%xmm6
mulsd  %xmm6,%xmm0
mulsd  %xmm11,%xmm9
mulsd  %xmm12,%xmm15
addsd  %xmm0,%xmm15
movapd %xmm3,%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm5,%xmm9
movapd %xmm7,%xmm5
mulsd  %xmm10,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm6,%xmm3
mulsd  %xmm12,%xmm7
addsd  %xmm3,%xmm7
movapd %xmm1,%xmm0
addsd  %xmm2,%xmm0
mov    -0x30(%rsp),%rbx
lea    -0x1(%rdi,%rbx,1),%rax
movsd  %xmm0,(%rcx,%rax,8)
subsd  %xmm1,%xmm2
mov    %r14,%rax
sub    %rdi,%rax
lea    (%rax,%r10,1),%rdx
add    $0xffffffffffffffff,%rdx
movsd  %xmm2,(%rcx,%rdx,8)
movapd %xmm5,%xmm0
addsd  %xmm13,%xmm0
subsd  %xmm13,%xmm5
lea    (%rdi,%rbx,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
lea    (%rax,%r10,1),%rdx
movsd  %xmm5,(%rcx,%rdx,8)
movapd %xmm15,%xmm0
lea    -0x1(%rdi,%r11,1),%rdx
addsd  %xmm4,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
subsd  %xmm15,%xmm4
lea    -0x1(%rax,%r12,1),%rdx
movsd  %xmm4,(%rcx,%rdx,8)
movapd %xmm7,%xmm0
addsd  %xmm9,%xmm0
subsd  %xmm9,%xmm7
lea    (%rdi,%r11,1),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    %rsi,%rdx
mov    %r13,%rsi
add    %r12,%rax
movsd  %xmm7,(%rcx,%rax,8)
add    $0x2,%rdi
cmp    %r14,%rdi
jb     16a0 <radf5+0x5a0>
jmp    15e0 <radf5+0x4e0>

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

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