#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 size_t j2;
typedef size_t ik;
typedef size_t ic;
typedef size_t i;

/* Variables and functions */
double cos(size_t);
int /*<<< orphan*/ memcpy(double *, double *, size_t);
double sin(size_t);
int /*<<< orphan*/ util_free_(double *);
scalar_t__ util_malloc_(int);
void radfg(size_t ido, size_t ip, size_t l1, size_t idl1, double *cc,
           double *ch, const double *wa) {
  const size_t cdim = ip;
  static const double twopi = 6.28318530717958647692;
  size_t idij, ipph, i, j, k, l, j2, ic, jc, lc, ik;
  double ai1, ai2, ar1, ar2, arg;
  double *csarr;
  size_t aidx;
  ipph = (ip + 1) / 2;
  if (ido != 1) {
    memcpy(ch, cc, idl1 * sizeof(double));
    for (j = 1; j < ip; j++)
      for (k = 0; k < l1; k++) {
        ch[(0) + ido * ((k) + l1 * (j))] = cc[(0) + ido * ((k) + l1 * (j))];
        idij = (j - 1) * ido + 1;
        for (i = 2; i < ido; i += 2, idij += 2) {
          ch[(i - 1) + ido * ((k) + l1 * (j))] =
              wa[idij - 1] * cc[(i - 1) + ido * ((k) + l1 * (j))] +
              wa[idij] * cc[(i) + ido * ((k) + l1 * (j))];
          ch[(i) + ido * ((k) + l1 * (j))] =
              wa[idij - 1] * cc[(i) + ido * ((k) + l1 * (j))] -
              wa[idij] * cc[(i - 1) + ido * ((k) + l1 * (j))];
        }
      }
    for (j = 1, jc = ip - 1; j < ipph; j++, jc--)
      for (k = 0; k < l1; k++)
        for (i = 2; i < ido; i += 2) {
          {
            cc[(i - 1) + ido * ((k) + l1 * (j))] =
                ch[(i - 1) + ido * ((k) + l1 * (jc))] +
                ch[(i - 1) + ido * ((k) + l1 * (j))];
            cc[(i) + ido * ((k) + l1 * (jc))] =
                ch[(i - 1) + ido * ((k) + l1 * (jc))] -
                ch[(i - 1) + ido * ((k) + l1 * (j))];
          }
          {
            cc[(i) + ido * ((k) + l1 * (j))] =
                ch[(i) + ido * ((k) + l1 * (j))] +
                ch[(i) + ido * ((k) + l1 * (jc))];
            cc[(i - 1) + ido * ((k) + l1 * (jc))] =
                ch[(i) + ido * ((k) + l1 * (j))] -
                ch[(i) + ido * ((k) + l1 * (jc))];
          }
        }
  } else
    memcpy(cc, ch, idl1 * sizeof(double));
  for (j = 1, jc = ip - 1; j < ipph; j++, jc--)
    for (k = 0; k < l1; k++) {
      cc[(0) + ido * ((k) + l1 * (j))] =
          ch[(0) + ido * ((k) + l1 * (jc))] + ch[(0) + ido * ((k) + l1 * (j))];
      cc[(0) + ido * ((k) + l1 * (jc))] =
          ch[(0) + ido * ((k) + l1 * (jc))] - ch[(0) + ido * ((k) + l1 * (j))];
    }
  csarr = ((double *)util_malloc_((2 * ip) * sizeof(double)));
  arg = twopi / ip;
  csarr[0] = 1.;
  csarr[1] = 0.;
  csarr[2] = csarr[2 * ip - 2] = cos(arg);
  csarr[3] = sin(arg);
  csarr[2 * ip - 1] = -csarr[3];
  for (i = 2; i <= ip / 2; ++i) {
    csarr[2 * i] = csarr[2 * ip - 2 * i] = cos(i * arg);
    csarr[2 * i + 1] = sin(i * arg);
    csarr[2 * ip - 2 * i + 1] = -csarr[2 * i + 1];
  }
  for (l = 1, lc = ip - 1; l < ipph; l++, lc--) {
    ar1 = csarr[2 * l];
    ai1 = csarr[2 * l + 1];
    for (ik = 0; ik < idl1; ik++) {
      ch[(ik) + idl1 * (l)] =
          cc[(ik) + idl1 * (0)] + ar1 * cc[(ik) + idl1 * (1)];
      ch[(ik) + idl1 * (lc)] = ai1 * cc[(ik) + idl1 * (ip - 1)];
    }
    aidx = 2 * l;
    for (j = 2, jc = ip - 2; j < ipph; j++, jc--) {
      aidx += 2 * l;
      if (aidx >= 2 * ip)
        aidx -= 2 * ip;
      ar2 = csarr[aidx];
      ai2 = csarr[aidx + 1];
      for (ik = 0; ik < idl1; ik++) {
        ch[(ik) + idl1 * (l)] += ar2 * cc[(ik) + idl1 * (j)];
        ch[(ik) + idl1 * (lc)] += ai2 * cc[(ik) + idl1 * (jc)];
      }
    }
  }
  do {
    util_free_(csarr);
    (csarr) = NULL;
  } while (0);
  for (j = 1; j < ipph; j++)
    for (ik = 0; ik < idl1; ik++)
      ch[(ik) + idl1 * (0)] += cc[(ik) + idl1 * (j)];
  for (k = 0; k < l1; k++)
    memcpy(&cc[(0) + ido * ((0) + cdim * (k))],
           &ch[(0) + ido * ((k) + l1 * (0))], ido * sizeof(double));
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    j2 = 2 * j;
    for (k = 0; k < l1; k++) {
      cc[(ido - 1) + ido * ((j2 - 1) + cdim * (k))] =
          ch[(0) + ido * ((k) + l1 * (j))];
      cc[(0) + ido * ((j2) + cdim * (k))] = ch[(0) + ido * ((k) + l1 * (jc))];
    }
  }
  if (ido == 1)
    return;
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    j2 = 2 * j;
    for (k = 0; k < l1; k++)
      for (i = 2; i < ido; i += 2) {
        ic = ido - i;
        {
          cc[(i - 1) + ido * ((j2) + cdim * (k))] =
              ch[(i - 1) + ido * ((k) + l1 * (j))] +
              ch[(i - 1) + ido * ((k) + l1 * (jc))];
          cc[(ic - 1) + ido * ((j2 - 1) + cdim * (k))] =
              ch[(i - 1) + ido * ((k) + l1 * (j))] -
              ch[(i - 1) + ido * ((k) + l1 * (jc))];
        }
        {
          cc[(i) + ido * ((j2) + cdim * (k))] =
              ch[(i) + ido * ((k) + l1 * (jc))] +
              ch[(i) + ido * ((k) + l1 * (j))];
          cc[(ic) + ido * ((j2 - 1) + cdim * (k))] =
              ch[(i) + ido * ((k) + l1 * (jc))] -
              ch[(i) + ido * ((k) + l1 * (j))];
        }
      }
  }
}


x86 assembly (clang, -O0):
<radfg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
shr    $0x1,%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x1,-0x8(%rbp)
je     168c <radfg+0x53c>
mov    -0x30(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x20(%rbp),%rdx
shl    $0x3,%rdx
call   1060 <memcpy@plt>
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    13f8 <radfg+0x2a8>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    13e2 <radfg+0x292>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
sub    $0x1,%rax
imul   -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    13cc <radfg+0x27c>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
jmp    1242 <radfg+0xf2>
jmp    13d1 <radfg+0x281>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11cd <radfg+0x7d>
jmp    13e7 <radfg+0x297>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11b7 <radfg+0x67>
movq   $0x1,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1687 <radfg+0x537>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1665 <radfg+0x515>
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    164f <radfg+0x4ff>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
jmp    1438 <radfg+0x2e8>
jmp    1654 <radfg+0x504>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1422 <radfg+0x2d2>
jmp    166a <radfg+0x51a>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    140c <radfg+0x2bc>
jmp    16a1 <radfg+0x551>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x20(%rbp),%rdx
shl    $0x3,%rdx
call   1060 <memcpy@plt>
movq   $0x1,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    17ea <radfg+0x69a>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    17c8 <radfg+0x678>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x80(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x80(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x80(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    16cb <radfg+0x57b>
jmp    17cd <radfg+0x67d>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    16b5 <radfg+0x565>
mov    -0x10(%rbp),%edi
shl    $0x4,%edi
call   1040 <util_malloc_@plt>
mov    %rax,-0xc0(%rbp)
movaps 0x17fd(%rip),%xmm0
movq   -0x10(%rbp),%xmm1
punpckldq %xmm0,%xmm1
movapd 0x17fc(%rip),%xmm0
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x17f5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xc0(%rbp),%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rax)
mov    -0xc0(%rbp),%rax
movq   $0x0,0x8(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0x17be(%rip),%xmm2
movsd  %xmm2,-0xd0(%rbp)
ff
movaps %xmm0,%xmm1
subsd  %xmm2,%xmm1
cvttsd2si %xmm1,%rax
cvttsd2si %xmm0,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
and    %rcx,%rax
or     %rax,%rdi
call   1070 <cos@plt>
movsd  -0xd0(%rbp),%xmm2
ff
mov    -0xc0(%rbp),%rcx
mov    -0x10(%rbp),%rax
shl    $0x4,%rax
movsd  %xmm0,-0x10(%rax,%rcx,1)
mov    -0xc0(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
movaps %xmm0,%xmm1
subsd  %xmm2,%xmm1
cvttsd2si %xmm1,%rax
cvttsd2si %xmm0,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
and    %rcx,%rax
or     %rax,%rdi
call   1050 <sin@plt>
mov    -0xc0(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0xc0(%rbp),%rax
movsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
shr    $0x1,%rcx
cmp    %rcx,%rax
ja     1ac1 <radfg+0x971>
movq   -0x50(%rbp),%xmm0
movaps 0x16a7(%rip),%xmm1
movaps %xmm1,-0x100(%rbp)
punpckldq %xmm1,%xmm0
movapd 0x16a4(%rip),%xmm1
movaps %xmm1,-0xf0(%rbp)
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
movsd  0x1683(%rip),%xmm1
movsd  %xmm1,-0xd8(%rbp)
ff
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1070 <cos@plt>
movaps -0x100(%rbp),%xmm3
movaps -0xf0(%rbp),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mov    -0xc0(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    %rcx,%rcx
mov    -0x50(%rbp),%rdx
add    %rdx,%rdx
sub    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x4,%rcx
movsd  %xmm0,(%rax,%rcx,1)
movq   -0x50(%rbp),%xmm0
punpckldq %xmm3,%xmm0
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm2
unpckhpd %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
movaps %xmm0,%xmm2
cvttsd2si %xmm2,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1050 <sin@plt>
mov    -0xc0(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x50(%rbp),%rdx
shl    $0x1,%rdx
sub    %rdx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1938 <radfg+0x7e8>
movq   $0x1,-0x68(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1dc4 <radfg+0xc74>
mov    -0xc0(%rbp),%rax
mov    -0x68(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xc0(%rbp),%rax
mov    -0x68(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1bfb <radfg+0xaab>
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
imul   $0x0,-0x20(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
shl    $0x0,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rsi
sub    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x88(%rbp),%rdx
ff
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    1b2a <radfg+0x9da>
mov    -0x68(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xc8(%rbp)
movq   $0x2,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1d9c <radfg+0xc4c>
mov    -0x68(%rbp),%rax
shl    $0x1,%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jb     1c73 <radfg+0xb23>
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0xc8(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1d7a <radfg+0xc2a>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x80(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x88(%rbp),%rdx
ff
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    1cb5 <radfg+0xb65>
jmp    1d7f <radfg+0xc2f>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    1c1e <radfg+0xace>
jmp    1da1 <radfg+0xc51>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x88(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
jmp    1ad8 <radfg+0x988>
jmp    1dc9 <radfg+0xc79>
mov    -0xc0(%rbp),%rdi
call   1030 <util_free_@plt>
movq   $0x0,-0xc0(%rbp)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1e78 <radfg+0xd28>
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1e62 <radfg+0xd12>
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
imul   $0x0,-0x20(%rbp),%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    1e01 <radfg+0xcb1>
jmp    1e67 <radfg+0xd17>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1de8 <radfg+0xc98>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1ef3 <radfg+0xda3>
mov    -0x28(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x60(%rbp),%rcx
add    $0x0,%rcx
imul   %rcx,%rax
add    $0x0,%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
imul   $0x0,-0x18(%rbp),%rdx
add    %rdx,%rcx
imul   %rcx,%rax
add    $0x0,%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x8(%rbp),%rdx
shl    $0x3,%rdx
call   1060 <memcpy@plt>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1e80 <radfg+0xd30>
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1ffd <radfg+0xead>
mov    -0x10(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1fe7 <radfg+0xe97>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x58(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x70(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    -0x18(%rbp),%rsi
imul   -0x80(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    -0x38(%rbp),%rsi
imul   -0x60(%rbp),%rsi
add    %rsi,%rdx
imul   %rdx,%rcx
add    $0x0,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1f29 <radfg+0xdd9>
jmp    1fec <radfg+0xe9c>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1efb <radfg+0xdab>
cmpq   $0x1,-0x8(%rbp)
jne    200d <radfg+0xebd>
jmp    22b0 <radfg+0x1160>
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    22b0 <radfg+0x1160>
mov    -0x10(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    229a <radfg+0x114a>
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    2284 <radfg+0x1134>
mov    -0x8(%rbp),%rax
sub    -0x50(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x70(%rbp),%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x70(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x70(%rbp),%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x80(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdi
imul   -0x58(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x70(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
jmp    2059 <radfg+0xf09>
jmp    2289 <radfg+0x1139>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    2043 <radfg+0xef3>
jmp    229f <radfg+0x114f>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2015 <radfg+0xec5>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radfg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r8,%rbx
mov    %rdx,%r15
lea    0x1(%rsi),%rax
mov    %rax,0x138(%rsp)
shr    %rax
mov    %rax,0xf0(%rsp)
mov    %rcx,0x20(%rsp)
lea    0x0(,%rcx,8),%rdx
cmp    $0x1,%rdi
mov    %r8,(%rsp)
mov    %r15,0xe8(%rsp)
mov    %rdi,0x30(%rsp)
mov    %r9,0x8(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rdx,0x130(%rsp)
jne    16b1 <radfg+0x561>
mov    %rbx,%rdi
mov    %r9,%rsi
call   1060 <memcpy@plt>
mov    0x50(%rsp),%r14
lea    -0x1(%r14),%r9
cmpq   $0x4,0x138(%rsp)
setae  %al
mov    %eax,0x4c(%rsp)
mov    %r9,0x100(%rsp)
jb     1ccd <radfg+0xb7d>
mov    0xf0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovae %rax,%rcx
mov    %rcx,0x88(%rsp)
mov    %r9,%rbx
imul   %r15,%rbx
mov    %r15,%rax
imul   %r14,%rax
mov    %rax,0x58(%rsp)
lea    -0x2(%r15),%rax
mov    %rax,0xb0(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
cmp    $0x1,%r15
setne  %al
mov    0x30(%rsp),%rdi
cmp    $0x1,%rdi
sete   %dl
and    %al,%dl
mov    %dl,0x68(%rsp)
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xf8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x108(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
lea    0x2(%rbx),%rax
imul   %rdi,%rax
mov    (%rsp),%rsi
lea    (%rsi,%rax,8),%rcx
mov    %rcx,0x70(%rsp)
mov    %r15,%rcx
imul   %rdi,%rcx
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0xe0(%rsp)
neg    %rdx
mov    %rdx,0x38(%rsp)
mov    %rdi,%rdx
shl    $0x5,%rdx
mov    %rdx,0x120(%rsp)
mov    0x8(%rsp),%rbp
lea    0x0(,%rax,8),%r14
add    %rbp,%r14
lea    0x2(%r15),%rdx
imul   %rdi,%rdx
lea    (%rsi,%rdx,8),%r10
lea    0x0(,%rdx,8),%r8
add    %rbp,%r8
lea    (%rsi,%rcx,8),%rax
lea    0x0(,%rcx,8),%r11
add    %rbp,%r11
imul   %r9,%rcx
lea    (%rsi,%rcx,8),%rdx
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%r15,%r15,1),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(,%rdi,8),%r12
mov    $0x1,%ecx
mov    %rcx,0x28(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
mov    %rbx,0xc0(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r15,0xa8(%rsp)
mov    %r9,0x98(%rsp)
mov    %rdx,%r9
jmp    13a2 <radfg+0x252>
nop
mov    0x28(%rsp),%rsi
add    $0x1,%rsi
addq   $0xffffffffffffffff,0x98(%rsp)
addq   $0x1,0xa0(%rsp)
mov    0x38(%rsp),%rdx
add    %rdx,0x70(%rsp)
add    %rdx,%r14
mov    0xe0(%rsp),%rcx
add    %rcx,%r10
add    %rcx,%r8
add    %rdx,%r9
add    %rdx,%rbp
add    %rcx,%rax
add    %rcx,%r11
add    %r15,0xa8(%rsp)
sub    %r15,0x18(%rsp)
mov    %rsi,0x28(%rsp)
cmp    0x88(%rsp),%rsi
je     1b73 <radfg+0xa23>
test   %r15,%r15
je     1340 <radfg+0x1f0>
cmpb   $0x0,0x68(%rsp)
je     1500 <radfg+0x3b0>
mov    0xa0(%rsp),%rcx
imul   %r15,%rcx
lea    (%rcx,%r15,1),%rsi
mov    %rsi,0xd8(%rsp)
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rcx,1),%r15
mov    %r15,0x40(%rsp)
mov    0xc0(%rsp),%rdi
sub    %rcx,%rdi
mov    0x58(%rsp),%rbx
sub    %rcx,%rbx
mov    (%rsp),%rdx
lea    (%rdx,%rsi,8),%rcx
lea    (%rdx,%r15,8),%rsi
lea    (%rdx,%rdi,8),%r15
lea    (%rdx,%rbx,8),%r13
mov    0x8(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdi
mov    %rdi,0x118(%rsp)
lea    (%rdx,%rbx,8),%rdi
mov    %rdi,0x110(%rsp)
mov    0x40(%rsp),%rbx
lea    (%rdx,%rbx,8),%rbx
cmp    %r13,%rcx
setb   0x40(%rsp)
cmp    %rsi,%r15
setb   0x90(%rsp)
cmp    %rdi,%rcx
setb   0xd0(%rsp)
mov    0x118(%rsp),%rdi
cmp    %rsi,%rdi
setb   0x60(%rsp)
cmp    %rbx,%rcx
mov    0xd8(%rsp),%rcx
lea    (%rdx,%rcx,8),%rcx
setb   0xd8(%rsp)
cmp    %rsi,%rcx
setb   0xc8(%rsp)
cmp    0x110(%rsp),%r15
setb   %sil
cmp    %r13,%rdi
setb   %dil
cmp    %rbx,%r15
setb   %dl
cmp    %r13,%rcx
setb   %cl
mov    0x90(%rsp),%bl
test   %bl,0x40(%rsp)
jne    16a2 <radfg+0x552>
mov    0x60(%rsp),%bl
and    %bl,0xd0(%rsp)
mov    0xe8(%rsp),%r15
jne    1500 <radfg+0x3b0>
mov    0xc8(%rsp),%bl
and    %bl,0xd8(%rsp)
jne    1500 <radfg+0x3b0>
and    %dil,%sil
jne    1500 <radfg+0x3b0>
mov    $0x0,%edi
and    %cl,%dl
jne    1502 <radfg+0x3b2>
cmpq   $0x2,0xb0(%rsp)
jae    15a0 <radfg+0x450>
xor    %edx,%edx
jmp    1628 <radfg+0x4d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
mov    %r15,%rcx
sub    %rdi,%rcx
mov    0xa8(%rsp),%rdx
lea    (%rdi,%rdx,1),%rsi
mov    %r10,0x40(%rsp)
mov    0x30(%rsp),%r10
imul   %r10,%rsi
mov    (%rsp),%rbx
lea    (%rbx,%rsi,8),%rdx
mov    %rax,0x90(%rsp)
mov    %r9,%rax
mov    0x8(%rsp),%r9
lea    (%r9,%rsi,8),%r13
add    0x18(%rsp),%rdi
imul   %r10,%rdi
mov    0x40(%rsp),%r10
lea    (%rbx,%rdi,8),%rsi
lea    (%r9,%rdi,8),%rdi
mov    %rax,%r9
mov    0x90(%rsp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,1),%xmm0
addsd  0x0(%r13,%rbx,1),%xmm0
movsd  %xmm0,(%rdx,%rbx,1)
movsd  (%rdi,%rbx,1),%xmm0
subsd  0x0(%r13,%rbx,1),%xmm0
movsd  %xmm0,(%rsi,%rbx,1)
add    %r12,%rbx
add    $0xffffffffffffffff,%rcx
jne    1570 <radfg+0x420>
jmp    1340 <radfg+0x1f0>
mov    0x128(%rsp),%rcx
xor    %edi,%edi
xor    %edx,%edx
mov    0x120(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x0(%rbp,%rdi,1),%xmm0
movupd (%r11,%rdi,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rdi,1)
movupd 0x0(%rbp,%rdi,1),%xmm0
movupd (%r11,%rdi,1),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%r9,%rdi,1)
movupd (%r14,%rdi,1),%xmm0
movupd (%r8,%rdi,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r10,%rdi,1)
movupd (%r14,%rdi,1),%xmm0
movupd (%r8,%rdi,1),%xmm1
subpd  %xmm1,%xmm0
mov    0x70(%rsp),%rbx
movupd %xmm0,(%rbx,%rdi,1)
add    $0x4,%rdx
add    %rsi,%rdi
add    $0xfffffffffffffffe,%rcx
jne    15c0 <radfg+0x470>
testb  $0x1,0x108(%rsp)
01
je     1689 <radfg+0x539>
mov    0x98(%rsp),%rcx
imul   %r15,%rcx
mov    0x28(%rsp),%rsi
imul   %r15,%rsi
add    %rdx,%rcx
mov    0x30(%rsp),%rdi
imul   %rdi,%rcx
mov    0x8(%rsp),%rbx
movupd (%rbx,%rcx,8),%xmm0
add    %rdx,%rsi
imul   %rdi,%rsi
movupd (%rbx,%rsi,8),%xmm1
addpd  %xmm0,%xmm1
mov    (%rsp),%rdx
movupd %xmm1,(%rdx,%rsi,8)
movupd (%rbx,%rcx,8),%xmm0
movupd (%rbx,%rsi,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%rdx,%rcx,8)
mov    0xf8(%rsp),%rcx
mov    %rcx,%rdi
cmp    %r15,%rcx
je     1340 <radfg+0x1f0>
jmp    1502 <radfg+0x3b2>
xor    %edi,%edi
mov    0xe8(%rsp),%r15
jmp    1502 <radfg+0x3b2>
mov    %rsi,%r14
mov    %rdi,%rbp
mov    %r9,%rdi
mov    %rbx,%rsi
call   1060 <memcpy@plt>
cmp    $0x2,%r14
jb     1cbc <radfg+0xb6c>
mov    0x1b0(%rsp),%r8
lea    -0x3(%rbp),%rax
mov    %rax,%rsi
shr    %rsi
mov    %r15,%rdi
imul   %rbp,%rdi
lea    0x1(%rdi),%rcx
mov    %rcx,0x108(%rsp)
lea    0x2(%rdi),%rcx
mov    %rcx,0x100(%rsp)
mov    %rax,0x28(%rsp)
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rax,1),%rcx
add    $0x3,%rcx
mov    %rcx,0x128(%rsp)
add    $0x2,%rax
mov    %rax,0xf8(%rsp)
lea    0x1(%rsi),%rcx
mov    $0x10,%edx
mov    %rsi,%rax
mul    %rdx
mov    %rax,0x98(%rsp)
seto   0x40(%rsp)
mov    %rcx,0x58(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x68(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    %rax,0x120(%rsp)
lea    (%rsi,%rsi,1),%rax
add    $0x2,%rax
or     $0x2,%rax
mov    %rax,0xb8(%rsp)
mov    0x8(%rsp),%rdx
lea    (%rdx,%rdi,8),%rax
add    $0x8,%rax
mov    %rax,0x118(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rax,0xc0(%rsp)
lea    0x0(,%rbp,8),%r9
lea    0x8(%rbx,%rdi,8),%rax
mov    %rax,0x110(%rsp)
lea    (%rbx,%rdi,8),%rax
mov    %rax,0xd0(%rsp)
mov    %rdi,0xb0(%rsp)
lea    (%rdx,%rdi,8),%rax
mov    %rax,0x60(%rsp)
mov    $0x1,%eax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0xc8(%rsp)
mov    %r8,%rdi
jmp    182a <radfg+0x6da>
nopl   0x0(%rax)
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0xc8(%rsp)
mov    0xc0(%rsp),%rax
add    %rax,0x118(%rsp)
add    %rax,0x110(%rsp)
add    %r9,%rdi
add    %rax,0xd0(%rsp)
add    %rax,0x60(%rsp)
mov    %rcx,0x38(%rsp)
cmp    0x50(%rsp),%rcx
je     1b7d <radfg+0xa2d>
test   %r15,%r15
je     17e0 <radfg+0x690>
mov    0xb0(%rsp),%rsi
mov    0xc8(%rsp),%rcx
imul   %rcx,%rsi
mov    0x108(%rsp),%rax
add    %rsi,%rax
mov    %rax,0xa0(%rsp)
mov    0x128(%rsp),%rax
add    %rsi,%rax
mov    %rax,0x90(%rsp)
mov    %rcx,%rax
imul   %rbp,%rax
mov    0xf8(%rsp),%rcx
add    %rax,%rcx
add    0x100(%rsp),%rsi
mov    %rsi,0xa8(%rsp)
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
mov    %rax,0x88(%rsp)
lea    (%rsi,%rcx,8),%rax
mov    %rax,0xe0(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,%rsi
imul   %r15,%rsi
lea    -0x1(%rax),%rcx
imul   %rbp,%rcx
mov    0x120(%rsp),%rax
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,0xd8(%rsp)
add    $0x1,%rcx
mov    %rcx,0x70(%rsp)
mov    0x60(%rsp),%r8
mov    0xd0(%rsp),%r11
mov    0x110(%rsp),%r13
mov    0x118(%rsp),%r10
xor    %r14d,%r14d
mov    %rsi,0x18(%rsp)
jmp    1929 <radfg+0x7d9>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r9,%r10
add    %r9,%r13
add    %r9,%r11
add    %r9,%r8
cmp    %r15,%r14
je     17e0 <radfg+0x690>
lea    (%r14,%rsi,1),%rax
imul   %rbp,%rax
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
cmp    $0x3,%rbp
jb     1910 <radfg+0x7c0>
mov    $0x2,%r12d
cmpq   $0x2,0x28(%rsp)
jae    1960 <radfg+0x810>
mov    0x70(%rsp),%rcx
jmp    1b11 <radfg+0x9c1>
nopl   0x0(%rax)
mov    %r14,%rsi
imul   %rbp,%rsi
mov    0xa0(%rsp),%rax
add    %rsi,%rax
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rsi,1),%rbx
lea    (%rdx,%rax,8),%rcx
lea    (%rdx,%rbx,8),%rbx
mov    0x98(%rsp),%rbp
lea    (%rcx,%rbp,1),%rdx
cmp    %rcx,%rdx
setb   %dl
mov    0x40(%rsp),%r15b
or     %r15b,%dl
add    %rbx,%rbp
cmp    %rbx,%rbp
setb   %bl
test   %dl,%dl
jne    1ad5 <radfg+0x985>
or     %r15b,%bl
mov    (%rsp),%rbx
jne    1ae0 <radfg+0x990>
add    0x90(%rsp),%rsi
mov    0x8(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
lea    (%rbx,%rax,8),%rbp
lea    (%rbx,%rsi,8),%rax
cmp    0xe0(%rsp),%rcx
setb   %sil
cmp    %rdx,0x88(%rsp)
setb   %bl
cmp    %rax,%rcx
setb   %al
cmp    %rdx,%rbp
setb   %dl
test   %bl,%sil
mov    0xe8(%rsp),%r15
jne    1af9 <radfg+0x9a9>
mov    0x70(%rsp),%rcx
and    %dl,%al
mov    (%rsp),%rbx
mov    0x30(%rsp),%rbp
mov    0x8(%rsp),%rdx
mov    0x18(%rsp),%rsi
jne    1b11 <radfg+0x9c1>
mov    0x68(%rsp),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdi,%rsi,1),%xmm0
movupd 0x10(%rdi,%rsi,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movupd 0x0(%r13,%rsi,1),%xmm3
movupd 0x10(%r13,%rsi,1),%xmm4
movapd %xmm3,%xmm5
unpcklpd %xmm4,%xmm5
unpckhpd %xmm1,%xmm0
unpckhpd %xmm4,%xmm3
movapd %xmm0,%xmm1
mulpd  %xmm3,%xmm1
mulpd  %xmm2,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm5,%xmm0
subpd  %xmm0,%xmm3
movapd %xmm2,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm2,%xmm3
movups %xmm3,0x10(%r10,%rsi,1)
movupd %xmm0,(%r10,%rsi,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1a40 <radfg+0x8f0>
mov    0xd8(%rsp),%rcx
mov    0xb8(%rsp),%r12
mov    0x68(%rsp),%rax
cmp    %rax,0x58(%rsp)
mov    0x18(%rsp),%rsi
je     1910 <radfg+0x7c0>
jmp    1b11 <radfg+0x9c1>
mov    0x70(%rsp),%rcx
mov    (%rsp),%rbx
jmp    1ae5 <radfg+0x995>
mov    0x70(%rsp),%rcx
mov    0x30(%rsp),%rbp
mov    0x8(%rsp),%rdx
mov    0xe8(%rsp),%r15
jmp    1b0c <radfg+0x9bc>
mov    0x70(%rsp),%rcx
mov    (%rsp),%rbx
mov    0x30(%rsp),%rbp
mov    0x8(%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x1b0(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
nopl   (%rax)
movsd  (%rcx),%xmm0
mulsd  (%r11,%r12,8),%xmm0
movsd  -0x8(%rcx),%xmm1
mulsd  -0x8(%r11,%r12,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r8,%r12,8)
movsd  -0x8(%r11,%r12,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  -0x8(%rcx),%xmm1
mulsd  (%r11,%r12,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%r12,8)
add    $0x2,%r12
add    $0x10,%rcx
cmp    %rbp,%r12
jb     1b20 <radfg+0x9d0>
jmp    1910 <radfg+0x7c0>
mov    0x50(%rsp),%r14
jmp    1cd5 <radfg+0xb85>
cmpq   $0x4,0x138(%rsp)
jb     1cbc <radfg+0xb6c>
mov    0xf0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovae %rax,%rcx
mov    %rcx,0x70(%rsp)
mov    0xb0(%rsp),%rdx
lea    (%rbx,%rdx,8),%r10
mov    0x8(%rsp),%rcx
lea    (%rcx,%rdx,8),%r11
mov    0x50(%rsp),%rax
add    $0xffffffffffffffff,%rax
imul   %rdx,%rax
lea    (%rcx,%rax,8),%r14
mov    0xc0(%rsp),%r13
neg    %r13
lea    (%rbx,%rax,8),%rbp
mov    $0x1,%r12d
mov    0x30(%rsp),%rbx
jmp    1c13 <radfg+0xac3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0xc0(%rsp),%rax
add    %rax,%r10
add    %rax,%r11
add    %r13,%r14
add    %r13,%rbp
cmp    0x70(%rsp),%r12
je     11c3 <radfg+0x73>
test   %r15,%r15
je     1bf0 <radfg+0xaa0>
mov    %rbp,%rax
mov    %r14,%rdi
mov    %r11,%rsi
mov    %r10,%rcx
xor    %edx,%edx
jmp    1c45 <radfg+0xaf5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %r9,%rcx
add    %r9,%rsi
add    %r9,%rdi
add    %r9,%rax
cmp    %r15,%rdx
je     1bf0 <radfg+0xaa0>
cmp    $0x3,%rbx
jb     1c30 <radfg+0xae0>
mov    $0x2,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%r8,8),%xmm0
addsd  -0x8(%rsi,%r8,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%r8,8)
movsd  -0x8(%rdi,%r8,8),%xmm0
subsd  -0x8(%rsi,%r8,8),%xmm0
movsd  %xmm0,(%rax,%r8,8)
movsd  (%rsi,%r8,8),%xmm0
addsd  (%rdi,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%r8,8)
movsd  (%rsi,%r8,8),%xmm0
subsd  (%rdi,%r8,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r8,8)
add    $0x2,%r8
cmp    %rbx,%r8
jb     1c60 <radfg+0xb10>
jmp    1c30 <radfg+0xae0>
mov    0x50(%rsp),%r14
lea    -0x1(%r14),%rax
mov    %rax,0x100(%rsp)
movl   $0x0,0x4c(%rsp)
lea    (%r14,%r14,1),%rax
mov    %rax,0x38(%rsp)
mov    %r14d,%edi
shl    $0x4,%edi
call   1040 <util_malloc_@plt>
movq   %r14,%xmm0
punpckldq 0x130a(%rip),%xmm0
subpd  0x1312(%rip),%xmm0
mov    %rax,%rbp
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0x131b(%rip),%xmm2
divsd  %xmm1,%xmm2
movsd  0x1317(%rip),%xmm0
cvttsd2si %xmm2,%rax
movups %xmm0,0x0(%rbp)
mov    %rax,%rcx
sar    $0x3f,%rcx
movapd %xmm2,0x70(%rsp)
movapd %xmm2,%xmm0
subsd  0x12fd(%rip),%xmm0
cvttsd2si %xmm0,%r12
and    %rcx,%r12
or     %rax,%r12
mov    %r12,%rdi
call   1070 <cos@plt>
mov    %r14,%rbx
shl    $0x4,%rbx
movsd  %xmm0,-0x10(%rbx,%rbp,1)
movsd  %xmm0,0x10(%rbp)
mov    %r12,%rdi
call   1050 <sin@plt>
movsd  %xmm0,0x18(%rbp)
xorpd  0x12a3(%rip),%xmm0
mov    %rbp,0x28(%rsp)
movlpd %xmm0,-0x8(%rbx,%rbp,1)
cmp    $0x4,%r14
jb     1e53 <radfg+0xd03>
mov    0x50(%rsp),%rax
shr    %rax
mov    $0x1,%ebx
sub    %rax,%rbx
mov    0x28(%rsp),%rcx
lea    0x28(%rcx),%r14
mov    0x38(%rsp),%rax
lea    (%rcx,%rax,8),%r13
add    $0xffffffffffffffe8,%r13
mov    $0x2,%ebp
nopl   (%rax)
movq   %rbp,%xmm0
punpckldq 0x1233(%rip),%xmm0
subpd  0x123b(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  0x70(%rsp),%xmm1
cvttsd2si %xmm1,%rax
mov    %rax,%rcx
sar    $0x3f,%rcx
subsd  0x1245(%rip),%xmm1
cvttsd2si %xmm1,%r12
and    %rcx,%r12
or     %rax,%r12
mov    %r12,%rdi
call   1070 <cos@plt>
movsd  %xmm0,-0x8(%r13)
movsd  %xmm0,-0x8(%r14)
mov    %r12,%rdi
call   1050 <sin@plt>
movsd  %xmm0,(%r14)
xorpd  0x11f1(%rip),%xmm0
movlpd %xmm0,0x0(%r13)
lea    (%rbx,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
add    $0x10,%r14
add    $0xfffffffffffffff0,%r13
cmp    $0x2,%rax
jne    1dc0 <radfg+0xc70>
cmpb   $0x0,0x4c(%rsp)
mov    0x20(%rsp),%rbx
je     269b <radfg+0x154b>
mov    0x100(%rsp),%rdx
mov    %rdx,%rdi
imul   %rbx,%rdi
mov    0x50(%rsp),%rax
lea    -0x2(%rax),%rbp
mov    0xf0(%rsp),%rcx
cmp    $0x4,%rcx
mov    $0x3,%r13d
cmovae %rcx,%r13
cmp    $0x3,%rcx
mov    $0x2,%esi
cmovae %rcx,%rsi
mov    %rsi,0x128(%rsp)
lea    (%rbx,%rbx,1),%rcx
mov    %rcx,0x90(%rsp)
lea    0x8(,%rdx,8),%rdx
imul   %rbx,%rdx
lea    (%rbx,%rbx,2),%rcx
mov    %rcx,0x118(%rsp)
imul   %rbx,%rbp
lea    -0x8(,%rax,8),%rax
ff
imul   %rbx,%rax
mov    %rax,0x110(%rsp)
mov    (%rsp),%rax
lea    (%rax,%rbx,8),%rcx
mov    %rcx,0x58(%rsp)
mov    %rbx,%rcx
shl    $0x4,%rcx
add    %rax,%rcx
mov    %rcx,0x148(%rsp)
lea    -0x2(%rbx),%rcx
mov    %rcx,0x160(%rsp)
mov    %rcx,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %rbx,%r8
and    $0xfffffffffffffffe,%r8
mov    %rsi,%rcx
mov    %rsi,0x158(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x150(%rsp)
mov    0x130(%rsp),%r11
mov    %r11,%r12
neg    %r12
lea    (%rax,%rdi,8),%rcx
mov    %rcx,0x140(%rsp)
mov    %rdx,0x120(%rsp)
lea    (%rax,%rdx,1),%rcx
mov    %rcx,0x168(%rsp)
mov    0x8(%rsp),%rcx
lea    0x10(%rcx,%rbx,8),%rdx
lea    0x10(%rcx,%rdi,8),%rsi
mov    %rsi,0xf8(%rsp)
lea    (%rcx,%rbx,8),%rsi
mov    %rbp,0xd8(%rsp)
lea    (%rax,%rbp,8),%rax
mov    %rax,0x170(%rsp)
lea    (%rcx,%rdi,8),%rcx
mov    $0x1,%eax
mov    %rax,0x60(%rsp)
xor    %ebp,%ebp
mov    %rbx,0xb0(%rsp)
mov    %rdi,0xb8(%rsp)
mov    %rdi,0x108(%rsp)
mov    0x38(%rsp),%r14
mov    %r13,0x68(%rsp)
mov    %r8,0xd0(%rsp)
mov    %r12,0x88(%rsp)
jmp    203d <radfg+0xeed>
cs nopw 0x0(%rax,%rax,1)
mov    0x60(%rsp),%rdi
add    $0x1,%rdi
addq   $0xffffffffffffffff,0x100(%rsp)
mov    0xc0(%rsp),%rbp
add    $0x1,%rbp
mov    0xc8(%rsp),%rdx
add    %r11,%rdx
add    %r12,0xf8(%rsp)
sub    %rbx,0x108(%rsp)
add    %rbx,0xb0(%rsp)
add    %r11,%rsi
add    %r12,%rcx
mov    %rdi,%rax
mov    %rdi,0x60(%rsp)
cmp    0x128(%rsp),%rdi
je     26aa <radfg+0x155a>
mov    %rdx,0xc8(%rsp)
mov    %rbp,0xc0(%rsp)
mov    %rbp,%rax
imul   %rbx,%rax
lea    (%rax,%rbx,1),%r8
mov    0x90(%rsp),%rdx
lea    (%rdx,%rax,1),%r9
mov    0xb8(%rsp),%rbp
sub    %rax,%rbp
shl    $0x3,%rax
mov    %rbx,%rdx
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
sub    %rax,%rdi
add    0x120(%rsp),%rdi
mov    %rdi,0xa8(%rsp)
lea    (%rbx,%r8,8),%rax
mov    %rax,0xa0(%rsp)
lea    (%rbx,%r9,8),%rax
mov    %rax,0x98(%rsp)
lea    (%rbx,%rbp,8),%rax
mov    %rax,0x40(%rsp)
test   %rdx,%rdx
je     216c <radfg+0x101c>
mov    0x60(%rsp),%rax
shl    $0x4,%rax
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rax,1),%xmm0
movsd  0x8(%rdx,%rax,1),%xmm1
cmpq   $0x1,0x20(%rsp)
jne    2430 <radfg+0x12e0>
xor    %r9d,%r9d
mov    0x20(%rsp),%rbx
mov    %rbx,%r12
sub    %r9,%r12
mov    0x108(%rsp),%rax
add    %r9,%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%r10
mov    0xb8(%rsp),%rax
add    %r9,%rax
mov    (%rsp),%rdi
lea    (%rdi,%rax,8),%rbp
mov    0xb0(%rsp),%rax
add    %r9,%rax
lea    (%rdx,%rax,8),%rax
lea    (%rbx,%r9,1),%rdx
lea    (%rdi,%rdx,8),%rbx
lea    (%rdi,%r9,8),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdi,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r10,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    2140 <radfg+0xff0>
cmpq   $0x6,0x138(%rsp)
mov    0x20(%rsp),%rbx
mov    0x88(%rsp),%r12
jb     1fe0 <radfg+0xe90>
mov    0x60(%rsp),%rax
lea    (%rax,%rax,1),%rbp
mov    0xa0(%rsp),%rax
cmp    %rax,0xa8(%rsp)
seta   %al
mov    0x40(%rsp),%rdx
cmp    0x98(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0xe0(%rsp)
mov    $0x2,%r9d
mov    0x170(%rsp),%rdx
mov    0x148(%rsp),%rdi
xor    %r10d,%r10d
mov    %rbp,0x70(%rsp)
mov    %rbp,%rax
jmp    21f7 <radfg+0x10a7>
add    $0x1,%r9
add    $0x1,%r10
add    %r11,%rdi
add    %r12,%rdx
cmp    %r13,%r9
je     1fe0 <radfg+0xe90>
add    0x70(%rsp),%rax
cmp    %r14,%rax
mov    $0x0,%ebp
cmovae %r14,%rbp
sub    %rbp,%rax
test   %rbx,%rbx
je     21e0 <radfg+0x1090>
mov    0x28(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x8(%rbp,%rax,8),%xmm1
cmp    $0x1,%rbx
jne    2230 <radfg+0x10e0>
xor    %ebp,%ebp
jmp    23f0 <radfg+0x12a0>
xchg   %ax,%ax
mov    %r10,%rbp
imul   %rbx,%rbp
mov    0x90(%rsp),%rbx
lea    (%rbx,%rbp,1),%r11
mov    0x118(%rsp),%rbx
lea    (%rbx,%rbp,1),%r8
mov    0xd8(%rsp),%r14
sub    %rbp,%r14
shl    $0x3,%rbp
mov    (%rsp),%r15
mov    %r15,%rbx
sub    %rbp,%rbx
add    0x110(%rsp),%rbx
lea    (%r15,%r11,8),%r12
lea    (%r15,%r8,8),%rbp
mov    0xa0(%rsp),%r11
cmp    %rbp,%r11
setb   0x18(%rsp)
mov    0x98(%rsp),%r8
cmp    %r8,%r12
setb   %r13b
and    0x18(%rsp),%r13b
or     0xe0(%rsp),%r13b
cmp    %r11,%rbx
seta   %r11b
lea    (%r15,%r14,8),%r14
cmp    %r8,%r14
setb   0x18(%rsp)
mov    0x40(%rsp),%r15
cmp    %rbp,%r15
setb   %r8b
mov    0xa8(%rsp),%rbp
cmp    %r12,%rbp
seta   %r12b
cmp    %r15,%rbx
seta   %bl
cmp    %r14,%rbp
seta   %bpl
test   %r13b,%r13b
jne    23a5 <radfg+0x1255>
and    0x18(%rsp),%r11b
mov    0xe8(%rsp),%r15
mov    0x38(%rsp),%r14
mov    0x68(%rsp),%r13
jne    23d0 <radfg+0x1280>
and    %r12b,%r8b
mov    0x130(%rsp),%r11
jne    2394 <radfg+0x1244>
mov    %ebp,%r8d
mov    $0x0,%ebp
and    %r8b,%bl
mov    0x20(%rsp),%rbx
mov    0xd0(%rsp),%r8
mov    0x88(%rsp),%r12
jne    23f0 <radfg+0x12a0>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
xor    %ebp,%ebp
xchg   %ax,%ax
movupd (%rdi,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
movupd (%rsi,%rbp,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rsi,%rbp,8)
movupd (%rdx,%rbp,8),%xmm4
mulpd  %xmm3,%xmm4
movupd (%rcx,%rbp,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r8
jne    2350 <radfg+0x1200>
mov    %r8,%rbp
cmp    %rbx,%r8
jne    23f0 <radfg+0x12a0>
jmp    21e0 <radfg+0x1090>
xor    %ebp,%ebp
mov    0x20(%rsp),%rbx
mov    0x88(%rsp),%r12
jmp    23f0 <radfg+0x12a0>
xor    %ebp,%ebp
mov    0xe8(%rsp),%r15
mov    0x20(%rsp),%rbx
mov    0x130(%rsp),%r11
mov    0x38(%rsp),%r14
mov    0x68(%rsp),%r13
mov    0x88(%rsp),%r12
jmp    23f0 <radfg+0x12a0>
xor    %ebp,%ebp
mov    0x20(%rsp),%rbx
mov    0x130(%rsp),%r11
mov    0x88(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rsi,%rbp,8),%xmm2
movsd  %xmm2,(%rsi,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    23f0 <radfg+0x12a0>
jmp    21e0 <radfg+0x1090>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%r13
mov    0xa0(%rsp),%rdx
cmp    %rdx,%r13
seta   0x70(%rsp)
mov    0x98(%rsp),%r9
mov    0x40(%rsp),%r10
cmp    %r9,%r10
setb   %r14b
mov    0x58(%rsp),%rbx
cmp    %rbx,%rdx
setb   %al
mov    (%rsp),%rdi
cmp    %rdi,%r9
seta   0x18(%rsp)
mov    0x148(%rsp),%rbp
cmp    %rbp,%rdx
setb   0xe0(%rsp)
cmp    %r9,%rbx
setb   0x17(%rsp)
mov    0x168(%rsp),%r8
cmp    %rdx,%r8
seta   %dl
mov    0x140(%rsp),%r12
cmp    %r9,%r12
setb   0x16(%rsp)
cmp    %rbx,%r10
setb   %r9b
cmp    %rdi,%r13
seta   0x15(%rsp)
cmp    %rbp,%r10
setb   %bpl
cmp    %rbx,%r13
seta   0x14(%rsp)
cmp    %r10,%r8
seta   %dil
cmp    %r12,%r13
seta   %bl
test   %r14b,0x70(%rsp)
jne    2684 <radfg+0x1534>
and    0x18(%rsp),%al
mov    0x38(%rsp),%r14
jne    268e <radfg+0x153e>
mov    0x17(%rsp),%al
and    %al,0xe0(%rsp)
mov    0x68(%rsp),%r13
jne    20e0 <radfg+0xf90>
and    0x16(%rsp),%dl
jne    20e0 <radfg+0xf90>
and    0x15(%rsp),%r9b
jne    20e0 <radfg+0xf90>
and    0x14(%rsp),%bpl
jne    20e0 <radfg+0xf90>
mov    $0x0,%r9d
and    %bl,%dil
jne    20e3 <radfg+0xf93>
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x2,0x160(%rsp)
mov    0xc8(%rsp),%r8
jae    2569 <radfg+0x1419>
xor    %eax,%eax
mov    (%rsp),%r9
mov    0x20(%rsp),%r10
jmp    25fe <radfg+0x14ae>
mov    0x150(%rsp),%rdx
xor    %eax,%eax
mov    (%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x58(%rsp),%rdi
mov    0x140(%rsp),%rbx
mov    0xf8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r9,%rax,8),%xmm4
movupd (%rdi,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,-0x10(%r8,%rax,8)
movupd (%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
movupd %xmm4,-0x10(%rbp,%rax,8)
movupd 0x10(%r9,%rax,8),%xmm4
movupd 0x10(%rdi,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r8,%rax,8)
movupd 0x10(%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
movupd %xmm4,0x0(%rbp,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rdx
jne    25a0 <radfg+0x1450>
testb  $0x1,0x158(%rsp)
01
mov    0xd0(%rsp),%r8
je     2673 <radfg+0x1523>
mov    0x60(%rsp),%rdx
imul   %r10,%rdx
mov    0x100(%rsp),%rdi
imul   %r10,%rdi
movupd (%r9,%rax,8),%xmm4
lea    (%rax,%r10,1),%rbp
mov    (%rsp),%rbx
movupd (%rbx,%rbp,8),%xmm5
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
add    %rax,%rdx
mov    0x8(%rsp),%rbx
movupd %xmm3,(%rbx,%rdx,8)
mov    0xb8(%rsp),%rdx
add    %rax,%rdx
mov    (%rsp),%rbp
movupd 0x0(%rbp,%rdx,8),%xmm3
mulpd  %xmm3,%xmm2
add    %rax,%rdi
movupd %xmm2,(%rbx,%rdi,8)
mov    0x20(%rsp),%r10
mov    %r8,%r9
cmp    %r10,%r8
jne    20e3 <radfg+0xf93>
jmp    216c <radfg+0x101c>
xor    %r9d,%r9d
mov    0x38(%rsp),%r14
jmp    2691 <radfg+0x1541>
xor    %r9d,%r9d
mov    0x68(%rsp),%r13
jmp    20e3 <radfg+0xf93>
mov    0x28(%rsp),%rdi
call   1030 <util_free_@plt>
jmp    28f7 <radfg+0x17a7>
mov    0x28(%rsp),%rdi
call   1030 <util_free_@plt>
cmpb   $0x0,0x4c(%rsp)
je     28f7 <radfg+0x17a7>
mov    0xf0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%r12d
cmovae %rax,%r12
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,8),%r10
lea    -0x4(%rbx),%r9
mov    %r9,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %rbx,%r14
and    $0xfffffffffffffffc,%r14
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x70(%rsp)
mov    %rbx,%r13
neg    %r13
mov    (%rsp),%rax
lea    (%rax,%rbx,8),%rcx
add    $0x30,%rcx
mov    $0x1,%esi
xor    %edi,%edi
jmp    2744 <radfg+0x15f4>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x1,%rdi
mov    0x130(%rsp),%rax
add    %rax,%rcx
add    %rax,%r8
mov    %r8,0x58(%rsp)
cmp    %r12,%rsi
je     28f7 <radfg+0x17a7>
test   %rbx,%rbx
mov    0x58(%rsp),%r8
je     2720 <radfg+0x15d0>
mov    %rsi,%rdx
imul   %rbx,%rdx
cmp    $0x4,%rbx
jb     27a3 <radfg+0x1653>
mov    %rdi,%rax
imul   %rbx,%rax
mov    0x90(%rsp),%rbx
add    %rax,%rbx
mov    (%rsp),%rbp
lea    0x0(,%rbx,8),%rbx
add    %rbp,%rbx
cmp    0x8(%rsp),%rbx
mov    0x20(%rsp),%rbx
jbe    2821 <radfg+0x16d1>
add    %rbx,%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %r10,%rax
jae    2821 <radfg+0x16d1>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%bl
je     27cf <radfg+0x167f>
add    %rbp,%rdx
mov    (%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x8(%rsp),%rax
addsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    %r13,%rbp
mov    0x8(%rsp),%rdx
mov    0x58(%rsp),%r8
je     2720 <radfg+0x15d0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rax,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x8(%r8,%rax,8),%xmm0
addsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    27f0 <radfg+0x16a0>
jmp    2720 <radfg+0x15d0>
cmp    $0x4,%r9
jae    282b <radfg+0x16db>
xor    %eax,%eax
jmp    289f <radfg+0x174f>
mov    0x70(%rsp),%rbp
xor    %eax,%eax
mov    0x8(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rax,8),%xmm0
movupd -0x20(%rcx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rcx,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rbx,%rax,8)
movupd %xmm1,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    2840 <radfg+0x16f0>
test   $0x1,%r11b
je     28dc <radfg+0x178c>
lea    (%rax,%rdx,1),%rbx
mov    (%rsp),%rbp
movupd 0x0(%rbp,%rbx,8),%xmm0
movupd 0x10(%rbp,%rbx,8),%xmm1
mov    0x8(%rsp),%rbx
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    %r14,%rbp
mov    0x20(%rsp),%rbx
cmp    %rbx,%r14
mov    0x58(%rsp),%r8
je     2720 <radfg+0x15d0>
jmp    27a5 <radfg+0x1655>
test   %r15,%r15
je     294a <radfg+0x17fa>
mov    0x30(%rsp),%rax
lea    0x0(,%rax,8),%r13
mov    0x50(%rsp),%r14
imul   %rax,%r14
shl    $0x3,%r14
mov    (%rsp),%rbp
mov    0x8(%rsp),%r12
mov    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
call   1060 <memcpy@plt>
add    %r13,%r12
add    %r14,%rbp
add    $0xffffffffffffffff,%rbx
jne    2930 <radfg+0x17e0>
cmpb   $0x0,0x4c(%rsp)
je     2a12 <radfg+0x18c2>
mov    0xf0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%r8d
cmovae %rax,%r8
mov    %r15,%r10
mov    0x30(%rsp),%rcx
imul   %rcx,%r10
mov    0x50(%rsp),%rdi
lea    -0x1(%rdi),%rdx
imul   %r10,%rdx
shl    $0x3,%rdx
shl    $0x3,%r10
lea    0x0(,%rcx,8),%rsi
mov    %rcx,%r9
shl    $0x4,%r9
mov    (%rsp),%rax
lea    (%rax,%r9,1),%r11
mov    %rdi,%rax
imul   %rcx,%rax
shl    $0x3,%rax
mov    $0x1,%r14d
mov    %r10,%rcx
jmp    29d2 <radfg+0x1882>
nopl   0x0(%rax)
add    $0x1,%r14
sub    %r10,%rdx
add    %r9,%r11
add    %r10,%rcx
cmp    %r8,%r14
je     2a12 <radfg+0x18c2>
test   %r15,%r15
je     29c0 <radfg+0x1870>
mov    %r11,%rbp
mov    0x8(%rsp),%rbx
mov    %r15,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rcx,1),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  (%rbx,%rdx,1),%xmm0
movsd  %xmm0,0x0(%rbp)
add    %rsi,%rbx
add    %rax,%rbp
add    $0xffffffffffffffff,%rdi
jne    29f0 <radfg+0x18a0>
jmp    29c0 <radfg+0x1870>
cmpq   $0x1,0x30(%rsp)
mov    0x8(%rsp),%rdx
je     2b76 <radfg+0x1a26>
cmpq   $0x4,0x138(%rsp)
jb     2b76 <radfg+0x1a26>
mov    0xf0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovae %rax,%rcx
mov    %rcx,0x70(%rsp)
mov    0x30(%rsp),%rcx
mov    %rcx,%rax
shl    $0x4,%rax
mov    %rax,0x28(%rsp)
add    %rax,(%rsp)
mov    0x50(%rsp),%rsi
mov    %rsi,%r13
imul   %rcx,%r13
shl    $0x3,%r13
mov    %r15,%rax
imul   %rcx,%rax
lea    (%rdx,%rax,8),%r14
lea    0x0(,%rax,8),%r10
lea    0x0(,%rcx,8),%rbp
add    $0xffffffffffffffff,%rsi
imul   %rax,%rsi
lea    (%rdx,%rsi,8),%rbx
mov    %r10,%r11
neg    %r11
mov    $0x1,%r12d
mov    0x30(%rsp),%r9
jmp    2ace <radfg+0x197e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x28(%rsp),%rax
add    %rax,(%rsp)
add    %r10,%r14
add    %r11,%rbx
cmp    0x70(%rsp),%r12
je     2b76 <radfg+0x1a26>
test   %r15,%r15
je     2ab0 <radfg+0x1960>
mov    %rbx,%rax
mov    %r14,%rsi
mov    (%rsp),%rdi
xor    %ecx,%ecx
jmp    2b02 <radfg+0x19b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %r13,%rdi
add    %rbp,%rsi
add    %rbp,%rax
cmp    %r15,%rcx
je     2ab0 <radfg+0x1960>
cmp    $0x3,%r9
jb     2af0 <radfg+0x19a0>
mov    $0x2,%edx
mov    $0xfffffffffffffffe,%r8
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rsi,%rdx,8),%xmm0
addsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rdx,8)
movsd  -0x8(%rsi,%rdx,8),%xmm0
subsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%r8,8)
movsd  (%rax,%rdx,8),%xmm0
addsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
movsd  (%rax,%rdx,8),%xmm0
subsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%r8,8)
add    $0x2,%rdx
add    $0xfffffffffffffffe,%r8
cmp    %r9,%rdx
jb     2b20 <radfg+0x19d0>
jmp    2af0 <radfg+0x19a0>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@radfg.twopi = internal constant double 0x401921FB54442D18
define void @radfg(i64 %0, i64 %1, i64 %2, i64 %3, double* %4, double* %5, double* %6) {
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double*
%33 = alloca i64
store i64 %0, i64* %8
store i64 %1, i64* %9
store i64 %2, i64* %10
store i64 %3, i64* %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%34 = load i64, i64* %9
store i64 %34, i64* %15
%35 = load i64, i64* %9
%36 = add i64 %35, 1
%37 = udiv i64 %36, 2
store i64 %37, i64* %17
%38 = load i64, i64* %8
%39 = icmp ne i64 %38, 1
br i1 %39, label %40, label %378
40: ; preds = %7
%41 = load double*, double** %13
%42 = load double*, double** %12
%43 = load i64, i64* %11
%44 = mul i64 %43, 8
%45 = call i32 @memcpy(double* %41, double* %42, i64 %44)
store i64 1, i64* %19
br label %46
46: ; preds = %193, %40
%47 = load i64, i64* %19
%48 = load i64, i64* %9
%49 = icmp ult i64 %47, %48
br i1 %49, label %50, label %196
50: ; preds = %46
store i64 0, i64* %20
br label %51
51: ; preds = %189, %50
%52 = load i64, i64* %20
%53 = load i64, i64* %10
%54 = icmp ult i64 %52, %53
br i1 %54, label %55, label %192
55: ; preds = %51
%56 = load double*, double** %12
%57 = load i64, i64* %8
%58 = load i64, i64* %20
%59 = load i64, i64* %10
%60 = load i64, i64* %19
%61 = mul i64 %59, %60
%62 = add i64 %58, %61
%63 = mul i64 %57, %62
%64 = add i64 0, %63
%65 = getelementptr inbounds double, double* %56, i64 %64
%66 = load double, double* %65
%67 = load double*, double** %13
%68 = load i64, i64* %8
%69 = load i64, i64* %20
%70 = load i64, i64* %10
%71 = load i64, i64* %19
%72 = mul i64 %70, %71
%73 = add i64 %69, %72
%74 = mul i64 %68, %73
%75 = add i64 0, %74
%76 = getelementptr inbounds double, double* %67, i64 %75
store double %66, double* %76
%77 = load i64, i64* %19
%78 = sub i64 %77, 1
%79 = load i64, i64* %8
%80 = mul i64 %78, %79
%81 = add i64 %80, 1
store i64 %81, i64* %16
store i64 2, i64* %18
br label %82
82: ; preds = %183, %55
%83 = load i64, i64* %18
%84 = load i64, i64* %8
%85 = icmp ult i64 %83, %84
br i1 %85, label %86, label %188
86: ; preds = %82
%87 = load double*, double** %14
%88 = load i64, i64* %16
%89 = sub i64 %88, 1
%90 = getelementptr inbounds double, double* %87, i64 %89
%91 = load double, double* %90
%92 = load double*, double** %12
%93 = load i64, i64* %18
%94 = sub i64 %93, 1
%95 = load i64, i64* %8
%96 = load i64, i64* %20
%97 = load i64, i64* %10
%98 = load i64, i64* %19
%99 = mul i64 %97, %98
%100 = add i64 %96, %99
%101 = mul i64 %95, %100
%102 = add i64 %94, %101
%103 = getelementptr inbounds double, double* %92, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %14
%106 = load i64, i64* %16
%107 = getelementptr inbounds double, double* %105, i64 %106
%108 = load double, double* %107
%109 = load double*, double** %12
%110 = load i64, i64* %18
%111 = load i64, i64* %8
%112 = load i64, i64* %20
%113 = load i64, i64* %10
%114 = load i64, i64* %19
%115 = mul i64 %113, %114
%116 = add i64 %112, %115
%117 = mul i64 %111, %116
%118 = add i64 %110, %117
%119 = getelementptr inbounds double, double* %109, i64 %118
%120 = load double, double* %119
%121 = fmul double %108, %120
%122 = call double @llvm.fmuladd.f64(double %91, double %104, double %121)
%123 = load double*, double** %13
%124 = load i64, i64* %18
%125 = sub i64 %124, 1
%126 = load i64, i64* %8
%127 = load i64, i64* %20
%128 = load i64, i64* %10
%129 = load i64, i64* %19
%130 = mul i64 %128, %129
%131 = add i64 %127, %130
%132 = mul i64 %126, %131
%133 = add i64 %125, %132
%134 = getelementptr inbounds double, double* %123, i64 %133
store double %122, double* %134
%135 = load double*, double** %14
%136 = load i64, i64* %16
%137 = sub i64 %136, 1
%138 = getelementptr inbounds double, double* %135, i64 %137
%139 = load double, double* %138
%140 = load double*, double** %12
%141 = load i64, i64* %18
%142 = load i64, i64* %8
%143 = load i64, i64* %20
%144 = load i64, i64* %10
%145 = load i64, i64* %19
%146 = mul i64 %144, %145
%147 = add i64 %143, %146
%148 = mul i64 %142, %147
%149 = add i64 %141, %148
%150 = getelementptr inbounds double, double* %140, i64 %149
%151 = load double, double* %150
%152 = load double*, double** %14
%153 = load i64, i64* %16
%154 = getelementptr inbounds double, double* %152, i64 %153
%155 = load double, double* %154
%156 = load double*, double** %12
%157 = load i64, i64* %18
%158 = sub i64 %157, 1
%159 = load i64, i64* %8
%160 = load i64, i64* %20
%161 = load i64, i64* %10
%162 = load i64, i64* %19
%163 = mul i64 %161, %162
%164 = add i64 %160, %163
%165 = mul i64 %159, %164
%166 = add i64 %158, %165
%167 = getelementptr inbounds double, double* %156, i64 %166
%168 = load double, double* %167
%169 = fmul double %155, %168
%170 = fneg double %169
%171 = call double @llvm.fmuladd.f64(double %139, double %151, double %170)
%172 = load double*, double** %13
%173 = load i64, i64* %18
%174 = load i64, i64* %8
%175 = load i64, i64* %20
%176 = load i64, i64* %10
%177 = load i64, i64* %19
%178 = mul i64 %176, %177
%179 = add i64 %175, %178
%180 = mul i64 %174, %179
%181 = add i64 %173, %180
%182 = getelementptr inbounds double, double* %172, i64 %181
store double %171, double* %182
br label %183
183: ; preds = %86
%184 = load i64, i64* %18
%185 = add i64 %184, 2
store i64 %185, i64* %18
%186 = load i64, i64* %16
%187 = add i64 %186, 2
store i64 %187, i64* %16
br label %82
188: ; preds = %82
br label %189
189: ; preds = %188
%190 = load i64, i64* %20
%191 = add i64 %190, 1
store i64 %191, i64* %20
br label %51
192: ; preds = %51
br label %193
193: ; preds = %192
%194 = load i64, i64* %19
%195 = add i64 %194, 1
store i64 %195, i64* %19
br label %46
196: ; preds = %46
store i64 1, i64* %19
%197 = load i64, i64* %9
%198 = sub i64 %197, 1
store i64 %198, i64* %24
br label %199
199: ; preds = %372, %196
%200 = load i64, i64* %19
%201 = load i64, i64* %17
%202 = icmp ult i64 %200, %201
br i1 %202, label %203, label %377
203: ; preds = %199
store i64 0, i64* %20
br label %204
204: ; preds = %368, %203
%205 = load i64, i64* %20
%206 = load i64, i64* %10
%207 = icmp ult i64 %205, %206
br i1 %207, label %208, label %371
208: ; preds = %204
store i64 2, i64* %18
br label %209
209: ; preds = %364, %208
%210 = load i64, i64* %18
%211 = load i64, i64* %8
%212 = icmp ult i64 %210, %211
br i1 %212, label %213, label %367
213: ; preds = %209
%214 = load double*, double** %13
%215 = load i64, i64* %18
%216 = sub i64 %215, 1
%217 = load i64, i64* %8
%218 = load i64, i64* %20
%219 = load i64, i64* %10
%220 = load i64, i64* %24
%221 = mul i64 %219, %220
%222 = add i64 %218, %221
%223 = mul i64 %217, %222
%224 = add i64 %216, %223
%225 = getelementptr inbounds double, double* %214, i64 %224
%226 = load double, double* %225
%227 = load double*, double** %13
%228 = load i64, i64* %18
%229 = sub i64 %228, 1
%230 = load i64, i64* %8
%231 = load i64, i64* %20
%232 = load i64, i64* %10
%233 = load i64, i64* %19
%234 = mul i64 %232, %233
%235 = add i64 %231, %234
%236 = mul i64 %230, %235
%237 = add i64 %229, %236
%238 = getelementptr inbounds double, double* %227, i64 %237
%239 = load double, double* %238
%240 = fadd double %226, %239
%241 = load double*, double** %12
%242 = load i64, i64* %18
%243 = sub i64 %242, 1
%244 = load i64, i64* %8
%245 = load i64, i64* %20
%246 = load i64, i64* %10
%247 = load i64, i64* %19
%248 = mul i64 %246, %247
%249 = add i64 %245, %248
%250 = mul i64 %244, %249
%251 = add i64 %243, %250
%252 = getelementptr inbounds double, double* %241, i64 %251
store double %240, double* %252
%253 = load double*, double** %13
%254 = load i64, i64* %18
%255 = sub i64 %254, 1
%256 = load i64, i64* %8
%257 = load i64, i64* %20
%258 = load i64, i64* %10
%259 = load i64, i64* %24
%260 = mul i64 %258, %259
%261 = add i64 %257, %260
%262 = mul i64 %256, %261
%263 = add i64 %255, %262
%264 = getelementptr inbounds double, double* %253, i64 %263
%265 = load double, double* %264
%266 = load double*, double** %13
%267 = load i64, i64* %18
%268 = sub i64 %267, 1
%269 = load i64, i64* %8
%270 = load i64, i64* %20
%271 = load i64, i64* %10
%272 = load i64, i64* %19
%273 = mul i64 %271, %272
%274 = add i64 %270, %273
%275 = mul i64 %269, %274
%276 = add i64 %268, %275
%277 = getelementptr inbounds double, double* %266, i64 %276
%278 = load double, double* %277
%279 = fsub double %265, %278
%280 = load double*, double** %12
%281 = load i64, i64* %18
%282 = load i64, i64* %8
%283 = load i64, i64* %20
%284 = load i64, i64* %10
%285 = load i64, i64* %24
%286 = mul i64 %284, %285
%287 = add i64 %283, %286
%288 = mul i64 %282, %287
%289 = add i64 %281, %288
%290 = getelementptr inbounds double, double* %280, i64 %289
store double %279, double* %290
%291 = load double*, double** %13
%292 = load i64, i64* %18
%293 = load i64, i64* %8
%294 = load i64, i64* %20
%295 = load i64, i64* %10
%296 = load i64, i64* %19
%297 = mul i64 %295, %296
%298 = add i64 %294, %297
%299 = mul i64 %293, %298
%300 = add i64 %292, %299
%301 = getelementptr inbounds double, double* %291, i64 %300
%302 = load double, double* %301
%303 = load double*, double** %13
%304 = load i64, i64* %18
%305 = load i64, i64* %8
%306 = load i64, i64* %20
%307 = load i64, i64* %10
%308 = load i64, i64* %24
%309 = mul i64 %307, %308
%310 = add i64 %306, %309
%311 = mul i64 %305, %310
%312 = add i64 %304, %311
%313 = getelementptr inbounds double, double* %303, i64 %312
%314 = load double, double* %313
%315 = fadd double %302, %314
%316 = load double*, double** %12
%317 = load i64, i64* %18
%318 = load i64, i64* %8
%319 = load i64, i64* %20
%320 = load i64, i64* %10
%321 = load i64, i64* %19
%322 = mul i64 %320, %321
%323 = add i64 %319, %322
%324 = mul i64 %318, %323
%325 = add i64 %317, %324
%326 = getelementptr inbounds double, double* %316, i64 %325
store double %315, double* %326
%327 = load double*, double** %13
%328 = load i64, i64* %18
%329 = load i64, i64* %8
%330 = load i64, i64* %20
%331 = load i64, i64* %10
%332 = load i64, i64* %19
%333 = mul i64 %331, %332
%334 = add i64 %330, %333
%335 = mul i64 %329, %334
%336 = add i64 %328, %335
%337 = getelementptr inbounds double, double* %327, i64 %336
%338 = load double, double* %337
%339 = load double*, double** %13
%340 = load i64, i64* %18
%341 = load i64, i64* %8
%342 = load i64, i64* %20
%343 = load i64, i64* %10
%344 = load i64, i64* %24
%345 = mul i64 %343, %344
%346 = add i64 %342, %345
%347 = mul i64 %341, %346
%348 = add i64 %340, %347
%349 = getelementptr inbounds double, double* %339, i64 %348
%350 = load double, double* %349
%351 = fsub double %338, %350
%352 = load double*, double** %12
%353 = load i64, i64* %18
%354 = sub i64 %353, 1
%355 = load i64, i64* %8
%356 = load i64, i64* %20
%357 = load i64, i64* %10
%358 = load i64, i64* %24
%359 = mul i64 %357, %358
%360 = add i64 %356, %359
%361 = mul i64 %355, %360
%362 = add i64 %354, %361
%363 = getelementptr inbounds double, double* %352, i64 %362
store double %351, double* %363
br label %364
364: ; preds = %213
%365 = load i64, i64* %18
%366 = add i64 %365, 2
store i64 %366, i64* %18
br label %209
367: ; preds = %209
br label %368
368: ; preds = %367
%369 = load i64, i64* %20
%370 = add i64 %369, 1
store i64 %370, i64* %20
br label %204
371: ; preds = %204
br label %372
372: ; preds = %371
%373 = load i64, i64* %19
%374 = add i64 %373, 1
store i64 %374, i64* %19
%375 = load i64, i64* %24
%376 = add i64 %375, -1
store i64 %376, i64* %24
br label %199
377: ; preds = %199
br label %384
378: ; preds = %7
%379 = load double*, double** %12
%380 = load double*, double** %13
%381 = load i64, i64* %11
%382 = mul i64 %381, 8
%383 = call i32 @memcpy(double* %379, double* %380, i64 %382)
br label %384
384: ; preds = %378, %377
store i64 1, i64* %19
%385 = load i64, i64* %9
%386 = sub i64 %385, 1
store i64 %386, i64* %24
br label %387
387: ; preds = %467, %384
%388 = load i64, i64* %19
%389 = load i64, i64* %17
%390 = icmp ult i64 %388, %389
br i1 %390, label %391, label %472
391: ; preds = %387
store i64 0, i64* %20
br label %392
392: ; preds = %463, %391
%393 = load i64, i64* %20
%394 = load i64, i64* %10
%395 = icmp ult i64 %393, %394
br i1 %395, label %396, label %466
396: ; preds = %392
%397 = load double*, double** %13
%398 = load i64, i64* %8
%399 = load i64, i64* %20
%400 = load i64, i64* %10
%401 = load i64, i64* %24
%402 = mul i64 %400, %401
%403 = add i64 %399, %402
%404 = mul i64 %398, %403
%405 = add i64 0, %404
%406 = getelementptr inbounds double, double* %397, i64 %405
%407 = load double, double* %406
%408 = load double*, double** %13
%409 = load i64, i64* %8
%410 = load i64, i64* %20
%411 = load i64, i64* %10
%412 = load i64, i64* %19
%413 = mul i64 %411, %412
%414 = add i64 %410, %413
%415 = mul i64 %409, %414
%416 = add i64 0, %415
%417 = getelementptr inbounds double, double* %408, i64 %416
%418 = load double, double* %417
%419 = fadd double %407, %418
%420 = load double*, double** %12
%421 = load i64, i64* %8
%422 = load i64, i64* %20
%423 = load i64, i64* %10
%424 = load i64, i64* %19
%425 = mul i64 %423, %424
%426 = add i64 %422, %425
%427 = mul i64 %421, %426
%428 = add i64 0, %427
%429 = getelementptr inbounds double, double* %420, i64 %428
store double %419, double* %429
%430 = load double*, double** %13
%431 = load i64, i64* %8
%432 = load i64, i64* %20
%433 = load i64, i64* %10
%434 = load i64, i64* %24
%435 = mul i64 %433, %434
%436 = add i64 %432, %435
%437 = mul i64 %431, %436
%438 = add i64 0, %437
%439 = getelementptr inbounds double, double* %430, i64 %438
%440 = load double, double* %439
%441 = load double*, double** %13
%442 = load i64, i64* %8
%443 = load i64, i64* %20
%444 = load i64, i64* %10
%445 = load i64, i64* %19
%446 = mul i64 %444, %445
%447 = add i64 %443, %446
%448 = mul i64 %442, %447
%449 = add i64 0, %448
%450 = getelementptr inbounds double, double* %441, i64 %449
%451 = load double, double* %450
%452 = fsub double %440, %451
%453 = load double*, double** %12
%454 = load i64, i64* %8
%455 = load i64, i64* %20
%456 = load i64, i64* %10
%457 = load i64, i64* %24
%458 = mul i64 %456, %457
%459 = add i64 %455, %458
%460 = mul i64 %454, %459
%461 = add i64 0, %460
%462 = getelementptr inbounds double, double* %453, i64 %461
store double %452, double* %462
br label %463
463: ; preds = %396
%464 = load i64, i64* %20
%465 = add i64 %464, 1
store i64 %465, i64* %20
br label %392
466: ; preds = %392
br label %467
467: ; preds = %466
%468 = load i64, i64* %19
%469 = add i64 %468, 1
store i64 %469, i64* %19
%470 = load i64, i64* %24
%471 = add i64 %470, -1
store i64 %471, i64* %24
br label %387
472: ; preds = %387
%473 = load i64, i64* %9
%474 = mul i64 2, %473
%475 = mul i64 %474, 8
%476 = trunc i64 %475 to i32
%477 = call i64 @util_malloc_(i32 %476)
%478 = inttoptr i64 %477 to double*
store double* %478, double** %32
%479 = load i64, i64* %9
%480 = uitofp i64 %479 to double
%481 = fdiv double 0x401921FB54442D18, %480
store double %481, double* %31
%482 = load double*, double** %32
%483 = getelementptr inbounds double, double* %482, i64 0
store double 1.000000e+00, double* %483
%484 = load double*, double** %32
%485 = getelementptr inbounds double, double* %484, i64 1
store double 0.000000e+00, double* %485
%486 = load double, double* %31
%487 = fptoui double %486 to i64
%488 = call double @cos(i64 %487)
%489 = load double*, double** %32
%490 = load i64, i64* %9
%491 = mul i64 2, %490
%492 = sub i64 %491, 2
%493 = getelementptr inbounds double, double* %489, i64 %492
store double %488, double* %493
%494 = load double*, double** %32
%495 = getelementptr inbounds double, double* %494, i64 2
store double %488, double* %495
%496 = load double, double* %31
%497 = fptoui double %496 to i64
%498 = call double @sin(i64 %497)
%499 = load double*, double** %32
%500 = getelementptr inbounds double, double* %499, i64 3
store double %498, double* %500
%501 = load double*, double** %32
%502 = getelementptr inbounds double, double* %501, i64 3
%503 = load double, double* %502
%504 = fneg double %503
%505 = load double*, double** %32
%506 = load i64, i64* %9
%507 = mul i64 2, %506
%508 = sub i64 %507, 1
%509 = getelementptr inbounds double, double* %505, i64 %508
store double %504, double* %509
store i64 2, i64* %18
br label %510
510: ; preds = %559, %472
%511 = load i64, i64* %18
%512 = load i64, i64* %9
%513 = udiv i64 %512, 2
%514 = icmp ule i64 %511, %513
br i1 %514, label %515, label %562
515: ; preds = %510
%516 = load i64, i64* %18
%517 = uitofp i64 %516 to double
%518 = load double, double* %31
%519 = fmul double %517, %518
%520 = fptoui double %519 to i64
%521 = call double @cos(i64 %520)
%522 = load double*, double** %32
%523 = load i64, i64* %9
%524 = mul i64 2, %523
%525 = load i64, i64* %18
%526 = mul i64 2, %525
%527 = sub i64 %524, %526
%528 = getelementptr inbounds double, double* %522, i64 %527
store double %521, double* %528
%529 = load double*, double** %32
%530 = load i64, i64* %18
%531 = mul i64 2, %530
%532 = getelementptr inbounds double, double* %529, i64 %531
store double %521, double* %532
%533 = load i64, i64* %18
%534 = uitofp i64 %533 to double
%535 = load double, double* %31
%536 = fmul double %534, %535
%537 = fptoui double %536 to i64
%538 = call double @sin(i64 %537)
%539 = load double*, double** %32
%540 = load i64, i64* %18
%541 = mul i64 2, %540
%542 = add i64 %541, 1
%543 = getelementptr inbounds double, double* %539, i64 %542
store double %538, double* %543
%544 = load double*, double** %32
%545 = load i64, i64* %18
%546 = mul i64 2, %545
%547 = add i64 %546, 1
%548 = getelementptr inbounds double, double* %544, i64 %547
%549 = load double, double* %548
%550 = fneg double %549
%551 = load double*, double** %32
%552 = load i64, i64* %9
%553 = mul i64 2, %552
%554 = load i64, i64* %18
%555 = mul i64 2, %554
%556 = sub i64 %553, %555
%557 = add i64 %556, 1
%558 = getelementptr inbounds double, double* %551, i64 %557
store double %550, double* %558
br label %559
559: ; preds = %515
%560 = load i64, i64* %18
%561 = add i64 %560, 1
store i64 %561, i64* %18
br label %510
562: ; preds = %510
store i64 1, i64* %21
%563 = load i64, i64* %9
%564 = sub i64 %563, 1
store i64 %564, i64* %25
br label %565
565: ; preds = %714, %562
%566 = load i64, i64* %21
%567 = load i64, i64* %17
%568 = icmp ult i64 %566, %567
br i1 %568, label %569, label %719
569: ; preds = %565
%570 = load double*, double** %32
%571 = load i64, i64* %21
%572 = mul i64 2, %571
%573 = getelementptr inbounds double, double* %570, i64 %572
%574 = load double, double* %573
store double %574, double* %29
%575 = load double*, double** %32
%576 = load i64, i64* %21
%577 = mul i64 2, %576
%578 = add i64 %577, 1
%579 = getelementptr inbounds double, double* %575, i64 %578
%580 = load double, double* %579
store double %580, double* %27
store i64 0, i64* %26
br label %581
581: ; preds = %627, %569
%582 = load i64, i64* %26
%583 = load i64, i64* %11
%584 = icmp ult i64 %582, %583
br i1 %584, label %585, label %630
585: ; preds = %581
%586 = load double*, double** %12
%587 = load i64, i64* %26
%588 = load i64, i64* %11
%589 = mul i64 %588, 0
%590 = add i64 %587, %589
%591 = getelementptr inbounds double, double* %586, i64 %590
%592 = load double, double* %591
%593 = load double, double* %29
%594 = load double*, double** %12
%595 = load i64, i64* %26
%596 = load i64, i64* %11
%597 = mul i64 %596, 1
%598 = add i64 %595, %597
%599 = getelementptr inbounds double, double* %594, i64 %598
%600 = load double, double* %599
%601 = call double @llvm.fmuladd.f64(double %593, double %600, double %592)
%602 = load double*, double** %13
%603 = load i64, i64* %26
%604 = load i64, i64* %11
%605 = load i64, i64* %21
%606 = mul i64 %604, %605
%607 = add i64 %603, %606
%608 = getelementptr inbounds double, double* %602, i64 %607
store double %601, double* %608
%609 = load double, double* %27
%610 = load double*, double** %12
%611 = load i64, i64* %26
%612 = load i64, i64* %11
%613 = load i64, i64* %9
%614 = sub i64 %613, 1
%615 = mul i64 %612, %614
%616 = add i64 %611, %615
%617 = getelementptr inbounds double, double* %610, i64 %616
%618 = load double, double* %617
%619 = fmul double %609, %618
%620 = load double*, double** %13
%621 = load i64, i64* %26
%622 = load i64, i64* %11
%623 = load i64, i64* %25
%624 = mul i64 %622, %623
%625 = add i64 %621, %624
%626 = getelementptr inbounds double, double* %620, i64 %625
store double %619, double* %626
br label %627
627: ; preds = %585
%628 = load i64, i64* %26
%629 = add i64 %628, 1
store i64 %629, i64* %26
br label %581
630: ; preds = %581
%631 = load i64, i64* %21
%632 = mul i64 2, %631
store i64 %632, i64* %33
store i64 2, i64* %19
%633 = load i64, i64* %9
%634 = sub i64 %633, 2
store i64 %634, i64* %24
br label %635
635: ; preds = %708, %630
%636 = load i64, i64* %19
%637 = load i64, i64* %17
%638 = icmp ult i64 %636, %637
br i1 %638, label %639, label %713
639: ; preds = %635
%640 = load i64, i64* %21
%641 = mul i64 2, %640
%642 = load i64, i64* %33
%643 = add i64 %642, %641
store i64 %643, i64* %33
%644 = load i64, i64* %33
%645 = load i64, i64* %9
%646 = mul i64 2, %645
%647 = icmp uge i64 %644, %646
br i1 %647, label %648, label %653
648: ; preds = %639
%649 = load i64, i64* %9
%650 = mul i64 2, %649
%651 = load i64, i64* %33
%652 = sub i64 %651, %650
store i64 %652, i64* %33
br label %653
653: ; preds = %648, %639
%654 = load double*, double** %32
%655 = load i64, i64* %33
%656 = getelementptr inbounds double, double* %654, i64 %655
%657 = load double, double* %656
store double %657, double* %30
%658 = load double*, double** %32
%659 = load i64, i64* %33
%660 = add i64 %659, 1
%661 = getelementptr inbounds double, double* %658, i64 %660
%662 = load double, double* %661
store double %662, double* %28
store i64 0, i64* %26
br label %663
663: ; preds = %704, %653
%664 = load i64, i64* %26
%665 = load i64, i64* %11
%666 = icmp ult i64 %664, %665
br i1 %666, label %667, label %707
667: ; preds = %663
%668 = load double, double* %30
%669 = load double*, double** %12
%670 = load i64, i64* %26
%671 = load i64, i64* %11
%672 = load i64, i64* %19
%673 = mul i64 %671, %672
%674 = add i64 %670, %673
%675 = getelementptr inbounds double, double* %669, i64 %674
%676 = load double, double* %675
%677 = load double*, double** %13
%678 = load i64, i64* %26
%679 = load i64, i64* %11
%680 = load i64, i64* %21
%681 = mul i64 %679, %680
%682 = add i64 %678, %681
%683 = getelementptr inbounds double, double* %677, i64 %682
%684 = load double, double* %683
%685 = call double @llvm.fmuladd.f64(double %668, double %676, double %684)
store double %685, double* %683
%686 = load double, double* %28
%687 = load double*, double** %12
%688 = load i64, i64* %26
%689 = load i64, i64* %11
%690 = load i64, i64* %24
%691 = mul i64 %689, %690
%692 = add i64 %688, %691
%693 = getelementptr inbounds double, double* %687, i64 %692
%694 = load double, double* %693
%695 = load double*, double** %13
%696 = load i64, i64* %26
%697 = load i64, i64* %11
%698 = load i64, i64* %25
%699 = mul i64 %697, %698
%700 = add i64 %696, %699
%701 = getelementptr inbounds double, double* %695, i64 %700
%702 = load double, double* %701
%703 = call double @llvm.fmuladd.f64(double %686, double %694, double %702)
store double %703, double* %701
br label %704
704: ; preds = %667
%705 = load i64, i64* %26
%706 = add i64 %705, 1
store i64 %706, i64* %26
br label %663
707: ; preds = %663
br label %708
708: ; preds = %707
%709 = load i64, i64* %19
%710 = add i64 %709, 1
store i64 %710, i64* %19
%711 = load i64, i64* %24
%712 = add i64 %711, -1
store i64 %712, i64* %24
br label %635
713: ; preds = %635
br label %714
714: ; preds = %713
%715 = load i64, i64* %21
%716 = add i64 %715, 1
store i64 %716, i64* %21
%717 = load i64, i64* %25
%718 = add i64 %717, -1
store i64 %718, i64* %25
br label %565
719: ; preds = %565
br label %720
720: ; preds = %719
%721 = load double*, double** %32
%722 = call i32 @util_free_(double* %721)
store double* null, double** %32
br label %723
723: ; preds = %720
store i64 1, i64* %19
br label %724
724: ; preds = %754, %723
%725 = load i64, i64* %19
%726 = load i64, i64* %17
%727 = icmp ult i64 %725, %726
br i1 %727, label %728, label %757
728: ; preds = %724
store i64 0, i64* %26
br label %729
729: ; preds = %750, %728
%730 = load i64, i64* %26
%731 = load i64, i64* %11
%732 = icmp ult i64 %730, %731
br i1 %732, label %733, label %753
733: ; preds = %729
%734 = load double*, double** %12
%735 = load i64, i64* %26
%736 = load i64, i64* %11
%737 = load i64, i64* %19
%738 = mul i64 %736, %737
%739 = add i64 %735, %738
%740 = getelementptr inbounds double, double* %734, i64 %739
%741 = load double, double* %740
%742 = load double*, double** %13
%743 = load i64, i64* %26
%744 = load i64, i64* %11
%745 = mul i64 %744, 0
%746 = add i64 %743, %745
%747 = getelementptr inbounds double, double* %742, i64 %746
%748 = load double, double* %747
%749 = fadd double %748, %741
store double %749, double* %747
br label %750
750: ; preds = %733
%751 = load i64, i64* %26
%752 = add i64 %751, 1
store i64 %752, i64* %26
br label %729
753: ; preds = %729
br label %754
754: ; preds = %753
%755 = load i64, i64* %19
%756 = add i64 %755, 1
store i64 %756, i64* %19
br label %724
757: ; preds = %724
store i64 0, i64* %20
br label %758
758: ; preds = %784, %757
%759 = load i64, i64* %20
%760 = load i64, i64* %10
%761 = icmp ult i64 %759, %760
br i1 %761, label %762, label %787
762: ; preds = %758
%763 = load double*, double** %12
%764 = load i64, i64* %8
%765 = load i64, i64* %15
%766 = load i64, i64* %20
%767 = mul i64 %765, %766
%768 = add i64 0, %767
%769 = mul i64 %764, %768
%770 = add i64 0, %769
%771 = getelementptr inbounds double, double* %763, i64 %770
%772 = load double*, double** %13
%773 = load i64, i64* %8
%774 = load i64, i64* %20
%775 = load i64, i64* %10
%776 = mul i64 %775, 0
%777 = add i64 %774, %776
%778 = mul i64 %773, %777
%779 = add i64 0, %778
%780 = getelementptr inbounds double, double* %772, i64 %779
%781 = load i64, i64* %8
%782 = mul i64 %781, 8
%783 = call i32 @memcpy(double* %771, double* %780, i64 %782)
br label %784
784: ; preds = %762
%785 = load i64, i64* %20
%786 = add i64 %785, 1
store i64 %786, i64* %20
br label %758
787: ; preds = %758
store i64 1, i64* %19
br label %788
788: ; preds = %852, %787
%789 = load i64, i64* %19
%790 = load i64, i64* %17
%791 = icmp ult i64 %789, %790
br i1 %791, label %792, label %855
792: ; preds = %788
%793 = load i64, i64* %9
%794 = load i64, i64* %19
%795 = sub i64 %793, %794
store i64 %795, i64* %24
%796 = load i64, i64* %19
%797 = mul i64 2, %796
store i64 %797, i64* %22
store i64 0, i64* %20
br label %798
798: ; preds = %848, %792
%799 = load i64, i64* %20
%800 = load i64, i64* %10
%801 = icmp ult i64 %799, %800
br i1 %801, label %802, label %851
802: ; preds = %798
%803 = load double*, double** %13
%804 = load i64, i64* %8
%805 = load i64, i64* %20
%806 = load i64, i64* %10
%807 = load i64, i64* %19
%808 = mul i64 %806, %807
%809 = add i64 %805, %808
%810 = mul i64 %804, %809
%811 = add i64 0, %810
%812 = getelementptr inbounds double, double* %803, i64 %811
%813 = load double, double* %812
%814 = load double*, double** %12
%815 = load i64, i64* %8
%816 = sub i64 %815, 1
%817 = load i64, i64* %8
%818 = load i64, i64* %22
%819 = sub i64 %818, 1
%820 = load i64, i64* %15
%821 = load i64, i64* %20
%822 = mul i64 %820, %821
%823 = add i64 %819, %822
%824 = mul i64 %817, %823
%825 = add i64 %816, %824
%826 = getelementptr inbounds double, double* %814, i64 %825
store double %813, double* %826
%827 = load double*, double** %13
%828 = load i64, i64* %8
%829 = load i64, i64* %20
%830 = load i64, i64* %10
%831 = load i64, i64* %24
%832 = mul i64 %830, %831
%833 = add i64 %829, %832
%834 = mul i64 %828, %833
%835 = add i64 0, %834
%836 = getelementptr inbounds double, double* %827, i64 %835
%837 = load double, double* %836
%838 = load double*, double** %12
%839 = load i64, i64* %8
%840 = load i64, i64* %22
%841 = load i64, i64* %15
%842 = load i64, i64* %20
%843 = mul i64 %841, %842
%844 = add i64 %840, %843
%845 = mul i64 %839, %844
%846 = add i64 0, %845
%847 = getelementptr inbounds double, double* %838, i64 %846
store double %837, double* %847
br label %848
848: ; preds = %802
%849 = load i64, i64* %20
%850 = add i64 %849, 1
store i64 %850, i64* %20
br label %798
851: ; preds = %798
br label %852
852: ; preds = %851
%853 = load i64, i64* %19
%854 = add i64 %853, 1
store i64 %854, i64* %19
br label %788
855: ; preds = %788
%856 = load i64, i64* %8
%857 = icmp eq i64 %856, 1
br i1 %857, label %858, label %859
858: ; preds = %855
br label %1046
859: ; preds = %855
store i64 1, i64* %19
br label %860
860: ; preds = %1043, %859
%861 = load i64, i64* %19
%862 = load i64, i64* %17
%863 = icmp ult i64 %861, %862
br i1 %863, label %864, label %1046
864: ; preds = %860
%865 = load i64, i64* %9
%866 = load i64, i64* %19
%867 = sub i64 %865, %866
store i64 %867, i64* %24
%868 = load i64, i64* %19
%869 = mul i64 2, %868
store i64 %869, i64* %22
store i64 0, i64* %20
br label %870
870: ; preds = %1039, %864
%871 = load i64, i64* %20
%872 = load i64, i64* %10
%873 = icmp ult i64 %871, %872
br i1 %873, label %874, label %1042
874: ; preds = %870
store i64 2, i64* %18
br label %875
875: ; preds = %1035, %874
%876 = load i64, i64* %18
%877 = load i64, i64* %8
%878 = icmp ult i64 %876, %877
br i1 %878, label %879, label %1038
879: ; preds = %875
%880 = load i64, i64* %8
%881 = load i64, i64* %18
%882 = sub i64 %880, %881
store i64 %882, i64* %23
%883 = load double*, double** %13
%884 = load i64, i64* %18
%885 = sub i64 %884, 1
%886 = load i64, i64* %8
%887 = load i64, i64* %20
%888 = load i64, i64* %10
%889 = load i64, i64* %19
%890 = mul i64 %888, %889
%891 = add i64 %887, %890
%892 = mul i64 %886, %891
%893 = add i64 %885, %892
%894 = getelementptr inbounds double, double* %883, i64 %893
%895 = load double, double* %894
%896 = load double*, double** %13
%897 = load i64, i64* %18
%898 = sub i64 %897, 1
%899 = load i64, i64* %8
%900 = load i64, i64* %20
%901 = load i64, i64* %10
%902 = load i64, i64* %24
%903 = mul i64 %901, %902
%904 = add i64 %900, %903
%905 = mul i64 %899, %904
%906 = add i64 %898, %905
%907 = getelementptr inbounds double, double* %896, i64 %906
%908 = load double, double* %907
%909 = fadd double %895, %908
%910 = load double*, double** %12
%911 = load i64, i64* %18
%912 = sub i64 %911, 1
%913 = load i64, i64* %8
%914 = load i64, i64* %22
%915 = load i64, i64* %15
%916 = load i64, i64* %20
%917 = mul i64 %915, %916
%918 = add i64 %914, %917
%919 = mul i64 %913, %918
%920 = add i64 %912, %919
%921 = getelementptr inbounds double, double* %910, i64 %920
store double %909, double* %921
%922 = load double*, double** %13
%923 = load i64, i64* %18
%924 = sub i64 %923, 1
%925 = load i64, i64* %8
%926 = load i64, i64* %20
%927 = load i64, i64* %10
%928 = load i64, i64* %19
%929 = mul i64 %927, %928
%930 = add i64 %926, %929
%931 = mul i64 %925, %930
%932 = add i64 %924, %931
%933 = getelementptr inbounds double, double* %922, i64 %932
%934 = load double, double* %933
%935 = load double*, double** %13
%936 = load i64, i64* %18
%937 = sub i64 %936, 1
%938 = load i64, i64* %8
%939 = load i64, i64* %20
%940 = load i64, i64* %10
%941 = load i64, i64* %24
%942 = mul i64 %940, %941
%943 = add i64 %939, %942
%944 = mul i64 %938, %943
%945 = add i64 %937, %944
%946 = getelementptr inbounds double, double* %935, i64 %945
%947 = load double, double* %946
%948 = fsub double %934, %947
%949 = load double*, double** %12
%950 = load i64, i64* %23
%951 = sub i64 %950, 1
%952 = load i64, i64* %8
%953 = load i64, i64* %22
%954 = sub i64 %953, 1
%955 = load i64, i64* %15
%956 = load i64, i64* %20
%957 = mul i64 %955, %956
%958 = add i64 %954, %957
%959 = mul i64 %952, %958
%960 = add i64 %951, %959
%961 = getelementptr inbounds double, double* %949, i64 %960
store double %948, double* %961
%962 = load double*, double** %13
%963 = load i64, i64* %18
%964 = load i64, i64* %8
%965 = load i64, i64* %20
%966 = load i64, i64* %10
%967 = load i64, i64* %24
%968 = mul i64 %966, %967
%969 = add i64 %965, %968
%970 = mul i64 %964, %969
%971 = add i64 %963, %970
%972 = getelementptr inbounds double, double* %962, i64 %971
%973 = load double, double* %972
%974 = load double*, double** %13
%975 = load i64, i64* %18
%976 = load i64, i64* %8
%977 = load i64, i64* %20
%978 = load i64, i64* %10
%979 = load i64, i64* %19
%980 = mul i64 %978, %979
%981 = add i64 %977, %980
%982 = mul i64 %976, %981
%983 = add i64 %975, %982
%984 = getelementptr inbounds double, double* %974, i64 %983
%985 = load double, double* %984
%986 = fadd double %973, %985
%987 = load double*, double** %12
%988 = load i64, i64* %18
%989 = load i64, i64* %8
%990 = load i64, i64* %22
%991 = load i64, i64* %15
%992 = load i64, i64* %20
%993 = mul i64 %991, %992
%994 = add i64 %990, %993
%995 = mul i64 %989, %994
%996 = add i64 %988, %995
%997 = getelementptr inbounds double, double* %987, i64 %996
store double %986, double* %997
%998 = load double*, double** %13
%999 = load i64, i64* %18
%1000 = load i64, i64* %8
%1001 = load i64, i64* %20
%1002 = load i64, i64* %10
%1003 = load i64, i64* %24
%1004 = mul i64 %1002, %1003
%1005 = add i64 %1001, %1004
%1006 = mul i64 %1000, %1005
%1007 = add i64 %999, %1006
%1008 = getelementptr inbounds double, double* %998, i64 %1007
%1009 = load double, double* %1008
%1010 = load double*, double** %13
%1011 = load i64, i64* %18
%1012 = load i64, i64* %8
%1013 = load i64, i64* %20
%1014 = load i64, i64* %10
%1015 = load i64, i64* %19
%1016 = mul i64 %1014, %1015
%1017 = add i64 %1013, %1016
%1018 = mul i64 %1012, %1017
%1019 = add i64 %1011, %1018
%1020 = getelementptr inbounds double, double* %1010, i64 %1019
%1021 = load double, double* %1020
%1022 = fsub double %1009, %1021
%1023 = load double*, double** %12
%1024 = load i64, i64* %23
%1025 = load i64, i64* %8
%1026 = load i64, i64* %22
%1027 = sub i64 %1026, 1
%1028 = load i64, i64* %15
%1029 = load i64, i64* %20
%1030 = mul i64 %1028, %1029
%1031 = add i64 %1027, %1030
%1032 = mul i64 %1025, %1031
%1033 = add i64 %1024, %1032
%1034 = getelementptr inbounds double, double* %1023, i64 %1033
store double %1022, double* %1034
br label %1035
1035: ; preds = %879
%1036 = load i64, i64* %18
%1037 = add i64 %1036, 2
store i64 %1037, i64* %18
br label %875
1038: ; preds = %875
br label %1039
1039: ; preds = %1038
%1040 = load i64, i64* %20
%1041 = add i64 %1040, 1
store i64 %1041, i64* %20
br label %870
1042: ; preds = %870
br label %1043
1043: ; preds = %1042
%1044 = load i64, i64* %19
%1045 = add i64 %1044, 1
store i64 %1045, i64* %19
br label %860
1046: ; preds = %858, %860
ret void
}

LLVM IR (-O2):
define void @radfg(i64 %0, i64 %1, i64 %2, i64 %3, double* %4, double* %5, double* nocapture %6) {
%8 = bitcast double* %4 to i8*
%9 = add i64 %1, 1
%10 = lshr i64 %9, 1
%11 = icmp eq i64 %0, 1
%12 = shl i64 %3, 3
br i1 %11, label %235, label %13
13: ; preds = %7
%14 = tail call i32 @memcpy(double* %5, double* %4, i64 %12)
%15 = icmp ugt i64 %1, 1
br i1 %15, label %16, label %237
16: ; preds = %13
%17 = icmp eq i64 %2, 0
%18 = icmp ugt i64 %0, 2
%19 = add i64 %0, -3
%20 = lshr i64 %19, 1
%21 = mul i64 %2, %0
%22 = add i64 %21, 1
%23 = mul i64 %2, %0
%24 = add i64 %21, 2
%25 = add i64 %23, 1
%26 = mul i64 %2, %0
%27 = add i64 %0, -3
%28 = lshr i64 %27, 1
%29 = and i64 %27, -2
%30 = add i64 %23, %29
%31 = add i64 %30, 3
%32 = add i64 %29, 2
%33 = add nuw i64 %28, 1
%34 = icmp ult i64 %27, 2
%35 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %20, i64 16)
%36 = extractvalue { i64, i1 } %35, 0
%37 = extractvalue { i64, i1 } %35, 1
%38 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %20, i64 16)
%39 = extractvalue { i64, i1 } %38, 0
%40 = extractvalue { i64, i1 } %38, 1
%41 = and i64 %33, -2
%42 = shl i64 %41, 1
%43 = shl i64 %33, 1
%44 = or i64 %43, 2
%45 = getelementptr inbounds double, double* %4, i64 -1
%46 = getelementptr inbounds double, double* %5, i64 -1
%47 = icmp eq i64 %33, %41
br label %48
48: ; preds = %16, %182
%49 = phi i64 [ 0, %16 ], [ %185, %182 ]
%50 = phi i64 [ 1, %16 ], [ %183, %182 ]
%51 = mul i64 %26, %49
%52 = add i64 %25, %51
%53 = add i64 %31, %51
%54 = mul i64 %49, %0
%55 = getelementptr double, double* %6, i64 %54
%56 = add i64 %32, %54
%57 = getelementptr double, double* %6, i64 %56
%58 = mul i64 %23, %49
%59 = add i64 %22, %58
%60 = add i64 %24, %58
br i1 %17, label %182, label %61
61: ; preds = %48
%62 = mul i64 %50, %2
%63 = add i64 %50, -1
%64 = mul i64 %63, %0
%65 = add i64 %64, 1
%66 = add i64 %65, %42
br label %73
67: ; preds = %182
%68 = icmp ugt i64 %9, 3
br i1 %68, label %69, label %237
69: ; preds = %67
%70 = icmp eq i64 %2, 0
%71 = icmp ugt i64 %0, 2
%72 = call i64 @llvm.umax.i64(i64 %10, i64 2)
br label %186
73: ; preds = %61, %179
%74 = phi i64 [ 0, %61 ], [ %180, %179 ]
%75 = mul i64 %74, %0
%76 = add i64 %52, %75
%77 = getelementptr double, double* %5, i64 %76
%78 = add i64 %53, %75
%79 = getelementptr double, double* %5, i64 %78
%80 = getelementptr double, double* %4, i64 %76
%81 = getelementptr double, double* %4, i64 %78
%82 = mul i64 %74, %0
%83 = add i64 %59, %82
%84 = getelementptr double, double* %5, i64 %83
%85 = bitcast double* %84 to i8*
%86 = add i64 %60, %82
%87 = getelementptr double, double* %5, i64 %86
%88 = bitcast double* %87 to i8*
%89 = add i64 %74, %62
%90 = mul i64 %89, %0
%91 = getelementptr inbounds double, double* %4, i64 %90
%92 = load double, double* %91
%93 = getelementptr inbounds double, double* %5, i64 %90
store double %92, double* %93
br i1 %18, label %94, label %179
94: ; preds = %73
br i1 %34, label %148, label %95
95: ; preds = %94
%96 = getelementptr i8, i8* %85, i64 %36
%97 = icmp ult i8* %96, %85
%98 = or i1 %97, %37
%99 = getelementptr i8, i8* %88, i64 %39
%100 = icmp ult i8* %99, %88
%101 = or i1 %100, %40
%102 = or i1 %98, %101
br i1 %102, label %148, label %103
103: ; preds = %95
%104 = icmp ult double* %77, %57
%105 = icmp ult double* %55, %79
%106 = and i1 %104, %105
%107 = icmp ult double* %77, %81
%108 = icmp ult double* %80, %79
%109 = and i1 %107, %108
%110 = or i1 %106, %109
br i1 %110, label %148, label %111
111: ; preds = %103, %111
%112 = phi i64 [ %145, %111 ], [ 0, %103 ]
%113 = shl i64 %112, 1
%114 = shl i64 %112, 1
%115 = or i64 %114, 2
%116 = add i64 %64, %113
%117 = getelementptr inbounds double, double* %6, i64 %116
%118 = bitcast double* %117 to <4 x double>*
%119 = load <4 x double>, <4 x double>* %118
%120 = shufflevector <4 x double> %119, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%121 = add i64 %115, %90
%122 = add i64 %121, -1
%123 = getelementptr inbounds double, double* %4, i64 %122
%124 = bitcast double* %123 to <4 x double>*
%125 = load <4 x double>, <4 x double>* %124
%126 = shufflevector <4 x double> %125, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%127 = fmul <4 x double> %119, %125
%128 = shufflevector <4 x double> %127, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%129 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %120, <2 x double> %126, <2 x double> %128)
%130 = bitcast double* %117 to <4 x double>*
%131 = load <4 x double>, <4 x double>* %130
%132 = shufflevector <4 x double> %131, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%133 = shufflevector <4 x double> %131, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%134 = getelementptr inbounds double, double* %45, i64 %121
%135 = bitcast double* %134 to <4 x double>*
%136 = load <4 x double>, <4 x double>* %135
%137 = shufflevector <4 x double> %136, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%138 = shufflevector <4 x double> %136, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%139 = fneg <2 x double> %133
%140 = fmul <2 x double> %137, %139
%141 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %132, <2 x double> %138, <2 x double> %140)
%142 = getelementptr inbounds double, double* %46, i64 %121
%143 = bitcast double* %142 to <4 x double>*
%144 = shufflevector <2 x double> %129, <2 x double> %141, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %144, <4 x double>* %143
%145 = add nuw i64 %112, 2
%146 = icmp eq i64 %145, %41
br i1 %146, label %147, label %111
147: ; preds = %111
br i1 %47, label %179, label %148
148: ; preds = %103, %95, %94, %147
%149 = phi i64 [ %65, %103 ], [ %65, %95 ], [ %65, %94 ], [ %66, %147 ]
%150 = phi i64 [ 2, %103 ], [ 2, %95 ], [ 2, %94 ], [ %44, %147 ]
br label %151
151: ; preds = %148, %151
%152 = phi i64 [ %177, %151 ], [ %149, %148 ]
%153 = phi i64 [ %176, %151 ], [ %150, %148 ]
%154 = add i64 %152, -1
%155 = getelementptr inbounds double, double* %6, i64 %154
%156 = load double, double* %155
%157 = add i64 %153, %90
%158 = add i64 %157, -1
%159 = getelementptr inbounds double, double* %4, i64 %158
%160 = load double, double* %159
%161 = getelementptr inbounds double, double* %6, i64 %152
%162 = load double, double* %161
%163 = getelementptr inbounds double, double* %4, i64 %157
%164 = load double, double* %163
%165 = fmul double %162, %164
%166 = tail call double @llvm.fmuladd.f64(double %156, double %160, double %165)
%167 = getelementptr inbounds double, double* %5, i64 %158
store double %166, double* %167
%168 = load double, double* %155
%169 = load double, double* %163
%170 = load double, double* %161
%171 = load double, double* %159
%172 = fneg double %170
%173 = fmul double %171, %172
%174 = tail call double @llvm.fmuladd.f64(double %168, double %169, double %173)
%175 = getelementptr inbounds double, double* %5, i64 %157
store double %174, double* %175
%176 = add nuw i64 %153, 2
%177 = add i64 %152, 2
%178 = icmp ult i64 %176, %0
br i1 %178, label %151, label %179
179: ; preds = %151, %147, %73
%180 = add nuw i64 %74, 1
%181 = icmp eq i64 %180, %2
br i1 %181, label %182, label %73
182: ; preds = %179, %48
%183 = add nuw i64 %50, 1
%184 = icmp eq i64 %183, %1
%185 = add i64 %49, 1
br i1 %184, label %67, label %48
186: ; preds = %69, %232
%187 = phi i64 [ %1, %69 ], [ %189, %232 ]
%188 = phi i64 [ 1, %69 ], [ %233, %232 ]
%189 = add i64 %187, -1
br i1 %70, label %232, label %190
190: ; preds = %186
%191 = mul i64 %189, %2
%192 = mul i64 %188, %2
br label %193
193: ; preds = %190, %229
%194 = phi i64 [ 0, %190 ], [ %230, %229 ]
br i1 %71, label %195, label %229
195: ; preds = %193
%196 = add i64 %194, %191
%197 = mul i64 %196, %0
%198 = add i64 %194, %192
%199 = mul i64 %198, %0
br label %200
200: ; preds = %195, %200
%201 = phi i64 [ 2, %195 ], [ %227, %200 ]
%202 = add i64 %201, -1
%203 = add i64 %202, %197
%204 = getelementptr inbounds double, double* %5, i64 %203
%205 = load double, double* %204
%206 = add i64 %202, %199
%207 = getelementptr inbounds double, double* %5, i64 %206
%208 = load double, double* %207
%209 = fadd double %205, %208
%210 = getelementptr inbounds double, double* %4, i64 %206
store double %209, double* %210
%211 = load double, double* %204
%212 = load double, double* %207
%213 = fsub double %211, %212
%214 = add i64 %201, %197
%215 = getelementptr inbounds double, double* %4, i64 %214
store double %213, double* %215
%216 = add i64 %201, %199
%217 = getelementptr inbounds double, double* %5, i64 %216
%218 = load double, double* %217
%219 = getelementptr inbounds double, double* %5, i64 %214
%220 = load double, double* %219
%221 = fadd double %218, %220
%222 = getelementptr inbounds double, double* %4, i64 %216
store double %221, double* %222
%223 = load double, double* %217
%224 = load double, double* %219
%225 = fsub double %223, %224
%226 = getelementptr inbounds double, double* %4, i64 %203
store double %225, double* %226
%227 = add nuw i64 %201, 2
%228 = icmp ult i64 %227, %0
br i1 %228, label %200, label %229
229: ; preds = %200, %193
%230 = add nuw i64 %194, 1
%231 = icmp eq i64 %230, %2
br i1 %231, label %232, label %193
232: ; preds = %229, %186
%233 = add nuw nsw i64 %188, 1
%234 = icmp eq i64 %233, %72
br i1 %234, label %239, label %186
235: ; preds = %7
%236 = tail call i32 @memcpy(double* %4, double* %5, i64 %12)
br label %239
237: ; preds = %67, %13
%238 = add nsw i64 %1, -1
br label %398
239: ; preds = %232, %235
%240 = add i64 %1, -1
%241 = icmp ugt i64 %9, 3
br i1 %241, label %242, label %398
242: ; preds = %239
%243 = icmp eq i64 %2, 0
%244 = call i64 @llvm.umax.i64(i64 %10, i64 2)
%245 = shl i64 %2, 1
%246 = mul i64 %240, %2
%247 = mul i64 %2, %1
%248 = add i64 %2, -2
%249 = lshr i64 %248, 1
%250 = add nuw i64 %249, 1
%251 = icmp ne i64 %2, 1
%252 = icmp eq i64 %0, 1
%253 = and i1 %251, %252
%254 = and i64 %2, -2
%255 = and i64 %250, 1
%256 = icmp ult i64 %248, 2
%257 = and i64 %250, -2
%258 = icmp eq i64 %255, 0
%259 = icmp eq i64 %254, %2
br label %260
260: ; preds = %242, %393
%261 = phi i64 [ 0, %242 ], [ %397, %393 ]
%262 = phi i64 [ 1, %242 ], [ %394, %393 ]
%263 = phi i64 [ %240, %242 ], [ %395, %393 ]
%264 = mul i64 %261, %2
%265 = add i64 %264, %2
%266 = getelementptr double, double* %4, i64 %265
%267 = add i64 %245, %264
%268 = getelementptr double, double* %4, i64 %267
%269 = mul i64 %261, %2
%270 = sub i64 %246, %269
%271 = getelementptr double, double* %4, i64 %270
%272 = sub i64 %247, %269
%273 = getelementptr double, double* %4, i64 %272
%274 = getelementptr double, double* %5, i64 %270
%275 = getelementptr double, double* %5, i64 %272
%276 = getelementptr double, double* %5, i64 %265
%277 = getelementptr double, double* %5, i64 %267
br i1 %243, label %393, label %278
278: ; preds = %260
%279 = mul i64 %263, %2
%280 = mul i64 %262, %2
br i1 %253, label %281, label %373
281: ; preds = %278
%282 = icmp ult double* %266, %273
%283 = icmp ult double* %271, %268
%284 = and i1 %282, %283
%285 = icmp ult double* %266, %275
%286 = icmp ult double* %274, %268
%287 = and i1 %285, %286
%288 = or i1 %284, %287
%289 = icmp ult double* %266, %277
%290 = icmp ult double* %276, %268
%291 = and i1 %289, %290
%292 = or i1 %288, %291
%293 = icmp ult double* %271, %275
%294 = icmp ult double* %274, %273
%295 = and i1 %293, %294
%296 = or i1 %292, %295
%297 = icmp ult double* %271, %277
%298 = icmp ult double* %276, %273
%299 = and i1 %297, %298
%300 = or i1 %296, %299
br i1 %300, label %373, label %301
301: ; preds = %281
br i1 %256, label %349, label %302
302: ; preds = %301, %302
%303 = phi i64 [ %346, %302 ], [ 0, %301 ]
%304 = phi i64 [ %347, %302 ], [ 0, %301 ]
%305 = add i64 %303, %279
%306 = mul i64 %305, %0
%307 = getelementptr inbounds double, double* %5, i64 %306
%308 = bitcast double* %307 to <2 x double>*
%309 = load <2 x double>, <2 x double>* %308
%310 = add i64 %303, %280
%311 = mul i64 %310, %0
%312 = getelementptr inbounds double, double* %5, i64 %311
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = fadd <2 x double> %309, %314
%316 = getelementptr inbounds double, double* %4, i64 %311
%317 = bitcast double* %316 to <2 x double>*
store <2 x double> %315, <2 x double>* %317
%318 = bitcast double* %307 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = bitcast double* %312 to <2 x double>*
%321 = load <2 x double>, <2 x double>* %320
%322 = fsub <2 x double> %319, %321
%323 = getelementptr inbounds double, double* %4, i64 %306
%324 = bitcast double* %323 to <2 x double>*
store <2 x double> %322, <2 x double>* %324
%325 = or i64 %303, 2
%326 = add i64 %325, %279
%327 = mul i64 %326, %0
%328 = getelementptr inbounds double, double* %5, i64 %327
%329 = bitcast double* %328 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329
%331 = add i64 %325, %280
%332 = mul i64 %331, %0
%333 = getelementptr inbounds double, double* %5, i64 %332
%334 = bitcast double* %333 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = fadd <2 x double> %330, %335
%337 = getelementptr inbounds double, double* %4, i64 %332
%338 = bitcast double* %337 to <2 x double>*
store <2 x double> %336, <2 x double>* %338
%339 = bitcast double* %328 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = bitcast double* %333 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = fsub <2 x double> %340, %342
%344 = getelementptr inbounds double, double* %4, i64 %327
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> %343, <2 x double>* %345
%346 = add nuw i64 %303, 4
%347 = add nuw i64 %304, 2
%348 = icmp eq i64 %347, %257
br i1 %348, label %349, label %302
349: ; preds = %302, %301
%350 = phi i64 [ 0, %301 ], [ %346, %302 ]
br i1 %258, label %372, label %351
351: ; preds = %349
%352 = add i64 %350, %279
%353 = mul i64 %352, %0
%354 = getelementptr inbounds double, double* %5, i64 %353
%355 = bitcast double* %354 to <2 x double>*
%356 = load <2 x double>, <2 x double>* %355
%357 = add i64 %350, %280
%358 = mul i64 %357, %0
%359 = getelementptr inbounds double, double* %5, i64 %358
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = fadd <2 x double> %356, %361
%363 = getelementptr inbounds double, double* %4, i64 %358
%364 = bitcast double* %363 to <2 x double>*
store <2 x double> %362, <2 x double>* %364
%365 = bitcast double* %354 to <2 x double>*
%366 = load <2 x double>, <2 x double>* %365
%367 = bitcast double* %359 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = fsub <2 x double> %366, %368
%370 = getelementptr inbounds double, double* %4, i64 %353
%371 = bitcast double* %370 to <2 x double>*
store <2 x double> %369, <2 x double>* %371
br label %372
372: ; preds = %349, %351
br i1 %259, label %393, label %373
373: ; preds = %281, %278, %372
%374 = phi i64 [ 0, %281 ], [ 0, %278 ], [ %254, %372 ]
br label %375
375: ; preds = %373, %375
%376 = phi i64 [ %391, %375 ], [ %374, %373 ]
%377 = add i64 %376, %279
%378 = mul i64 %377, %0
%379 = getelementptr inbounds double, double* %5, i64 %378
%380 = load double, double* %379
%381 = add i64 %376, %280
%382 = mul i64 %381, %0
%383 = getelementptr inbounds double, double* %5, i64 %382
%384 = load double, double* %383
%385 = fadd double %380, %384
%386 = getelementptr inbounds double, double* %4, i64 %382
store double %385, double* %386
%387 = load double, double* %379
%388 = load double, double* %383
%389 = fsub double %387, %388
%390 = getelementptr inbounds double, double* %4, i64 %378
store double %389, double* %390
%391 = add nuw i64 %376, 1
%392 = icmp eq i64 %391, %2
br i1 %392, label %393, label %375
393: ; preds = %375, %372, %260
%394 = add nuw nsw i64 %262, 1
%395 = add i64 %263, -1
%396 = icmp eq i64 %394, %244
%397 = add i64 %261, 1
br i1 %396, label %398, label %260
398: ; preds = %393, %237, %239
%399 = phi i1 [ false, %237 ], [ false, %239 ], [ %241, %393 ]
%400 = phi i64 [ %238, %237 ], [ %240, %239 ], [ %240, %393 ]
%401 = shl i64 %1, 1
%402 = trunc i64 %1 to i32
%403 = shl i32 %402, 4
%404 = tail call i64 @util_malloc_(i32 %403)
%405 = inttoptr i64 %404 to double*
%406 = uitofp i64 %1 to double
%407 = fdiv double 0x401921FB54442D18, %406
%408 = inttoptr i64 %404 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 0.000000e+00>, <2 x double>* %408
%409 = fptoui double %407 to i64
%410 = tail call double @cos(i64 %409)
%411 = add i64 %401, -2
%412 = getelementptr inbounds double, double* %405, i64 %411
store double %410, double* %412
%413 = getelementptr inbounds double, double* %405, i64 2
store double %410, double* %413
%414 = tail call double @sin(i64 %409)
%415 = getelementptr inbounds double, double* %405, i64 3
store double %414, double* %415
%416 = fneg double %414
%417 = add i64 %401, -1
%418 = getelementptr inbounds double, double* %405, i64 %417
store double %416, double* %418
%419 = icmp ult i64 %1, 4
br i1 %419, label %422, label %420
420: ; preds = %398
%421 = lshr i64 %1, 1
br label %464
422: ; preds = %464, %398
br i1 %399, label %425, label %423
423: ; preds = %422
%424 = tail call i32 @util_free_(double* %405)
br label %870
425: ; preds = %422
%426 = icmp eq i64 %3, 0
%427 = mul i64 %400, %3
%428 = add i64 %1, -2
%429 = icmp ugt i64 %9, 5
%430 = call i64 @llvm.umax.i64(i64 %10, i64 3)
%431 = call i64 @llvm.umax.i64(i64 %10, i64 2)
%432 = shl i64 %3, 1
%433 = shl i64 %400, 3
%434 = add i64 %433, 8
%435 = mul i64 %434, %3
%436 = mul i64 %3, 3
%437 = mul i64 %428, %3
%438 = shl i64 %1, 3
%439 = add i64 %438, -8
%440 = mul i64 %439, %3
%441 = shl i64 %3, 1
%442 = shl i64 %400, 3
%443 = add i64 %442, 8
%444 = mul i64 %443, %3
%445 = getelementptr double, double* %4, i64 %3
%446 = bitcast double* %445 to i8*
%447 = getelementptr double, double* %4, i64 %441
%448 = getelementptr double, double* %4, i64 %427
%449 = bitcast double* %448 to i8*
%450 = getelementptr i8, i8* %8, i64 %444
%451 = add i64 %3, -2
%452 = lshr i64 %451, 1
%453 = add nuw i64 %452, 1
%454 = icmp eq i64 %3, 1
%455 = and i64 %3, -2
%456 = and i64 %453, 1
%457 = icmp ult i64 %451, 2
%458 = and i64 %453, -2
%459 = icmp eq i64 %456, 0
%460 = icmp eq i64 %455, %3
%461 = icmp eq i64 %3, 1
%462 = and i64 %3, -2
%463 = icmp eq i64 %462, %3
br label %482
464: ; preds = %420, %464
%465 = phi i64 [ %480, %464 ], [ 2, %420 ]
%466 = uitofp i64 %465 to double
%467 = fmul double %407, %466
%468 = fptoui double %467 to i64
%469 = tail call double @cos(i64 %468)
%470 = shl i64 %465, 1
%471 = sub i64 %401, %470
%472 = getelementptr inbounds double, double* %405, i64 %471
store double %469, double* %472
%473 = getelementptr inbounds double, double* %405, i64 %470
store double %469, double* %473
%474 = tail call double @sin(i64 %468)
%475 = or i64 %470, 1
%476 = getelementptr inbounds double, double* %405, i64 %475
store double %474, double* %476
%477 = fneg double %474
%478 = or i64 %471, 1
%479 = getelementptr inbounds double, double* %405, i64 %478
store double %477, double* %479
%480 = add nuw i64 %465, 1
%481 = icmp eq i64 %465, %421
br i1 %481, label %422, label %464
482: ; preds = %425, %754
%483 = phi i64 [ 0, %425 ], [ %758, %754 ]
%484 = phi i64 [ 1, %425 ], [ %755, %754 ]
%485 = phi i64 [ %400, %425 ], [ %756, %754 ]
%486 = mul i64 %483, %3
%487 = add i64 %486, %3
%488 = getelementptr double, double* %5, i64 %487
%489 = bitcast double* %488 to i8*
%490 = add i64 %441, %486
%491 = getelementptr double, double* %5, i64 %490
%492 = mul i64 %483, %3
%493 = sub i64 0, %492
%494 = sub i64 %427, %492
%495 = getelementptr double, double* %5, i64 %494
%496 = bitcast double* %495 to i8*
%497 = getelementptr double, double* %5, i64 %493
%498 = bitcast double* %497 to i8*
%499 = getelementptr i8, i8* %498, i64 %444
%500 = mul i64 %483, %3
%501 = add i64 %500, %3
%502 = getelementptr double, double* %5, i64 %501
%503 = bitcast double* %502 to i8*
%504 = add i64 %432, %500
%505 = getelementptr double, double* %5, i64 %504
%506 = mul i64 %483, %3
%507 = sub i64 0, %506
%508 = sub i64 %427, %506
%509 = getelementptr double, double* %5, i64 %508
%510 = bitcast double* %509 to i8*
%511 = getelementptr double, double* %5, i64 %507
%512 = bitcast double* %511 to i8*
%513 = getelementptr i8, i8* %512, i64 %435
%514 = shl nuw i64 %484, 1
%515 = getelementptr inbounds double, double* %405, i64 %514
%516 = load double, double* %515
%517 = or i64 %514, 1
%518 = getelementptr inbounds double, double* %405, i64 %517
%519 = load double, double* %518
br i1 %426, label %644, label %520
520: ; preds = %482
%521 = mul i64 %484, %3
%522 = mul i64 %485, %3
br i1 %454, label %624, label %523
523: ; preds = %520
%524 = icmp ugt i8* %499, %489
%525 = icmp ult double* %495, %491
%526 = and i1 %524, %525
%527 = icmp ult double* %488, %445
%528 = icmp ugt double* %491, %4
%529 = and i1 %527, %528
%530 = or i1 %526, %529
%531 = icmp ult double* %488, %447
%532 = icmp ult double* %445, %491
%533 = and i1 %531, %532
%534 = or i1 %530, %533
%535 = icmp ugt i8* %450, %489
%536 = icmp ult double* %448, %491
%537 = and i1 %535, %536
%538 = or i1 %534, %537
%539 = icmp ult double* %495, %445
%540 = icmp ugt i8* %499, %8
%541 = and i1 %539, %540
%542 = or i1 %538, %541
%543 = icmp ult double* %495, %447
%544 = icmp ugt i8* %499, %446
%545 = and i1 %543, %544
%546 = or i1 %542, %545
%547 = icmp ugt i8* %450, %496
%548 = icmp ugt i8* %499, %449
%549 = and i1 %547, %548
%550 = or i1 %546, %549
br i1 %550, label %624, label %551
551: ; preds = %523
%552 = insertelement <2 x double> poison, double %516, i64 0
%553 = shufflevector <2 x double> %552, <2 x double> poison, <2 x i32> zeroinitializer
%554 = insertelement <2 x double> poison, double %519, i64 0
%555 = shufflevector <2 x double> %554, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %457, label %601, label %556
556: ; preds = %551, %556
%557 = phi i64 [ %598, %556 ], [ 0, %551 ]
%558 = phi i64 [ %599, %556 ], [ 0, %551 ]
%559 = getelementptr inbounds double, double* %4, i64 %557
%560 = bitcast double* %559 to <2 x double>*
%561 = load <2 x double>, <2 x double>* %560
%562 = add i64 %557, %3
%563 = getelementptr inbounds double, double* %4, i64 %562
%564 = bitcast double* %563 to <2 x double>*
%565 = load <2 x double>, <2 x double>* %564
%566 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %553, <2 x double> %565, <2 x double> %561)
%567 = add i64 %557, %521
%568 = getelementptr inbounds double, double* %5, i64 %567
%569 = bitcast double* %568 to <2 x double>*
store <2 x double> %566, <2 x double>* %569
%570 = add i64 %557, %427
%571 = getelementptr inbounds double, double* %4, i64 %570
%572 = bitcast double* %571 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = fmul <2 x double> %555, %573
%575 = add i64 %557, %522
%576 = getelementptr inbounds double, double* %5, i64 %575
%577 = bitcast double* %576 to <2 x double>*
store <2 x double> %574, <2 x double>* %577
%578 = or i64 %557, 2
%579 = getelementptr inbounds double, double* %4, i64 %578
%580 = bitcast double* %579 to <2 x double>*
%581 = load <2 x double>, <2 x double>* %580
%582 = add i64 %578, %3
%583 = getelementptr inbounds double, double* %4, i64 %582
%584 = bitcast double* %583 to <2 x double>*
%585 = load <2 x double>, <2 x double>* %584
%586 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %553, <2 x double> %585, <2 x double> %581)
%587 = add i64 %578, %521
%588 = getelementptr inbounds double, double* %5, i64 %587
%589 = bitcast double* %588 to <2 x double>*
store <2 x double> %586, <2 x double>* %589
%590 = add i64 %578, %427
%591 = getelementptr inbounds double, double* %4, i64 %590
%592 = bitcast double* %591 to <2 x double>*
%593 = load <2 x double>, <2 x double>* %592
%594 = fmul <2 x double> %555, %593
%595 = add i64 %578, %522
%596 = getelementptr inbounds double, double* %5, i64 %595
%597 = bitcast double* %596 to <2 x double>*
store <2 x double> %594, <2 x double>* %597
%598 = add nuw i64 %557, 4
%599 = add nuw i64 %558, 2
%600 = icmp eq i64 %599, %458
br i1 %600, label %601, label %556
601: ; preds = %556, %551
%602 = phi i64 [ 0, %551 ], [ %598, %556 ]
br i1 %459, label %623, label %603
603: ; preds = %601
%604 = getelementptr inbounds double, double* %4, i64 %602
%605 = bitcast double* %604 to <2 x double>*
%606 = load <2 x double>, <2 x double>* %605
%607 = add i64 %602, %3
%608 = getelementptr inbounds double, double* %4, i64 %607
%609 = bitcast double* %608 to <2 x double>*
%610 = load <2 x double>, <2 x double>* %609
%611 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %553, <2 x double> %610, <2 x double> %606)
%612 = add i64 %602, %521
%613 = getelementptr inbounds double, double* %5, i64 %612
%614 = bitcast double* %613 to <2 x double>*
store <2 x double> %611, <2 x double>* %614
%615 = add i64 %602, %427
%616 = getelementptr inbounds double, double* %4, i64 %615
%617 = bitcast double* %616 to <2 x double>*
%618 = load <2 x double>, <2 x double>* %617
%619 = fmul <2 x double> %555, %618
%620 = add i64 %602, %522
%621 = getelementptr inbounds double, double* %5, i64 %620
%622 = bitcast double* %621 to <2 x double>*
store <2 x double> %619, <2 x double>* %622
br label %623
623: ; preds = %601, %603
br i1 %460, label %644, label %624
624: ; preds = %523, %520, %623
%625 = phi i64 [ 0, %523 ], [ 0, %520 ], [ %455, %623 ]
br label %626
626: ; preds = %624, %626
%627 = phi i64 [ %642, %626 ], [ %625, %624 ]
%628 = getelementptr inbounds double, double* %4, i64 %627
%629 = load double, double* %628
%630 = add i64 %627, %3
%631 = getelementptr inbounds double, double* %4, i64 %630
%632 = load double, double* %631
%633 = tail call double @llvm.fmuladd.f64(double %516, double %632, double %629)
%634 = add i64 %627, %521
%635 = getelementptr inbounds double, double* %5, i64 %634
store double %633, double* %635
%636 = add i64 %627, %427
%637 = getelementptr inbounds double, double* %4, i64 %636
%638 = load double, double* %637
%639 = fmul double %519, %638
%640 = add i64 %627, %522
%641 = getelementptr inbounds double, double* %5, i64 %640
store double %639, double* %641
%642 = add nuw i64 %627, 1
%643 = icmp eq i64 %642, %3
br i1 %643, label %644, label %626
644: ; preds = %626, %623, %482
br i1 %429, label %645, label %754
645: ; preds = %644
%646 = mul i64 %484, %3
%647 = mul i64 %485, %3
%648 = icmp ugt i8* %513, %503
%649 = icmp ult double* %509, %505
%650 = and i1 %648, %649
br label %651
651: ; preds = %645, %749
%652 = phi i64 [ 0, %645 ], [ %753, %749 ]
%653 = phi i64 [ %514, %645 ], [ %673, %749 ]
%654 = phi i64 [ 2, %645 ], [ %750, %749 ]
%655 = phi i64 [ %428, %645 ], [ %751, %749 ]
%656 = mul i64 %652, %3
%657 = add i64 %432, %656
%658 = getelementptr double, double* %4, i64 %657
%659 = bitcast double* %658 to i8*
%660 = add i64 %436, %656
%661 = getelementptr double, double* %4, i64 %660
%662 = mul i64 %652, %3
%663 = sub i64 0, %662
%664 = sub i64 %437, %662
%665 = getelementptr double, double* %4, i64 %664
%666 = bitcast double* %665 to i8*
%667 = getelementptr double, double* %4, i64 %663
%668 = bitcast double* %667 to i8*
%669 = getelementptr i8, i8* %668, i64 %440
%670 = add i64 %653, %514
%671 = icmp ult i64 %670, %401
%672 = select i1 %671, i64 0, i64 %401
%673 = sub i64 %670, %672
%674 = getelementptr inbounds double, double* %405, i64 %673
%675 = load double, double* %674
%676 = add i64 %673, 1
%677 = getelementptr inbounds double, double* %405, i64 %676
%678 = load double, double* %677
br i1 %426, label %749, label %679
679: ; preds = %651
%680 = mul i64 %654, %3
%681 = mul i64 %655, %3
br i1 %461, label %729, label %682
682: ; preds = %679
%683 = icmp ult double* %502, %661
%684 = icmp ult double* %658, %505
%685 = and i1 %683, %684
%686 = or i1 %650, %685
%687 = icmp ugt i8* %669, %503
%688 = icmp ult double* %665, %505
%689 = and i1 %687, %688
%690 = or i1 %686, %689
%691 = icmp ult double* %509, %661
%692 = icmp ugt i8* %513, %659
%693 = and i1 %691, %692
%694 = or i1 %690, %693
%695 = icmp ugt i8* %669, %510
%696 = icmp ugt i8* %513, %666
%697 = and i1 %695, %696
%698 = or i1 %694, %697
br i1 %698, label %729, label %699
699: ; preds = %682
%700 = insertelement <2 x double> poison, double %675, i64 0
%701 = shufflevector <2 x double> %700, <2 x double> poison, <2 x i32> zeroinitializer
%702 = insertelement <2 x double> poison, double %678, i64 0
%703 = shufflevector <2 x double> %702, <2 x double> poison, <2 x i32> zeroinitializer
br label %704
704: ; preds = %704, %699
%705 = phi i64 [ 0, %699 ], [ %726, %704 ]
%706 = add i64 %705, %680
%707 = getelementptr inbounds double, double* %4, i64 %706
%708 = bitcast double* %707 to <2 x double>*
%709 = load <2 x double>, <2 x double>* %708
%710 = add i64 %705, %646
%711 = getelementptr inbounds double, double* %5, i64 %710
%712 = bitcast double* %711 to <2 x double>*
%713 = load <2 x double>, <2 x double>* %712
%714 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %701, <2 x double> %709, <2 x double> %713)
%715 = bitcast double* %711 to <2 x double>*
store <2 x double> %714, <2 x double>* %715
%716 = add i64 %705, %681
%717 = getelementptr inbounds double, double* %4, i64 %716
%718 = bitcast double* %717 to <2 x double>*
%719 = load <2 x double>, <2 x double>* %718
%720 = add i64 %705, %647
%721 = getelementptr inbounds double, double* %5, i64 %720
%722 = bitcast double* %721 to <2 x double>*
%723 = load <2 x double>, <2 x double>* %722
%724 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %703, <2 x double> %719, <2 x double> %723)
%725 = bitcast double* %721 to <2 x double>*
store <2 x double> %724, <2 x double>* %725
%726 = add nuw i64 %705, 2
%727 = icmp eq i64 %726, %462
br i1 %727, label %728, label %704
728: ; preds = %704
br i1 %463, label %749, label %729
729: ; preds = %682, %679, %728
%730 = phi i64 [ 0, %682 ], [ 0, %679 ], [ %462, %728 ]
br label %731
731: ; preds = %729, %731
%732 = phi i64 [ %747, %731 ], [ %730, %729 ]
%733 = add i64 %732, %680
%734 = getelementptr inbounds double, double* %4, i64 %733
%735 = load double, double* %734
%736 = add i64 %732, %646
%737 = getelementptr inbounds double, double* %5, i64 %736
%738 = load double, double* %737
%739 = tail call double @llvm.fmuladd.f64(double %675, double %735, double %738)
store double %739, double* %737
%740 = add i64 %732, %681
%741 = getelementptr inbounds double, double* %4, i64 %740
%742 = load double, double* %741
%743 = add i64 %732, %647
%744 = getelementptr inbounds double, double* %5, i64 %743
%745 = load double, double* %744
%746 = tail call double @llvm.fmuladd.f64(double %678, double %742, double %745)
store double %746, double* %744
%747 = add nuw i64 %732, 1
%748 = icmp eq i64 %747, %3
br i1 %748, label %749, label %731
749: ; preds = %731, %728, %651
%750 = add nuw nsw i64 %654, 1
%751 = add i64 %655, -1
%752 = icmp eq i64 %750, %430
%753 = add i64 %652, 1
br i1 %752, label %754, label %651
754: ; preds = %749, %644
%755 = add nuw nsw i64 %484, 1
%756 = add i64 %485, -1
%757 = icmp eq i64 %755, %431
%758 = add i64 %483, 1
br i1 %757, label %759, label %482
759: ; preds = %754
%760 = tail call i32 @util_free_(double* %405)
br i1 %399, label %761, label %870
761: ; preds = %759
%762 = icmp eq i64 %3, 0
%763 = call i64 @llvm.umax.i64(i64 %10, i64 2)
%764 = getelementptr double, double* %5, i64 %3
%765 = shl i64 %3, 1
%766 = add i64 %3, -4
%767 = lshr i64 %766, 2
%768 = add nuw nsw i64 %767, 1
%769 = icmp ult i64 %3, 4
%770 = and i64 %3, -4
%771 = and i64 %768, 1
%772 = icmp ult i64 %766, 4
%773 = and i64 %768, 9223372036854775806
%774 = icmp eq i64 %771, 0
%775 = icmp eq i64 %770, %3
%776 = and i64 %3, 1
%777 = icmp eq i64 %776, 0
%778 = sub i64 0, %3
br label %779
779: ; preds = %761, %891
%780 = phi i64 [ 0, %761 ], [ %894, %891 ]
%781 = phi i64 [ 1, %761 ], [ %892, %891 ]
%782 = mul i64 %780, %3
%783 = add i64 %782, %3
%784 = getelementptr double, double* %4, i64 %783
%785 = add i64 %765, %782
%786 = getelementptr double, double* %4, i64 %785
br i1 %762, label %891, label %787
787: ; preds = %779
%788 = mul i64 %781, %3
br i1 %769, label %856, label %789
789: ; preds = %787
%790 = icmp ugt double* %786, %5
%791 = icmp ult double* %784, %764
%792 = and i1 %790, %791
br i1 %792, label %856, label %793
793: ; preds = %789
br i1 %772, label %835, label %794
794: ; preds = %793, %794
%795 = phi i64 [ %832, %794 ], [ 0, %793 ]
%796 = phi i64 [ %833, %794 ], [ 0, %793 ]
%797 = add i64 %795, %788
%798 = getelementptr inbounds double, double* %4, i64 %797
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = getelementptr inbounds double, double* %798, i64 2
%802 = bitcast double* %801 to <2 x double>*
%803 = load <2 x double>, <2 x double>* %802
%804 = getelementptr inbounds double, double* %5, i64 %795
%805 = bitcast double* %804 to <2 x double>*
%806 = load <2 x double>, <2 x double>* %805
%807 = getelementptr inbounds double, double* %804, i64 2
%808 = bitcast double* %807 to <2 x double>*
%809 = load <2 x double>, <2 x double>* %808
%810 = fadd <2 x double> %800, %806
%811 = fadd <2 x double> %803, %809
%812 = bitcast double* %804 to <2 x double>*
store <2 x double> %810, <2 x double>* %812
%813 = bitcast double* %807 to <2 x double>*
store <2 x double> %811, <2 x double>* %813
%814 = or i64 %795, 4
%815 = add i64 %814, %788
%816 = getelementptr inbounds double, double* %4, i64 %815
%817 = bitcast double* %816 to <2 x double>*
%818 = load <2 x double>, <2 x double>* %817
%819 = getelementptr inbounds double, double* %816, i64 2
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = getelementptr inbounds double, double* %5, i64 %814
%823 = bitcast double* %822 to <2 x double>*
%824 = load <2 x double>, <2 x double>* %823
%825 = getelementptr inbounds double, double* %822, i64 2
%826 = bitcast double* %825 to <2 x double>*
%827 = load <2 x double>, <2 x double>* %826
%828 = fadd <2 x double> %818, %824
%829 = fadd <2 x double> %821, %827
%830 = bitcast double* %822 to <2 x double>*
store <2 x double> %828, <2 x double>* %830
%831 = bitcast double* %825 to <2 x double>*
store <2 x double> %829, <2 x double>* %831
%832 = add nuw i64 %795, 8
%833 = add i64 %796, 2
%834 = icmp eq i64 %833, %773
br i1 %834, label %835, label %794
835: ; preds = %794, %793
%836 = phi i64 [ 0, %793 ], [ %832, %794 ]
br i1 %774, label %855, label %837
837: ; preds = %835
%838 = add i64 %836, %788
%839 = getelementptr inbounds double, double* %4, i64 %838
%840 = bitcast double* %839 to <2 x double>*
%841 = load <2 x double>, <2 x double>* %840
%842 = getelementptr inbounds double, double* %839, i64 2
%843 = bitcast double* %842 to <2 x double>*
%844 = load <2 x double>, <2 x double>* %843
%845 = getelementptr inbounds double, double* %5, i64 %836
%846 = bitcast double* %845 to <2 x double>*
%847 = load <2 x double>, <2 x double>* %846
%848 = getelementptr inbounds double, double* %845, i64 2
%849 = bitcast double* %848 to <2 x double>*
%850 = load <2 x double>, <2 x double>* %849
%851 = fadd <2 x double> %841, %847
%852 = fadd <2 x double> %844, %850
%853 = bitcast double* %845 to <2 x double>*
store <2 x double> %851, <2 x double>* %853
%854 = bitcast double* %848 to <2 x double>*
store <2 x double> %852, <2 x double>* %854
br label %855
855: ; preds = %835, %837
br i1 %775, label %891, label %856
856: ; preds = %789, %787, %855
%857 = phi i64 [ 0, %789 ], [ 0, %787 ], [ %770, %855 ]
%858 = xor i64 %857, -1
br i1 %777, label %867, label %859
859: ; preds = %856
%860 = add i64 %857, %788
%861 = getelementptr inbounds double, double* %4, i64 %860
%862 = load double, double* %861
%863 = getelementptr inbounds double, double* %5, i64 %857
%864 = load double, double* %863
%865 = fadd double %862, %864
store double %865, double* %863
%866 = or i64 %857, 1
br label %867
867: ; preds = %859, %856
%868 = phi i64 [ %857, %856 ], [ %866, %859 ]
%869 = icmp eq i64 %858, %778
br i1 %869, label %891, label %874
870: ; preds = %891, %423, %759
%871 = icmp eq i64 %2, 0
br i1 %871, label %895, label %872
872: ; preds = %870
%873 = shl i64 %0, 3
br label %899
874: ; preds = %867, %874
%875 = phi i64 [ %889, %874 ], [ %868, %867 ]
%876 = add i64 %875, %788
%877 = getelementptr inbounds double, double* %4, i64 %876
%878 = load double, double* %877
%879 = getelementptr inbounds double, double* %5, i64 %875
%880 = load double, double* %879
%881 = fadd double %878, %880
store double %881, double* %879
%882 = add nuw i64 %875, 1
%883 = add i64 %882, %788
%884 = getelementptr inbounds double, double* %4, i64 %883
%885 = load double, double* %884
%886 = getelementptr inbounds double, double* %5, i64 %882
%887 = load double, double* %886
%888 = fadd double %885, %887
store double %888, double* %886
%889 = add nuw i64 %875, 2
%890 = icmp eq i64 %889, %3
br i1 %890, label %891, label %874
891: ; preds = %867, %874, %855, %779
%892 = add nuw nsw i64 %781, 1
%893 = icmp eq i64 %892, %763
%894 = add i64 %780, 1
br i1 %893, label %870, label %779
895: ; preds = %899, %870
br i1 %399, label %896, label %938
896: ; preds = %895
%897 = add i64 %0, -1
%898 = call i64 @llvm.umax.i64(i64 %10, i64 2)
br label %908
899: ; preds = %872, %899
%900 = phi i64 [ 0, %872 ], [ %906, %899 ]
%901 = mul i64 %900, %0
%902 = mul i64 %901, %1
%903 = getelementptr inbounds double, double* %4, i64 %902
%904 = getelementptr inbounds double, double* %5, i64 %901
%905 = tail call i32 @memcpy(double* %903, double* %904, i64 %873)
%906 = add nuw i64 %900, 1
%907 = icmp eq i64 %906, %2
br i1 %907, label %895, label %899
908: ; preds = %896, %935
%909 = phi i64 [ 1, %896 ], [ %936, %935 ]
%910 = shl nuw i64 %909, 1
br i1 %871, label %935, label %911
911: ; preds = %908
%912 = sub i64 %1, %909
%913 = mul i64 %909, %2
%914 = mul i64 %912, %2
br label %915
915: ; preds = %911, %915
%916 = phi i64 [ 0, %911 ], [ %933, %915 ]
%917 = add i64 %916, %913
%918 = mul i64 %917, %0
%919 = getelementptr inbounds double, double* %5, i64 %918
%920 = load double, double* %919
%921 = mul i64 %916, %1
%922 = add i64 %921, %910
%923 = add i64 %922, -1
%924 = mul i64 %923, %0
%925 = add i64 %897, %924
%926 = getelementptr inbounds double, double* %4, i64 %925
store double %920, double* %926
%927 = add i64 %916, %914
%928 = mul i64 %927, %0
%929 = getelementptr inbounds double, double* %5, i64 %928
%930 = load double, double* %929
%931 = mul i64 %922, %0
%932 = getelementptr inbounds double, double* %4, i64 %931
store double %930, double* %932
%933 = add nuw i64 %916, 1
%934 = icmp eq i64 %933, %2
br i1 %934, label %935, label %915
935: ; preds = %915, %908
%936 = add nuw nsw i64 %909, 1
%937 = icmp eq i64 %936, %898
br i1 %937, label %938, label %908
938: ; preds = %935, %895
%939 = icmp ult i64 %9, 4
%940 = or i1 %11, %939
br i1 %940, label %1003, label %941
941: ; preds = %938
%942 = icmp ugt i64 %0, 2
%943 = call i64 @llvm.umax.i64(i64 %10, i64 2)
br label %944
944: ; preds = %941, %1000
%945 = phi i64 [ 1, %941 ], [ %1001, %1000 ]
%946 = shl nuw i64 %945, 1
br i1 %871, label %1000, label %947
947: ; preds = %944
%948 = sub i64 %1, %945
%949 = mul i64 %945, %2
%950 = mul i64 %948, %2
br label %951
951: ; preds = %947, %997
%952 = phi i64 [ 0, %947 ], [ %998, %997 ]
br i1 %942, label %953, label %997
953: ; preds = %951
%954 = add i64 %952, %949
%955 = mul i64 %954, %0
%956 = add i64 %952, %950
%957 = mul i64 %956, %0
%958 = mul i64 %952, %1
%959 = add i64 %958, %946
%960 = mul i64 %959, %0
%961 = add i64 %959, -1
%962 = mul i64 %961, %0
br label %963
963: ; preds = %953, %963
%964 = phi i64 [ 2, %953 ], [ %995, %963 ]
%965 = sub i64 %0, %964
%966 = add i64 %964, -1
%967 = add i64 %966, %955
%968 = getelementptr inbounds double, double* %5, i64 %967
%969 = load double, double* %968
%970 = add i64 %966, %957
%971 = getelementptr inbounds double, double* %5, i64 %970
%972 = load double, double* %971
%973 = fadd double %969, %972
%974 = add i64 %966, %960
%975 = getelementptr inbounds double, double* %4, i64 %974
store double %973, double* %975
%976 = load double, double* %968
%977 = load double, double* %971
%978 = fsub double %976, %977
%979 = add i64 %965, %962
%980 = add i64 %979, -1
%981 = getelementptr inbounds double, double* %4, i64 %980
store double %978, double* %981
%982 = add i64 %964, %957
%983 = getelementptr inbounds double, double* %5, i64 %982
%984 = load double, double* %983
%985 = add i64 %964, %955
%986 = getelementptr inbounds double, double* %5, i64 %985
%987 = load double, double* %986
%988 = fadd double %984, %987
%989 = add i64 %964, %960
%990 = getelementptr inbounds double, double* %4, i64 %989
store double %988, double* %990
%991 = load double, double* %983
%992 = load double, double* %986
%993 = fsub double %991, %992
%994 = getelementptr inbounds double, double* %4, i64 %979
store double %993, double* %994
%995 = add nuw i64 %964, 2
%996 = icmp ult i64 %995, %0
br i1 %996, label %963, label %997
997: ; preds = %963, %951
%998 = add nuw i64 %952, 1
%999 = icmp eq i64 %998, %2
br i1 %999, label %1000, label %951
1000: ; preds = %997, %944
%1001 = add nuw nsw i64 %945, 1
%1002 = icmp eq i64 %1001, %943
br i1 %1002, label %1003, label %944
1003: ; preds = %1000, %938
ret void
}