#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 size_t const i;

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


x86 assembly (clang, -O0):
<radb4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x4,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1320 <radb4+0x220>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  0xe09(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x2,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  0xdd8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb0(%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)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
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)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
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  -0xa0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
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)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112c <radb4+0x2c>
mov    -0x8(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    1597 <radb4+0x497>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1592 <radb4+0x492>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x3,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x1,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x3,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
shl    $0x2,%rdx
add    $0x1,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
subsd  -0x80(%rbp),%xmm1
movsd  0xb32(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
addsd  -0x80(%rbp),%xmm1
movsd  0xaab(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x3,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    133a <radb4+0x23a>
jmp    1597 <radb4+0x497>
cmpq   $0x2,-0x8(%rbp)
ja     15a7 <radb4+0x4a7>
jmp    1c6c <radb4+0xb6c>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1c6c <radb4+0xb6c>
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1c56 <radb4+0xb56>
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
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%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
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%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
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x3,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb0(%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)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x90(%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)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x80(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%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  -0x50(%rbp),%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
mulsd  -0x68(%rbp),%xmm1
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  -0x68(%rbp),%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
mulsd  -0x50(%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    $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  -0x58(%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  -0x70(%rbp),%xmm1
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  -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  -0x58(%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  -0x60(%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  -0x78(%rbp),%xmm1
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  -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  -0x60(%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    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    15c5 <radb4+0x4c5>
jmp    1c5b <radb4+0xb5b>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    15af <radb4+0x4af>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radb4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%r12
test   %rsi,%rsi
mov    %rsi,-0x40(%rsp)
je     12aa <radb4+0x1aa>
mov    %rsi,%rdi
imul   %r12,%rdi
lea    (%rcx,%rdi,8),%r9
lea    0x0(,%r12,8),%r11
lea    (%rdi,%rdi,2),%rax
lea    (%rcx,%rax,8),%r10
shl    $0x4,%rdi
add    %rcx,%rdi
mov    %r12,%rax
shl    $0x4,%rax
add    %rdx,%rax
mov    %r12,%rbx
shl    $0x5,%rbx
lea    (%rbx,%rdx,1),%r14
add    $0xfffffffffffffff8,%r14
xor    %ebx,%ebx
mov    %rsi,%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,4),%xmm0
movsd  (%r14,%rbx,4),%xmm1
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm1,%xmm0
movsd  -0x8(%rax,%rbx,4),%xmm1
movsd  (%rax,%rbx,4),%xmm3
addsd  %xmm1,%xmm1
addsd  %xmm3,%xmm3
movapd %xmm2,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rcx,%rbx,1)
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rbx,1)
movapd %xmm0,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%r10,%rbx,1)
subsd  %xmm3,%xmm0
movsd  %xmm0,(%r9,%rbx,1)
add    %r11,%rbx
add    $0xffffffffffffffff,%rbp
jne    1160 <radb4+0x60>
mov    $0x1,%r9b
test   $0x1,%r12b
jne    129f <radb4+0x19f>
lea    (%rsi,%rsi,2),%rax
add    $0x1,%rax
imul   %r12,%rax
lea    (%rcx,%rax,8),%r10
add    $0xfffffffffffffff8,%r10
lea    (%rsi,%rsi,1),%rax
add    $0x1,%rax
imul   %r12,%rax
lea    (%rcx,%rax,8),%r14
add    $0xfffffffffffffff8,%r14
lea    0x1(%rsi),%rax
imul   %r12,%rax
lea    (%rcx,%rax,8),%r15
add    $0xfffffffffffffff8,%r15
mov    %rsi,%rbp
lea    -0x8(%rcx,%r12,8),%rsi
lea    (%r12,%r12,2),%rax
lea    (%rdx,%rax,8),%rax
lea    (%rdx,%r12,8),%rbx
xor    %edi,%edi
movsd  0xddc(%rip),%xmm0
movsd  0xddc(%rip),%xmm1
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdi,4),%xmm2
movsd  (%rax,%rdi,4),%xmm3
movsd  -0x8(%rbx,%rdi,4),%xmm4
movsd  (%rbx,%rdi,4),%xmm5
movapd %xmm3,%xmm6
addsd  %xmm5,%xmm6
subsd  %xmm5,%xmm3
movapd %xmm4,%xmm5
addsd  %xmm2,%xmm5
subsd  %xmm2,%xmm4
addsd  %xmm5,%xmm5
movsd  %xmm5,(%rsi,%rdi,1)
movapd %xmm4,%xmm2
subsd  %xmm6,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r15,%rdi,1)
addsd  %xmm3,%xmm3
movsd  %xmm3,(%r14,%rdi,1)
addsd  %xmm6,%xmm4
mulsd  %xmm1,%xmm4
movsd  %xmm4,(%r10,%rdi,1)
add    %r11,%rdi
add    $0xffffffffffffffff,%rbp
jne    1230 <radb4+0x130>
mov    -0x40(%rsp),%rsi
cmp    $0x3,%r12
jae    12b7 <radb4+0x1b7>
jmp    153d <radb4+0x43d>
xor    %r9d,%r9d
cmp    $0x3,%r12
jb     153d <radb4+0x43d>
test   %r9b,%r9b
je     153d <radb4+0x43d>
lea    (%rsi,%rsi,1),%rax
mov    %rax,-0x30(%rsp)
lea    (%r12,%r12,1),%rbx
lea    (%rsi,%rsi,2),%rax
mov    %rax,-0x38(%rsp)
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rax
imul   %r12,%rax
mov    %rax,-0x8(%rsp)
lea    0x3(,%rdi,4),%rax
imul   %r12,%rax
mov    %rax,-0x10(%rsp)
lea    0x2(,%rdi,4),%rax
imul   %r12,%rax
mov    %rax,-0x18(%rsp)
lea    0x1(,%rdi,4),%rax
imul   %r12,%rax
mov    %rax,-0x20(%rsp)
mov    %rdi,%r13
imul   %r12,%r13
lea    (%rdi,%rsi,1),%r15
imul   %r12,%r15
mov    -0x30(%rsp),%rax
lea    (%rdi,%rax,1),%r9
imul   %r12,%r9
mov    -0x38(%rsp),%rax
mov    %rdi,-0x28(%rsp)
lea    (%rdi,%rax,1),%r10
imul   %r12,%r10
mov    $0x2,%r11d
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
sub    %r11,%rdi
mov    -0x8(%rsp),%rsi
lea    (%r11,%rsi,1),%r14
add    $0xffffffffffffffff,%r14
movsd  (%rdx,%r14,8),%xmm3
mov    -0x10(%rsp),%rbp
lea    -0x1(%rdi,%rbp,1),%rax
movsd  (%rdx,%rax,8),%xmm2
movapd %xmm3,%xmm1
addsd  %xmm2,%xmm1
lea    (%r11,%rsi,1),%rax
movsd  (%rdx,%rax,8),%xmm0
lea    (%rdi,%rbp,1),%rax
subsd  %xmm2,%xmm3
movsd  (%rdx,%rax,8),%xmm4
movapd %xmm0,%xmm7
addsd  %xmm4,%xmm7
mov    -0x18(%rsp),%rsi
lea    (%r11,%rsi,1),%rax
subsd  %xmm4,%xmm0
movsd  (%rdx,%rax,8),%xmm10
mov    -0x20(%rsp),%rbp
lea    (%rdi,%rbp,1),%rax
movsd  (%rdx,%rax,8),%xmm5
movapd %xmm10,%xmm8
addsd  %xmm5,%xmm8
lea    -0x1(%r11,%rsi,1),%rax
movsd  (%rdx,%rax,8),%xmm9
lea    -0x1(%rdi,%rbp,1),%rax
subsd  %xmm5,%xmm10
movsd  (%rdx,%rax,8),%xmm5
movapd %xmm9,%xmm11
addsd  %xmm5,%xmm11
subsd  %xmm5,%xmm9
movapd %xmm1,%xmm5
addsd  %xmm11,%xmm5
lea    -0x1(%r11,%r13,1),%rax
movapd %xmm0,%xmm2
addsd  %xmm10,%xmm2
lea    (%r11,%r13,1),%rdi
movsd  %xmm5,(%rcx,%rax,8)
movsd  %xmm2,(%rcx,%rdi,8)
movapd %xmm3,%xmm5
subsd  %xmm8,%xmm3
movapd %xmm7,%xmm2
addsd  %xmm9,%xmm2
movsd  -0x8(%r8,%r11,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  -0x10(%r8,%r11,8),%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
lea    (%r11,%r15,1),%rax
movsd  %xmm6,(%rcx,%rax,8)
mulsd  -0x8(%r8,%r11,8),%xmm2
subsd  %xmm11,%xmm1
mulsd  -0x10(%r8,%r11,8),%xmm3
subsd  %xmm10,%xmm0
subsd  %xmm2,%xmm3
lea    -0x1(%r11,%r15,1),%rax
lea    -0x2(%r11,%r12,1),%rdi
movsd  %xmm3,(%rcx,%rax,8)
lea    -0x1(%r11,%r12,1),%rax
movsd  (%r8,%rax,8),%xmm2
movsd  (%r8,%rdi,8),%xmm3
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
lea    (%r11,%r9,1),%rsi
movsd  %xmm3,(%rcx,%rsi,8)
mulsd  (%r8,%rax,8),%xmm0
mulsd  (%r8,%rdi,8),%xmm1
addsd  %xmm8,%xmm5
subsd  %xmm0,%xmm1
lea    -0x1(%r11,%r9,1),%rax
subsd  %xmm9,%xmm7
movsd  %xmm1,(%rcx,%rax,8)
lea    -0x2(%r11,%rbx,1),%rax
lea    -0x1(%r11,%rbx,1),%rsi
movsd  (%r8,%rsi,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  (%r8,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
lea    (%r11,%r10,1),%rdi
movsd  %xmm1,(%rcx,%rdi,8)
mulsd  (%r8,%rsi,8),%xmm7
mulsd  (%r8,%rax,8),%xmm5
subsd  %xmm7,%xmm5
lea    (%r11,%r10,1),%rax
add    $0xffffffffffffffff,%rax
movsd  %xmm5,(%rcx,%rax,8)
add    $0x2,%r11
cmp    %r12,%r11
jb     1360 <radb4+0x260>
mov    -0x28(%rsp),%rdi
add    $0x1,%rdi
mov    -0x40(%rsp),%rsi
cmp    %rsi,%rdi
jne    12e0 <radb4+0x1e0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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