#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 size_t k;
typedef int ic;
typedef int i;

/* Variables and functions */
void radb5(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, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3,
      ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
  for (k = 0; k < l1; k++) {
    ti5 = 2 * cc[(0) + ido * ((2) + cdim * (k))];
    ti4 = 2 * cc[(0) + ido * ((4) + cdim * (k))];
    tr2 = 2 * cc[(ido - 1) + ido * ((1) + cdim * (k))];
    tr3 = 2 * cc[(ido - 1) + ido * ((3) + cdim * (k))];
    ch[(0) + ido * ((k) + l1 * (0))] =
        cc[(0) + ido * ((0) + cdim * (k))] + tr2 + tr3;
    cr2 = cc[(0) + ido * ((0) + cdim * (k))] + tr11 * tr2 + tr12 * tr3;
    cr3 = cc[(0) + ido * ((0) + cdim * (k))] + tr12 * tr2 + tr11 * tr3;
    {
      ci5 = ti5 * ti11 + ti4 * ti12;
      ci4 = ti5 * ti12 - ti4 * ti11;
    }
    {
      ch[(0) + ido * ((k) + l1 * (4))] = cr2 + ci5;
      ch[(0) + ido * ((k) + l1 * (1))] = cr2 - ci5;
    }
    {
      ch[(0) + ido * ((k) + l1 * (3))] = cr3 + ci4;
      ch[(0) + ido * ((k) + l1 * (2))] = cr3 - ci4;
    }
  }
  if (ido == 1)
    return;
  for (k = 0; k < l1; ++k)
    for (i = 2; i < ido; i += 2) {
      ic = ido - i;
      {
        tr2 = cc[(i - 1) + ido * ((2) + cdim * (k))] +
              cc[(ic - 1) + ido * ((1) + cdim * (k))];
        tr5 = cc[(i - 1) + ido * ((2) + cdim * (k))] -
              cc[(ic - 1) + ido * ((1) + cdim * (k))];
      }
      {
        ti5 = cc[(i) + ido * ((2) + cdim * (k))] +
              cc[(ic) + ido * ((1) + cdim * (k))];
        ti2 = cc[(i) + ido * ((2) + cdim * (k))] -
              cc[(ic) + ido * ((1) + cdim * (k))];
      }
      {
        tr3 = cc[(i - 1) + ido * ((4) + cdim * (k))] +
              cc[(ic - 1) + ido * ((3) + cdim * (k))];
        tr4 = cc[(i - 1) + ido * ((4) + cdim * (k))] -
              cc[(ic - 1) + ido * ((3) + cdim * (k))];
      }
      {
        ti4 = cc[(i) + ido * ((4) + cdim * (k))] +
              cc[(ic) + ido * ((3) + cdim * (k))];
        ti3 = cc[(i) + ido * ((4) + cdim * (k))] -
              cc[(ic) + ido * ((3) + cdim * (k))];
      }
      ch[(i - 1) + ido * ((k) + l1 * (0))] =
          cc[(i - 1) + ido * ((0) + cdim * (k))] + tr2 + tr3;
      ch[(i) + ido * ((k) + l1 * (0))] =
          cc[(i) + ido * ((0) + cdim * (k))] + ti2 + ti3;
      cr2 = cc[(i - 1) + ido * ((0) + cdim * (k))] + tr11 * tr2 + tr12 * tr3;
      ci2 = cc[(i) + ido * ((0) + cdim * (k))] + tr11 * ti2 + tr12 * ti3;
      cr3 = cc[(i - 1) + ido * ((0) + cdim * (k))] + tr12 * tr2 + tr11 * tr3;
      ci3 = cc[(i) + ido * ((0) + cdim * (k))] + tr12 * ti2 + tr11 * ti3;
      {
        cr5 = tr5 * ti11 + tr4 * ti12;
        cr4 = tr5 * ti12 - tr4 * ti11;
      }
      {
        ci5 = ti5 * ti11 + ti4 * ti12;
        ci4 = ti5 * ti12 - ti4 * ti11;
      }
      {
        dr4 = cr3 + ci4;
        dr3 = cr3 - ci4;
      }
      {
        di3 = ci3 + cr4;
        di4 = ci3 - cr4;
      }
      {
        dr5 = cr2 + ci5;
        dr2 = cr2 - ci5;
      }
      {
        di2 = ci2 + cr5;
        di5 = ci2 - cr5;
      }
      {
        ch[(i) + ido * ((k) + l1 * (1))] =
            wa[(i - 2) + (0) * ido] * di2 + wa[(i - 1) + (0) * ido] * dr2;
        ch[(i - 1) + ido * ((k) + l1 * (1))] =
            wa[(i - 2) + (0) * ido] * dr2 - wa[(i - 1) + (0) * ido] * di2;
      }
      {
        ch[(i) + ido * ((k) + l1 * (2))] =
            wa[(i - 2) + (1) * ido] * di3 + wa[(i - 1) + (1) * ido] * dr3;
        ch[(i - 1) + ido * ((k) + l1 * (2))] =
            wa[(i - 2) + (1) * ido] * dr3 - wa[(i - 1) + (1) * ido] * di3;
      }
      {
        ch[(i) + ido * ((k) + l1 * (3))] =
            wa[(i - 2) + (2) * ido] * di4 + wa[(i - 1) + (2) * ido] * dr4;
        ch[(i - 1) + ido * ((k) + l1 * (3))] =
            wa[(i - 2) + (2) * ido] * dr4 - wa[(i - 1) + (2) * ido] * di4;
      }
      {
        ch[(i) + ido * ((k) + l1 * (4))] =
            wa[(i - 2) + (3) * ido] * di5 + wa[(i - 1) + (3) * ido] * dr5;
        ch[(i - 1) + ido * ((k) + l1 * (4))] =
            wa[(i - 2) + (3) * ido] * dr5 - wa[(i - 1) + (3) * ido] * di5;
      }
    }
}


x86 assembly (clang, -O0):
<radb5>:
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    1441 <radb5+0x341>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x2,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  0xec2(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x4,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  0xe94(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x18(%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  0xe5f(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x18(%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  0xe2a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movsd  0xd90(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  0xd80(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x5,-0x40(%rbp),%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movsd  0xd42(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  0xd22(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0xcf2(%rip),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  0xcea(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0xccd(%rip),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc9e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x20(%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
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0x60(%rbp),%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x60(%rbp),%xmm0
mov    -0x20(%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112f <radb5+0x2f>
cmpq   $0x1,-0x8(%rbp)
jne    1451 <radb5+0x351>
jmp    1eb3 <radb5+0xdb3>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1eb3 <radb5+0xdb3>
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1e9d <radb5+0xd9d>
mov    -0x8(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%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
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%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
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x5,-0x40(%rbp),%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
addsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movsd  0x830(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  0x820(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movsd  0x7d7(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x7c7(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
movsd  0x785(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  0x765(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%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  (%rax,%rcx,8),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movsd  0x72c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x70c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x108(%rbp),%xmm0
ff
movsd  0x6df(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movsd  0x6d7(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  0x6b7(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x688(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x668(%rip),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movsd  0x660(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  0x643(%rip),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x614(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x98(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%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
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe8(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
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  %xmm0,(%rax,%rcx,8)
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
movsd  -0x70(%rbp),%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
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
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
movsd  -0xd0(%rbp),%xmm2
ff
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
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
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
movsd  -0x78(%rbp),%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
mulsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
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
movsd  -0xd8(%rbp),%xmm2
ff
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
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x3,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%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
mulsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x3,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x3,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%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  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    146f <radb5+0x36f>
jmp    1ea2 <radb5+0xda2>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1459 <radb5+0x359>
add    $0x88,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radb5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%rax
mov    %rsi,-0x58(%rsp)
test   %rsi,%rsi
je     125b <radb5+0x15b>
mov    %rdi,%r13
mov    -0x58(%rsp),%rbp
mov    %rbp,%r12
imul   %rdi,%r12
mov    %r12,%r14
shl    $0x4,%r14
lea    0x0(,%rdi,8),%r10
lea    0x0(,%r12,8),%rax
lea    (%rax,%rax,2),%r9
mov    %r12,%r15
shl    $0x5,%r15
lea    (%r10,%r10,4),%r11
shl    $0x5,%rdi
mov    %r13,%rsi
shl    $0x4,%rsi
movsd  0xe9c(%rip),%xmm10
movsd  0xe9b(%rip),%xmm8
movsd  0xe9a(%rip),%xmm11
mov    %rdx,%rbx
mov    %rcx,%rax
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rsi,1),%xmm3
movsd  (%rbx,%rsi,1),%xmm0
addsd  %xmm0,%xmm0
movsd  -0x8(%rbx,%rdi,1),%xmm1
movsd  (%rbx,%rdi,1),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm3
addsd  %xmm1,%xmm1
movsd  (%rbx),%xmm4
addsd  %xmm3,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rax)
movsd  (%rbx),%xmm4
movapd %xmm3,%xmm5
movapd %xmm10,%xmm7
mulsd  %xmm10,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm8,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm10,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm2,%xmm3
mulsd  %xmm11,%xmm3
movapd %xmm0,%xmm4
mulsd  0xe18(%rip),%xmm4
addsd  %xmm3,%xmm4
mulsd  0xe14(%rip),%xmm2
mulsd  %xmm11,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm4,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rax,%r15,1)
subsd  %xmm4,%xmm6
movsd  %xmm6,(%rax,%r12,8)
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%r9,1)
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%r14,1)
add    %r10,%rax
add    %r11,%rbx
add    $0xffffffffffffffff,%rbp
jne    1180 <radb5+0x80>
cmp    $0x1,%r13
jne    1266 <radb5+0x166>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x58(%rsp),%rax
lea    (%rax,%rax,1),%rsi
mov    %rsi,-0x38(%rsp)
mov    %r13,%rsi
add    %r13,%rsi
mov    %rsi,-0x28(%rsp)
lea    (%rax,%rax,2),%rsi
mov    %rsi,-0x40(%rsp)
lea    0x0(%r13,%r13,2),%rsi
mov    %rsi,-0x30(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,-0x48(%rsp)
xor    %eax,%eax
mov    %rax,-0x50(%rsp)
jmp    12c8 <radb5+0x1c8>
nopl   0x0(%rax,%rax,1)
mov    -0x50(%rsp),%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,-0x50(%rsp)
cmp    -0x58(%rsp),%rsi
je     125b <radb5+0x15b>
cmp    $0x3,%r13
movsd  0xd33(%rip),%xmm8
jb     12b0 <radb5+0x1b0>
mov    -0x50(%rsp),%rdi
lea    (%rdi,%rdi,4),%rax
lea    (%rdi,%rdi,4),%rsi
add    $0x2,%rsi
imul   %r13,%rsi
mov    %rsi,-0x10(%rsp)
lea    (%rdi,%rdi,4),%rsi
add    $0x1,%rsi
imul   %r13,%rsi
mov    %rsi,-0x18(%rsp)
lea    (%rdi,%rdi,4),%rsi
add    $0x4,%rsi
imul   %r13,%rsi
mov    %rsi,-0x20(%rsp)
lea    (%rdi,%rdi,4),%r9
add    $0x3,%r9
imul   %r13,%r9
imul   %r13,%rax
mov    %rax,-0x8(%rsp)
mov    %rdi,%r15
imul   %r13,%r15
mov    -0x58(%rsp),%rax
lea    (%rdi,%rax,1),%r14
imul   %r13,%r14
mov    -0x38(%rsp),%rax
lea    (%rdi,%rax,1),%r10
imul   %r13,%r10
mov    -0x40(%rsp),%rax
lea    (%rdi,%rax,1),%rsi
imul   %r13,%rsi
mov    -0x48(%rsp),%rax
lea    (%rdi,%rax,1),%r11
imul   %r13,%r11
mov    $0x2,%r12d
nopl   0x0(%rax)
mov    %r13,%rdi
sub    %r12,%rdi
mov    -0x10(%rsp),%rbx
lea    (%r12,%rbx,1),%rax
add    $0xffffffffffffffff,%rax
movsd  (%rdx,%rax,8),%xmm13
mov    -0x18(%rsp),%rbp
lea    -0x1(%rdi,%rbp,1),%rax
movsd  (%rdx,%rax,8),%xmm0
movapd %xmm13,%xmm14
addsd  %xmm0,%xmm14
lea    (%r12,%rbx,1),%rax
movsd  (%rdx,%rax,8),%xmm15
subsd  %xmm0,%xmm13
lea    (%rdi,%rbp,1),%rax
movsd  (%rdx,%rax,8),%xmm1
movapd %xmm15,%xmm9
mov    -0x20(%rsp),%rbx
lea    -0x1(%r12,%rbx,1),%rax
addsd  %xmm1,%xmm9
movsd  (%rdx,%rax,8),%xmm0
lea    -0x1(%rdi,%r9,1),%rax
movsd  (%rdx,%rax,8),%xmm3
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm15
lea    (%r12,%rbx,1),%rax
movsd  (%rdx,%rax,8),%xmm5
add    %r9,%rdi
addsd  %xmm3,%xmm2
movsd  (%rdx,%rdi,8),%xmm1
movapd %xmm5,%xmm4
mov    -0x8(%rsp),%rbx
lea    -0x1(%r12,%rbx,1),%rax
movsd  (%rdx,%rax,8),%xmm6
subsd  %xmm1,%xmm5
addsd  %xmm14,%xmm6
addsd  %xmm2,%xmm6
lea    -0x1(%r12,%r15,1),%rdi
movsd  %xmm6,(%rcx,%rdi,8)
lea    (%r12,%rbx,1),%rdi
movsd  (%rdx,%rdi,8),%xmm6
addsd  %xmm15,%xmm6
subsd  %xmm3,%xmm0
addsd  %xmm5,%xmm6
lea    (%r12,%r15,1),%rbx
movsd  %xmm6,(%rcx,%rbx,8)
addsd  %xmm1,%xmm4
movsd  (%rdx,%rax,8),%xmm1
movapd %xmm14,%xmm6
movapd %xmm10,%xmm12
mulsd  %xmm10,%xmm6
movapd %xmm2,%xmm7
mulsd  %xmm8,%xmm7
addsd  %xmm1,%xmm6
movsd  (%rdx,%rdi,8),%xmm8
movapd %xmm15,%xmm3
mulsd  %xmm10,%xmm3
mulsd  0xb86(%rip),%xmm14
addsd  %xmm8,%xmm3
addsd  %xmm1,%xmm14
mulsd  0xb73(%rip),%xmm15
movapd %xmm0,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm8,%xmm15
movapd %xmm13,%xmm8
movsd  0xb67(%rip),%xmm10
mulsd  %xmm10,%xmm8
addsd  %xmm1,%xmm8
movapd %xmm5,%xmm1
mulsd  0xb41(%rip),%xmm1
movsd  0xb50(%rip),%xmm10
mulsd  %xmm10,%xmm0
mulsd  %xmm11,%xmm13
addsd  %xmm0,%xmm13
movapd %xmm4,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm6,%xmm7
movapd %xmm9,%xmm6
mulsd  0xb1f(%rip),%xmm6
addsd  %xmm0,%xmm6
mulsd  %xmm10,%xmm4
addsd  %xmm3,%xmm1
mulsd  %xmm11,%xmm9
addsd  %xmm4,%xmm9
movapd %xmm6,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm8,%xmm4
subsd  %xmm6,%xmm7
addsd  %xmm1,%xmm4
movsd  -0x8(%r8,%r12,8),%xmm3
movsd  -0x10(%r8,%r12,8),%xmm6
mulsd  %xmm7,%xmm3
mulsd  %xmm4,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm12,%xmm2
addsd  %xmm14,%xmm2
lea    (%r12,%r14,1),%rax
movsd  %xmm6,(%rcx,%rax,8)
mulsd  -0x8(%r8,%r12,8),%xmm4
movapd %xmm12,%xmm10
mulsd  %xmm12,%xmm5
mulsd  -0x10(%r8,%r12,8),%xmm7
addsd  %xmm15,%xmm5
movapd %xmm9,%xmm3
addsd  %xmm2,%xmm3
subsd  %xmm4,%xmm7
movapd %xmm13,%xmm4
lea    -0x1(%r12,%r14,1),%rax
subsd  %xmm9,%xmm2
movsd  %xmm7,(%rcx,%rax,8)
lea    -0x2(%r12,%r13,1),%rax
lea    -0x1(%r12,%r13,1),%rdi
addsd  %xmm5,%xmm4
movsd  (%r8,%rdi,8),%xmm6
mulsd  %xmm2,%xmm6
movsd  (%r8,%rax,8),%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
lea    (%r12,%r10,1),%rbx
movsd  %xmm7,(%rcx,%rbx,8)
subsd  %xmm13,%xmm5
mulsd  (%r8,%rdi,8),%xmm4
mulsd  (%r8,%rax,8),%xmm2
subsd  %xmm4,%xmm2
lea    -0x1(%r12,%r10,1),%rax
mov    -0x28(%rsp),%rbx
lea    -0x2(%r12,%rbx,1),%rdi
movsd  %xmm2,(%rcx,%rax,8)
lea    -0x1(%r12,%rbx,1),%rax
movsd  (%r8,%rax,8),%xmm2
movsd  (%r8,%rdi,8),%xmm4
mulsd  %xmm3,%xmm2
mulsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
lea    (%r12,%rsi,1),%rbx
movsd  %xmm4,(%rcx,%rbx,8)
mulsd  (%r8,%rax,8),%xmm5
mulsd  (%r8,%rdi,8),%xmm3
subsd  %xmm5,%xmm3
lea    -0x1(%r12,%rsi,1),%rax
subsd  %xmm8,%xmm1
movsd  0x9d7(%rip),%xmm8
movsd  %xmm3,(%rcx,%rax,8)
mov    -0x30(%rsp),%rdi
lea    -0x2(%r12,%rdi,1),%rax
lea    -0x1(%r12,%rdi,1),%rdi
movsd  (%r8,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  (%r8,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
lea    (%r12,%r11,1),%rbx
movsd  %xmm3,(%rcx,%rbx,8)
mulsd  (%r8,%rdi,8),%xmm1
mulsd  (%r8,%rax,8),%xmm0
subsd  %xmm1,%xmm0
lea    (%r12,%r11,1),%rax
add    $0xffffffffffffffff,%rax
movsd  %xmm0,(%rcx,%rax,8)
add    $0x2,%r12
cmp    %r13,%r12
jb     1370 <radb5+0x270>
jmp    12b0 <radb5+0x1b0>

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

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