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

/* Forward declarations */

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

/* Variables and functions */
void radf3(size_t ido, size_t l1, const double *cc, double *ch,
           const double *wa) {
  const size_t cdim = 3;
  static const double taur = -0.5, taui = 0.86602540378443864676;
  size_t i, k, ic;
  double ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3;
  for (k = 0; k < l1; k++) {
    cr2 = cc[(0) + ido * ((k) + l1 * (1))] + cc[(0) + ido * ((k) + l1 * (2))];
    ch[(0) + ido * ((0) + cdim * (k))] = cc[(0) + ido * ((k) + l1 * (0))] + cr2;
    ch[(0) + ido * ((2) + cdim * (k))] =
        taui *
        (cc[(0) + ido * ((k) + l1 * (2))] - cc[(0) + ido * ((k) + l1 * (1))]);
    ch[(ido - 1) + ido * ((1) + cdim * (k))] =
        cc[(0) + ido * ((k) + l1 * (0))] + taur * cr2;
  }
  if (ido == 1)
    return;
  for (k = 0; k < l1; k++)
    for (i = 2; i < ido; i += 2) {
      ic = ido - i;
      {
        dr2 = wa[(i - 2) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))] +
              wa[(i - 1) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))];
        di2 = wa[(i - 2) + (0) * ido] * cc[(i) + ido * ((k) + l1 * (1))] -
              wa[(i - 1) + (0) * ido] * cc[(i - 1) + ido * ((k) + l1 * (1))];
      }
      {
        dr3 = wa[(i - 2) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))] +
              wa[(i - 1) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))];
        di3 = wa[(i - 2) + (1) * ido] * cc[(i) + ido * ((k) + l1 * (2))] -
              wa[(i - 1) + (1) * ido] * cc[(i - 1) + ido * ((k) + l1 * (2))];
      }
      cr2 = dr2 + dr3;
      ci2 = di2 + di3;
      ch[(i - 1) + ido * ((0) + cdim * (k))] =
          cc[(i - 1) + ido * ((k) + l1 * (0))] + cr2;
      ch[(i) + ido * ((0) + cdim * (k))] =
          cc[(i) + ido * ((k) + l1 * (0))] + ci2;
      tr2 = cc[(i - 1) + ido * ((k) + l1 * (0))] + taur * cr2;
      ti2 = cc[(i) + ido * ((k) + l1 * (0))] + taur * ci2;
      tr3 = taui * (di2 - di3);
      ti3 = taui * (dr3 - dr2);
      {
        ch[(i - 1) + ido * ((2) + cdim * (k))] = tr2 + tr3;
        ch[(ic - 1) + ido * ((1) + cdim * (k))] = tr2 - tr3;
      }
      {
        ch[(i) + ido * ((2) + cdim * (k))] = ti3 + ti2;
        ch[(ic) + ido * ((1) + cdim * (k))] = ti3 - ti2;
      }
    }
}


x86 assembly (clang, -O0):
<radf3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x3,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    12a9 <radf3+0x1a9>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x0,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x0,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,-0x40(%rbp),%rdx
add    $0x0,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x1,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rsi
shl    $0x0,%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xde5(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
imul   $0x3,-0x40(%rbp),%rdx
add    $0x2,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%rdx
imul   $0x0,-0x10(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  0xd9d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    112c <radf3+0x2c>
cmpq   $0x1,-0x8(%rbp)
jne    12b9 <radf3+0x1b9>
jmp    17d5 <radf3+0x6d5>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    17d5 <radf3+0x6d5>
movq   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    17bf <radf3+0x6bf>
mov    -0x8(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x0,-0x8(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x0,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x2,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x0,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  0x9aa(%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
mov    -0x40(%rbp),%rsi
imul   $0x0,-0x10(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  0x969(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm1
subsd  -0x60(%rbp),%xmm1
movsd  0x942(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
movsd  0x924(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x2,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rdx
imul   $0x3,-0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    12d7 <radf3+0x1d7>
jmp    17c4 <radf3+0x6c4>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12c1 <radf3+0x1c1>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radf3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %rsi,%rsi
je     11eb <radf3+0xeb>
mov    %rcx,%r10
mov    %rdx,%r9
lea    (%rsi,%rsi,1),%rax
mov    %rax,-0x20(%rsp)
cmp    $0x1,%rsi
jne    11f6 <radf3+0xf6>
xor    %r11d,%r11d
mov    %rsi,%rax
sub    %r11,%rax
lea    (%r11,%r11,2),%r13
add    $0x2,%r13
imul   %rdi,%r13
lea    0x0(,%rdi,8),%r15
lea    (%r15,%r15,2),%r14
mov    %r11,%rdx
imul   %rdi,%rdx
lea    0x0(,%rdx,8),%rcx
lea    (%rcx,%rcx,2),%r12
mov    -0x20(%rsp),%rcx
lea    (%r11,%rcx,1),%rbx
imul   %rdi,%rbx
add    %rsi,%r11
imul   %rdi,%r11
movsd  0xea4(%rip),%xmm0
movsd  0xea4(%rip),%xmm1
mov    %r9,%rbp
mov    %r10,%rcx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r11,8),%xmm2
addsd  0x0(%rbp,%rbx,8),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%r12,1)
movsd  0x0(%rbp,%rbx,8),%xmm3
subsd  0x0(%rbp,%r11,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%rcx,%r13,8)
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,-0x8(%rcx,%r13,8)
add    %r14,%rcx
add    %r15,%rbp
add    $0xffffffffffffffff,%rax
jne    1190 <radf3+0x90>
cmp    $0x1,%rdi
jne    1379 <radf3+0x279>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rsi),%rax
mov    $0x18,%ecx
mul    %rcx
seto   %cl
xor    %r11d,%r11d
cmp    $0x1,%rdi
jne    112f <radf3+0x2f>
lea    0x10(%r10),%rdx
lea    (%r10,%rax,1),%rbx
add    $0x10,%rbx
cmp    %rdx,%rbx
jb     112f <radf3+0x2f>
test   %cl,%cl
jne    112f <radf3+0x2f>
lea    0x8(%r10),%rdx
lea    (%r10,%rax,1),%rbx
add    $0x8,%rbx
cmp    %rdx,%rbx
jb     112f <radf3+0x2f>
test   %cl,%cl
jne    112f <radf3+0x2f>
add    %r10,%rax
cmp    %r10,%rax
jb     112f <radf3+0x2f>
test   %cl,%cl
jne    112f <radf3+0x2f>
lea    0x0(,%rsi,8),%rax
lea    (%rax,%rax,2),%rax
lea    (%r10,%rax,1),%rbp
lea    (%r9,%rsi,8),%rbx
add    %r9,%rax
cmp    %r10,%rbx
seta   %r15b
mov    -0x20(%rsp),%rcx
lea    (%r9,%rcx,8),%rcx
cmp    %r9,%rbp
seta   %dl
cmp    %r10,%rax
seta   %al
cmp    %rbp,%rcx
setb   %r14b
cmp    %r10,%rcx
seta   %cl
cmp    %rbp,%rbx
setb   %bl
xor    %r11d,%r11d
test   %dl,%r15b
jne    112f <radf3+0x2f>
and    %r14b,%al
jne    112f <radf3+0x2f>
and    %bl,%cl
jne    112f <radf3+0x2f>
mov    %rsi,%r11
and    $0xfffffffffffffffe,%r11
mov    %rsi,%r15
imul   %rdi,%r15
mov    %rdi,%rbp
shl    $0x4,%rbp
mov    %r15,%r12
shl    $0x4,%r12
lea    (%r10,%rbp,1),%rbx
add    $0xfffffffffffffff0,%rbx
lea    0x0(%rbp,%rbp,2),%r14
movapd 0xd0c(%rip),%xmm0
movapd 0xd14(%rip),%xmm1
mov    %r11,%rax
mov    %r9,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%r15,8),%xmm2
movupd (%rdx,%r12,1),%xmm3
movapd %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd (%rdx),%xmm5
movapd %xmm5,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm6,%xmm2
unpcklpd %xmm4,%xmm2
unpckhpd %xmm3,%xmm4
shufpd $0x2,%xmm6,%xmm3
movupd %xmm3,0x10(%rbx)
movupd %xmm4,0x20(%rbx)
movupd %xmm2,(%rbx)
add    %rbp,%rdx
add    %r14,%rbx
add    $0xfffffffffffffffe,%rax
jne    1310 <radf3+0x210>
cmp    %rsi,%r11
jne    112f <radf3+0x2f>
jmp    11e1 <radf3+0xe1>
xor    %eax,%eax
mov    %rax,-0x18(%rsp)
movsd  0xc9f(%rip),%xmm8
movsd  0xc8e(%rip),%xmm9
mov    %rsi,-0x10(%rsp)
jmp    13bf <radf3+0x2bf>
nopl   0x0(%rax)
mov    -0x18(%rsp),%rcx
add    $0x1,%rcx
mov    -0x10(%rsp),%rsi
mov    %rcx,%rax
mov    %rcx,-0x18(%rsp)
cmp    %rsi,%rcx
je     11eb <radf3+0xeb>
cmp    $0x3,%rdi
jb     13a0 <radf3+0x2a0>
mov    -0x10(%rsp),%rax
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rax,1),%r14
imul   %rdi,%r14
mov    -0x20(%rsp),%rax
lea    (%rcx,%rax,1),%r15
imul   %rdi,%r15
mov    %rcx,%r13
imul   %rdi,%r13
lea    (%rcx,%rcx,2),%r12
imul   %rdi,%r12
lea    (%rcx,%rcx,2),%rax
add    $0x2,%rax
imul   %rdi,%rax
lea    (%rcx,%rcx,2),%rcx
add    $0x1,%rcx
imul   %rdi,%rcx
mov    %rcx,-0x8(%rsp)
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%rbp
lea    (%rbx,%r14,1),%rcx
add    $0xffffffffffffffff,%rcx
movsd  (%r9,%rcx,8),%xmm6
movsd  -0x10(%r8,%rbx,8),%xmm2
movsd  -0x8(%r8,%rbx,8),%xmm4
lea    (%rbx,%r14,1),%rcx
movsd  (%r9,%rcx,8),%xmm7
movapd %xmm2,%xmm3
mulsd  %xmm6,%xmm3
mulsd  %xmm4,%xmm6
lea    -0x2(%rbx,%rdi,1),%rcx
mulsd  %xmm7,%xmm4
movsd  (%r8,%rcx,8),%xmm5
lea    -0x1(%rbx,%r15,1),%rcx
movsd  (%r9,%rcx,8),%xmm0
mulsd  %xmm7,%xmm2
lea    -0x1(%rbx,%rdi,1),%rcx
movsd  (%r8,%rcx,8),%xmm7
lea    (%rbx,%r15,1),%rcx
addsd  %xmm4,%xmm3
movsd  (%r9,%rcx,8),%xmm1
movapd %xmm5,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm7,%xmm0
subsd  %xmm6,%xmm2
mulsd  %xmm1,%xmm7
addsd  %xmm7,%xmm4
mulsd  %xmm1,%xmm5
movapd %xmm3,%xmm6
addsd  %xmm4,%xmm6
lea    -0x1(%rbx,%r13,1),%rcx
movsd  (%r9,%rcx,8),%xmm1
addsd  %xmm6,%xmm1
subsd  %xmm0,%xmm5
movapd %xmm2,%xmm7
lea    -0x1(%rbx,%r12,1),%r11
movsd  %xmm1,(%r10,%r11,8)
lea    (%rbx,%r13,1),%rsi
addsd  %xmm5,%xmm7
movsd  (%r9,%rsi,8),%xmm0
addsd  %xmm7,%xmm0
lea    (%rbx,%r12,1),%rdx
sub    %rbx,%rbp
movsd  %xmm0,(%r10,%rdx,8)
mulsd  %xmm8,%xmm6
addsd  (%r9,%rcx,8),%xmm6
mulsd  %xmm8,%xmm7
addsd  (%r9,%rsi,8),%xmm7
subsd  %xmm5,%xmm2
mulsd  %xmm9,%xmm2
subsd  %xmm3,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm2,%xmm0
addsd  %xmm6,%xmm0
lea    (%rbx,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
subsd  %xmm2,%xmm6
add    -0x8(%rsp),%rbp
movsd  %xmm0,(%r10,%rcx,8)
movsd  %xmm6,-0x8(%r10,%rbp,8)
movapd %xmm4,%xmm0
addsd  %xmm7,%xmm0
lea    (%rbx,%rax,1),%rcx
movsd  %xmm0,(%r10,%rcx,8)
subsd  %xmm7,%xmm4
movsd  %xmm4,(%r10,%rbp,8)
add    $0x2,%rbx
cmp    %rdi,%rbx
jb     1420 <radf3+0x320>
jmp    13a0 <radf3+0x2a0>

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

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