#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 int 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 radbg(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;
  for (k = 0; k < l1; k++)
    memcpy(&ch[(0) + ido * ((k) + l1 * (0))],
           &cc[(0) + ido * ((0) + cdim * (k))], ido * sizeof(double));
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    j2 = 2 * j;
    for (k = 0; k < l1; k++) {
      ch[(0) + ido * ((k) + l1 * (j))] =
          2 * cc[(ido - 1) + ido * ((j2 - 1) + cdim * (k))];
      ch[(0) + ido * ((k) + l1 * (jc))] =
          2 * cc[(0) + ido * ((j2) + cdim * (k))];
    }
  }
  if (ido != 1)
    for (j = 1, jc = ip - 1; j < ipph; j++, jc--)
      for (k = 0; k < l1; k++)
        for (i = 2; i < ido; i += 2) {
          ic = ido - i;
          {
            ch[(i - 1) + ido * ((k) + l1 * (j))] =
                cc[(i - 1) + ido * ((2 * j) + cdim * (k))] +
                cc[(ic - 1) + ido * ((2 * j - 1) + cdim * (k))];
            ch[(i - 1) + ido * ((k) + l1 * (jc))] =
                cc[(i - 1) + ido * ((2 * j) + cdim * (k))] -
                cc[(ic - 1) + ido * ((2 * j - 1) + cdim * (k))];
          }
          {
            ch[(i) + ido * ((k) + l1 * (jc))] =
                cc[(i) + ido * ((2 * j) + cdim * (k))] +
                cc[(ic) + ido * ((2 * j - 1) + cdim * (k))];
            ch[(i) + ido * ((k) + l1 * (j))] =
                cc[(i) + ido * ((2 * j) + cdim * (k))] -
                cc[(ic) + ido * ((2 * j - 1) + cdim * (k))];
          }
        }
  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; l < ipph; l++) {
    lc = ip - l;
    ar1 = csarr[2 * l];
    ai1 = csarr[2 * l + 1];
    for (ik = 0; ik < idl1; ik++) {
      cc[(ik) + idl1 * (l)] =
          ch[(ik) + idl1 * (0)] + ar1 * ch[(ik) + idl1 * (1)];
      cc[(ik) + idl1 * (lc)] = ai1 * ch[(ik) + idl1 * (ip - 1)];
    }
    aidx = 2 * l;
    for (j = 2; j < ipph; j++) {
      jc = ip - j;
      aidx += 2 * l;
      if (aidx >= 2 * ip)
        aidx -= 2 * ip;
      ar2 = csarr[aidx];
      ai2 = csarr[aidx + 1];
      for (ik = 0; ik < idl1; ik++) {
        cc[(ik) + idl1 * (l)] += ar2 * ch[(ik) + idl1 * (j)];
        cc[(ik) + idl1 * (lc)] += ai2 * ch[(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)] += ch[(ik) + idl1 * (j)];
  for (j = 1, jc = ip - 1; j < ipph; j++, jc--)
    for (k = 0; k < l1; k++) {
      ch[(0) + ido * ((k) + l1 * (jc))] =
          cc[(0) + ido * ((k) + l1 * (j))] + cc[(0) + ido * ((k) + l1 * (jc))];
      ch[(0) + ido * ((k) + l1 * (j))] =
          cc[(0) + ido * ((k) + l1 * (j))] - cc[(0) + ido * ((k) + l1 * (jc))];
    }
  if (ido == 1)
    return;
  for (j = 1, jc = ip - 1; j < ipph; j++, jc--)
    for (k = 0; k < l1; k++)
      for (i = 2; i < ido; i += 2) {
        {
          ch[(i - 1) + ido * ((k) + l1 * (jc))] =
              cc[(i - 1) + ido * ((k) + l1 * (j))] +
              cc[(i) + ido * ((k) + l1 * (jc))];
          ch[(i - 1) + ido * ((k) + l1 * (j))] =
              cc[(i - 1) + ido * ((k) + l1 * (j))] -
              cc[(i) + ido * ((k) + l1 * (jc))];
        }
        {
          ch[(i) + ido * ((k) + l1 * (j))] =
              cc[(i) + ido * ((k) + l1 * (j))] +
              cc[(i - 1) + ido * ((k) + l1 * (jc))];
          ch[(i) + ido * ((k) + l1 * (jc))] =
              cc[(i) + ido * ((k) + l1 * (j))] -
              cc[(i - 1) + ido * ((k) + l1 * (jc))];
        }
      }
  memcpy(cc, ch, idl1 * sizeof(double));
  for (j = 1; j < ip; j++)
    for (k = 0; k < l1; k++) {
      cc[(0) + ido * ((k) + l1 * (j))] = ch[(0) + ido * ((k) + l1 * (j))];
      idij = (j - 1) * ido + 1;
      for (i = 2; i < ido; i += 2, idij += 2) {
        cc[(i) + ido * ((k) + l1 * (j))] =
            wa[idij - 1] * ch[(i) + ido * ((k) + l1 * (j))] +
            wa[idij] * ch[(i - 1) + ido * ((k) + l1 * (j))];
        cc[(i - 1) + ido * ((k) + l1 * (j))] =
            wa[idij - 1] * ch[(i - 1) + ido * ((k) + l1 * (j))] -
            wa[idij] * ch[(i) + ido * ((k) + l1 * (j))];
      }
    }
}


x86 assembly (clang, -O0):
<radbg>:
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)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    120a <radbg+0xba>
mov    -0x30(%rbp),%rdi
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,%rdi
mov    -0x28(%rbp),%rsi
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,%rsi
mov    -0x8(%rbp),%rdx
shl    $0x3,%rdx
call   1060 <memcpy@plt>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1197 <radbg+0x47>
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1324 <radbg+0x1d4>
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    130e <radbg+0x1be>
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  0x1daf(%rip),%xmm0
mulsd  (%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    -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  0x1d5d(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
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  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1240 <radbg+0xf0>
jmp    1313 <radbg+0x1c3>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1212 <radbg+0xc2>
cmpq   $0x1,-0x8(%rbp)
je     15ff <radbg+0x4af>
movq   $0x1,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    15fa <radbg+0x4aa>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    15d8 <radbg+0x488>
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    15c2 <radbg+0x472>
mov    -0x8(%rbp),%rax
sub    -0x50(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
sub    $0x1,%rsi
mov    -0x38(%rbp),%rdi
imul   -0x60(%rbp),%rdi
add    %rdi,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
jmp    136f <radbg+0x21f>
jmp    15c7 <radbg+0x477>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1359 <radbg+0x209>
jmp    15dd <radbg+0x48d>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    1343 <radbg+0x1f3>
jmp    15ff <radbg+0x4af>
mov    -0x10(%rbp),%edi
shl    $0x4,%edi
call   1040 <util_malloc_@plt>
mov    %rax,-0xc0(%rbp)
movaps 0x19e8(%rip),%xmm0
movq   -0x10(%rbp),%xmm1
punpckldq %xmm0,%xmm1
movapd 0x19e7(%rip),%xmm0
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19e0(%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  0x19a9(%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     18d6 <radbg+0x786>
movq   -0x50(%rbp),%xmm0
movaps 0x1892(%rip),%xmm1
movaps %xmm1,-0x100(%rbp)
punpckldq %xmm1,%xmm0
movapd 0x188f(%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  0x186e(%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    174d <radbg+0x5fd>
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1bbb <radbg+0xa6b>
mov    -0x10(%rbp),%rax
sub    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
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    1a10 <radbg+0x8c0>
mov    -0x30(%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    -0x30(%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    -0x28(%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    -0x30(%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    -0x28(%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    193f <radbg+0x7ef>
mov    -0x68(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xc8(%rbp)
movq   $0x2,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1ba5 <radbg+0xa55>
mov    -0x10(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
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     1a88 <radbg+0x938>
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    1b8f <radbg+0xa3f>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%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    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x80(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%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    1aca <radbg+0x97a>
jmp    1b94 <radbg+0xa44>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1a27 <radbg+0x8d7>
jmp    1baa <radbg+0xa5a>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    18de <radbg+0x78e>
jmp    1bc0 <radbg+0xa70>
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    1c6f <radbg+0xb1f>
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1c59 <radbg+0xb09>
mov    -0x30(%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    1bf8 <radbg+0xaa8>
jmp    1c5e <radbg+0xb0e>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1bdf <radbg+0xa8f>
movq   $0x1,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1db8 <radbg+0xc68>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1d96 <radbg+0xc46>
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    -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
addsd  (%rax,%rcx,8),%xmm0
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  %xmm0,(%rax,%rcx,8)
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    -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
subsd  (%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    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1c99 <radbg+0xb49>
jmp    1d9b <radbg+0xc4b>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    1c83 <radbg+0xb33>
cmpq   $0x1,-0x8(%rbp)
jne    1dc8 <radbg+0xc78>
jmp    22b5 <radbg+0x1165>
movq   $0x1,-0x58(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    2057 <radbg+0xf07>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    2035 <radbg+0xee5>
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    201f <radbg+0xecf>
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
jmp    1e08 <radbg+0xcb8>
jmp    2024 <radbg+0xed4>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1df2 <radbg+0xca2>
jmp    203a <radbg+0xeea>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    1ddc <radbg+0xc8c>
mov    -0x28(%rbp),%rdi
mov    -0x30(%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    22b5 <radbg+0x1165>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    229f <radbg+0x114f>
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
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    2289 <radbg+0x1139>
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%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
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%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
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
jmp    20ff <radbg+0xfaf>
jmp    228e <radbg+0x113e>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    208a <radbg+0xf3a>
jmp    22a4 <radbg+0x1154>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2074 <radbg+0xf24>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%r13
mov    %r8,0x8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,%r15
mov    %rdi,0x18(%rsp)
mov    %rsi,0x80(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x98(%rsp)
test   %rdx,%rdx
je     11dc <radbg+0x8c>
mov    0x18(%rsp),%rax
lea    0x0(,%rax,8),%r12
mov    0x80(%rsp),%rcx
imul   %rax,%rcx
shl    $0x3,%rcx
mov    %rcx,0x70(%rsp)
mov    %r13,%rbx
mov    0x8(%rsp),%rbp
mov    %r15,%r14
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
call   1060 <memcpy@plt>
add    0x70(%rsp),%rbp
add    %r12,%rbx
add    $0xffffffffffffffff,%r14
jne    11c0 <radbg+0x70>
mov    0x98(%rsp),%rax
mov    %rax,%rcx
shr    %rcx
cmp    $0x4,%rax
mov    %rcx,0x110(%rsp)
jb     12ca <radbg+0x17a>
cmp    $0x3,%rcx
mov    $0x2,%r9d
cmovae %rcx,%r9
mov    %r15,%rax
mov    0x18(%rsp),%rbx
imul   %rbx,%rax
mov    0x80(%rsp),%r11
lea    -0x1(%r11),%r10
imul   %rax,%r10
lea    0x0(,%r10,8),%rdi
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,8),%r8
lea    0x0(,%rbx,8),%rcx
mov    %rbx,%rdx
shl    $0x4,%rdx
mov    0x8(%rsp),%rax
mov    %rdx,0x70(%rsp)
lea    (%rax,%rdx,1),%r14
imul   %rbx,%r11
shl    $0x3,%r11
mov    $0x1,%r12d
mov    %r8,%rdx
jmp    1284 <radbg+0x134>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
sub    %r8,%rdi
add    %r8,%rdx
add    0x70(%rsp),%r14
cmp    %r9,%r12
je     12d8 <radbg+0x188>
test   %r15,%r15
je     1270 <radbg+0x120>
mov    %r14,%rbp
mov    %r13,%rax
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rdx,1)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rdi,1)
add    %rcx,%rax
add    %r11,%rbp
add    $0xffffffffffffffff,%rsi
jne    12a0 <radbg+0x150>
jmp    1270 <radbg+0x120>
cmpq   $0x1,0x18(%rsp)
sete   %al
jmp    1422 <radbg+0x2d2>
cmp    $0x1,%rbx
sete   %al
je     1422 <radbg+0x2d2>
cmpq   $0x4,0x98(%rsp)
jb     1422 <radbg+0x2d2>
mov    0x110(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%edx
cmovae %rax,%rdx
mov    %rdx,0x10(%rsp)
mov    0x50(%rsp),%rax
lea    0x0(,%rax,8),%rbp
add    %r13,%rbp
shl    $0x3,%rax
lea    0x0(,%r10,8),%r14
add    %r13,%r14
mov    %rax,0x50(%rsp)
neg    %rax
mov    %rax,0x48(%rsp)
mov    0x8(%rsp),%rax
mov    0x70(%rsp),%rdx
lea    (%rax,%rdx,1),%r12
mov    $0x1,%esi
jmp    136e <radbg+0x21e>
nop
add    $0x1,%rsi
add    0x50(%rsp),%rbp
add    0x48(%rsp),%r14
add    0x70(%rsp),%r12
cmp    0x10(%rsp),%rsi
je     1420 <radbg+0x2d0>
test   %r15,%r15
je     1350 <radbg+0x200>
mov    %r12,%rdx
mov    %r14,%rdi
mov    %rbp,%rax
xor    %r8d,%r8d
jmp    13a2 <radbg+0x252>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %rcx,%rax
add    %rcx,%rdi
add    %r11,%rdx
cmp    %r15,%r8
je     1350 <radbg+0x200>
cmp    $0x3,%rbx
jb     1390 <radbg+0x240>
mov    $0x2,%r9d
mov    $0xfffffffffffffffe,%r10
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%r9,8),%xmm0
addsd  -0x8(%rdx,%r10,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r9,8)
movsd  -0x8(%rdx,%r9,8),%xmm0
subsd  -0x8(%rdx,%r10,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%r9,8)
movsd  (%rdx,%r9,8),%xmm0
addsd  (%rdx,%r10,8),%xmm0
movsd  %xmm0,(%rdi,%r9,8)
movsd  (%rdx,%r9,8),%xmm0
subsd  (%rdx,%r10,8),%xmm0
movsd  %xmm0,(%rax,%r9,8)
add    $0x2,%r9
add    $0xfffffffffffffffe,%r10
cmp    %rbx,%r9
jb     13c0 <radbg+0x270>
jmp    1390 <radbg+0x240>
xor    %eax,%eax
mov    %eax,0xcc(%rsp)
mov    0x80(%rsp),%r14
lea    (%r14,%r14,1),%rax
mov    %rax,0x28(%rsp)
mov    %r14d,%edi
shl    $0x4,%edi
call   1040 <util_malloc_@plt>
movq   %r14,%xmm0
punpckldq 0x1bae(%rip),%xmm0
subpd  0x1bb6(%rip),%xmm0
mov    %rax,%r12
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1bbf(%rip),%xmm2
divsd  %xmm1,%xmm2
movsd  0x1bbb(%rip),%xmm0
cvttsd2si %xmm2,%rax
movups %xmm0,(%r12)
mov    %rax,%rcx
sar    $0x3f,%rcx
movapd %xmm2,0x70(%rsp)
movapd %xmm2,%xmm0
subsd  0x1ba0(%rip),%xmm0
cvttsd2si %xmm0,%rbp
and    %rcx,%rbp
or     %rax,%rbp
mov    %rbp,%rdi
call   1070 <cos@plt>
mov    %r14,%rbx
shl    $0x4,%rbx
movsd  %xmm0,-0x10(%rbx,%r12,1)
movsd  %xmm0,0x10(%r12)
mov    %rbp,%rdi
call   1050 <sin@plt>
movsd  %xmm0,0x18(%r12)
xorpd  0x1b41(%rip),%xmm0
mov    %r12,0x10(%rsp)
movlpd %xmm0,-0x8(%rbx,%r12,1)
cmp    $0x4,%r14
jb     15c8 <radbg+0x478>
mov    0x80(%rsp),%rax
shr    %rax
mov    $0x1,%ecx
sub    %rax,%rcx
mov    %rcx,0x50(%rsp)
mov    0x10(%rsp),%rcx
lea    0x28(%rcx),%r12
mov    0x28(%rsp),%rax
lea    (%rcx,%rax,8),%r14
add    $0xffffffffffffffe8,%r14
mov    $0x2,%ebx
nopl   0x0(%rax,%rax,1)
movq   %rbx,%xmm0
punpckldq 0x1ac3(%rip),%xmm0
subpd  0x1acb(%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  0x1ad5(%rip),%xmm1
cvttsd2si %xmm1,%rbp
and    %rcx,%rbp
or     %rax,%rbp
mov    %rbp,%rdi
call   1070 <cos@plt>
movsd  %xmm0,-0x8(%r14)
movsd  %xmm0,-0x8(%r12)
mov    %rbp,%rdi
call   1050 <sin@plt>
movsd  %xmm0,(%r12)
xorpd  0x1a7f(%rip),%xmm0
movlpd %xmm0,(%r14)
mov    0x50(%rsp),%rax
add    %rbx,%rax
add    $0x1,%rax
add    $0x1,%rbx
add    $0x10,%r12
add    $0xfffffffffffffff0,%r14
cmp    $0x2,%rax
jne    1530 <radbg+0x3e0>
cmpq   $0x3,0x98(%rsp)
mov    %r13,0x68(%rsp)
mov    0x8(%rsp),%r9
mov    %r15,0x50(%rsp)
jbe    1e53 <radbg+0xd03>
mov    0x80(%rsp),%rcx
lea    -0x1(%rcx),%rdx
mov    %rdx,0x128(%rsp)
mov    %rdx,%rdi
mov    0x30(%rsp),%r14
imul   %r14,%rdi
mov    0x110(%rsp),%rdx
cmp    $0x4,%rdx
mov    $0x3,%r8d
cmovae %rdx,%r8
cmp    $0x3,%rdx
mov    $0x2,%esi
cmovae %rdx,%rsi
mov    %rsi,0x118(%rsp)
lea    (%r14,%r14,1),%rdx
mov    %rdx,0xa8(%rsp)
mov    %r14,%rdx
imul   %rcx,%rdx
lea    -0x2(%rcx),%rbp
imul   %r14,%rbp
lea    -0x8(,%rcx,8),%rcx
ff
imul   %r14,%rcx
mov    %rcx,0x100(%rsp)
mov    %r14,%rcx
shl    $0x4,%rcx
add    %r13,%rcx
mov    %rcx,0x140(%rsp)
lea    -0x2(%r14),%rcx
mov    %rcx,0x158(%rsp)
mov    %rcx,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x150(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x148(%rsp)
lea    0x0(,%r14,8),%r10
mov    %r10,%rbx
neg    %rbx
lea    (%r14,%r14,2),%rcx
mov    %rcx,0x58(%rsp)
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
mov    %rcx,0x130(%rsp)
lea    0x0(%r13,%rdi,8),%rcx
mov    %rcx,0x138(%rsp)
mov    %rdx,0x170(%rsp)
lea    0x0(%r13,%rdx,8),%rcx
mov    %rcx,0x160(%rsp)
lea    0x10(%r9,%r14,8),%rcx
lea    0x10(%r9,%rdi,8),%rax
lea    (%r9,%r14,8),%rsi
mov    %rbp,0x108(%rsp)
lea    0x0(%r13,%rbp,8),%rdx
mov    %rdx,0x168(%rsp)
lea    (%r9,%rdi,8),%rdx
mov    $0x1,%ebp
mov    %rbp,0x40(%rsp)
xor    %ebp,%ebp
mov    %r14,0xe0(%rsp)
mov    %rdi,0xd0(%rsp)
mov    %rdi,0xd8(%rsp)
mov    %r10,0x38(%rsp)
mov    0x28(%rsp),%r12
mov    %r8,0xa0(%rsp)
mov    %rbx,0x90(%rsp)
jmp    17cc <radbg+0x67c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%r9
add    $0x1,%r9
mov    0x120(%rsp),%rbp
add    $0x1,%rbp
mov    0xf0(%rsp),%rcx
add    %r10,%rcx
mov    0xe8(%rsp),%rax
add    %rbx,%rax
sub    %r14,0xd8(%rsp)
add    %r14,0xe0(%rsp)
add    %r10,%rsi
add    %rbx,%rdx
mov    %r9,%rdi
mov    %r9,0x40(%rsp)
cmp    0x118(%rsp),%r9
mov    0x50(%rsp),%r15
je     1e62 <radbg+0xd12>
mov    %rax,0xe8(%rsp)
mov    %rcx,0xf0(%rsp)
mov    %rbp,0x120(%rsp)
mov    %rbp,%rax
imul   %r14,%rax
lea    (%rax,%r14,1),%rcx
mov    0xa8(%rsp),%rdi
add    %rax,%rdi
mov    0xd0(%rsp),%rbp
sub    %rax,%rbp
mov    0x170(%rsp),%rbx
sub    %rax,%rbx
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
lea    (%rax,%rdi,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    (%rax,%rbp,8),%rcx
mov    %rcx,0x88(%rsp)
lea    (%rax,%rbx,8),%rax
mov    %rax,0xb0(%rsp)
test   %r14,%r14
je     18fc <radbg+0x7ac>
mov    0x40(%rsp),%rax
shl    $0x4,%rax
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,1),%xmm0
movsd  0x8(%rcx,%rax,1),%xmm1
cmp    $0x1,%r14
jne    1c00 <radbg+0xab0>
xor    %r8d,%r8d
mov    %r14,%r11
sub    %r8,%r11
mov    0xd8(%rsp),%rax
add    %r8,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,8),%r9
mov    0x138(%rsp),%rax
lea    (%rax,%r8,8),%rbp
mov    0xe0(%rsp),%rax
add    %r8,%rax
lea    (%rcx,%rax,8),%rcx
lea    (%r14,%r8,1),%rax
lea    0x0(,%rax,8),%rbx
add    %r13,%rbx
lea    0x0(,%r8,8),%rdi
add    %r13,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdi,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    18d0 <radbg+0x780>
cmpq   $0x6,0x98(%rsp)
mov    0xa0(%rsp),%r8
mov    0x90(%rsp),%rbx
jb     1770 <radbg+0x620>
mov    0x40(%rsp),%rax
lea    (%rax,%rax,1),%rbp
mov    0xb0(%rsp),%rax
cmp    %rax,0x60(%rsp)
setb   %al
mov    0x88(%rsp),%rcx
cmp    0xb8(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0xc0(%rsp)
mov    $0x2,%r11d
mov    0x168(%rsp),%rdi
mov    0x140(%rsp),%r9
xor    %r15d,%r15d
mov    %rbp,0x70(%rsp)
mov    %rbp,%rax
jmp    1997 <radbg+0x847>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
add    $0x1,%r15
add    %r10,%r9
add    %rbx,%rdi
cmp    %r8,%r11
je     1770 <radbg+0x620>
add    0x70(%rsp),%rax
cmp    %r12,%rax
mov    $0x0,%ebp
cmovae %r12,%rbp
sub    %rbp,%rax
test   %r14,%r14
je     1980 <radbg+0x830>
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  0x8(%rcx,%rax,8),%xmm1
cmp    $0x1,%r14
jne    1a10 <radbg+0x8c0>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rsi,%rbp,8),%xmm2
movsd  %xmm2,(%rsi,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rbp,8),%xmm2
movsd  %xmm2,(%rdx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    19d0 <radbg+0x880>
jmp    1980 <radbg+0x830>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rcx
imul   %r14,%rcx
mov    0xa8(%rsp),%rbp
lea    (%rcx,%rbp,1),%r10
mov    0x58(%rsp),%rbp
lea    (%rcx,%rbp,1),%r8
mov    0x108(%rsp),%rbx
sub    %rcx,%rbx
shl    $0x3,%rcx
mov    %r13,%rbp
sub    %rcx,%rbp
add    0x100(%rsp),%rbp
lea    0x0(,%r10,8),%r10
add    %r13,%r10
lea    0x0(,%r8,8),%r12
add    %r13,%r12
lea    0x0(,%rbx,8),%r8
add    %r13,%r8
mov    0x60(%rsp),%rbx
cmp    %r12,%rbx
setb   %r14b
mov    0xb8(%rsp),%rcx
cmp    %rcx,%r10
setb   %r13b
and    %r14b,%r13b
or     0xc0(%rsp),%r13b
cmp    %rbx,%rbp
seta   %bl
cmp    %rcx,%r8
setb   0x48(%rsp)
mov    0x88(%rsp),%rcx
cmp    %r12,%rcx
setb   %r14b
mov    0xb0(%rsp),%r12
cmp    %r12,%r10
setb   %r10b
cmp    %rcx,%rbp
seta   %cl
cmp    %r12,%r8
setb   %r12b
test   %r13b,%r13b
jne    1bca <radbg+0xa7a>
and    0x48(%rsp),%bl
mov    0xa0(%rsp),%r8
jne    1ba7 <radbg+0xa57>
and    %r10b,%r14b
mov    0x68(%rsp),%r13
mov    0x90(%rsp),%rbx
jne    1b91 <radbg+0xa41>
mov    $0x0,%ebp
and    %r12b,%cl
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
jne    19d0 <radbg+0x880>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
xor    %ebx,%ebx
mov    0xf8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r9,%rbx,8),%xmm4
mulpd  %xmm2,%xmm4
movupd (%rsi,%rbx,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rsi,%rbx,8)
movupd (%rdi,%rbx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd (%rdx,%rbx,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rdx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1b40 <radbg+0x9f0>
mov    %rcx,%rbp
cmp    %r14,%rcx
mov    0x90(%rsp),%rbx
jne    19d0 <radbg+0x880>
jmp    1980 <radbg+0x830>
xor    %ebp,%ebp
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
jmp    19d0 <radbg+0x880>
xor    %ebp,%ebp
mov    0x68(%rsp),%r13
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
mov    0x90(%rsp),%rbx
jmp    19d0 <radbg+0x880>
xor    %ebp,%ebp
mov    0x68(%rsp),%r13
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
mov    0xa0(%rsp),%r8
mov    0x90(%rsp),%rbx
jmp    19d0 <radbg+0x880>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x60(%rsp),%rax
mov    0xb0(%rsp),%r9
cmp    %r9,%rax
setb   0x70(%rsp)
mov    0xb8(%rsp),%rcx
mov    0x88(%rsp),%r11
cmp    %rcx,%r11
setb   %bl
mov    0x130(%rsp),%rdi
cmp    %rdi,%rax
setb   %r12b
cmp    %r13,%rcx
seta   0x48(%rsp)
mov    0x140(%rsp),%rbp
cmp    %rbp,%rax
setb   %r10b
cmp    %rcx,%rdi
setb   0xc0(%rsp)
mov    0x160(%rsp),%r14
cmp    %r14,%rax
setb   %r8b
mov    0x138(%rsp),%r15
cmp    %rcx,%r15
setb   0x27(%rsp)
cmp    %rdi,%r11
setb   %cl
cmp    %r13,%r9
seta   0x26(%rsp)
cmp    %rbp,%r11
setb   %al
cmp    %r9,%rdi
setb   %bpl
cmp    %r14,%r11
setb   %dil
cmp    %r9,%r15
setb   %r9b
test   %bl,0x70(%rsp)
jne    1e3c <radbg+0xcec>
and    0x48(%rsp),%r12b
jne    1e3c <radbg+0xcec>
and    0xc0(%rsp),%r10b
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
jne    186e <radbg+0x71e>
and    0x27(%rsp),%r8b
jne    186e <radbg+0x71e>
and    0x26(%rsp),%cl
jne    186e <radbg+0x71e>
and    %bpl,%al
jne    186e <radbg+0x71e>
mov    $0x0,%r8d
and    %r9b,%dil
jne    1871 <radbg+0x721>
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x2,0x158(%rsp)
mov    0xf0(%rsp),%r9
mov    0xe8(%rsp),%rbx
jae    1d3a <radbg+0xbea>
xor    %eax,%eax
mov    0x8(%rsp),%r8
jmp    1dbf <radbg+0xc6f>
mov    0x148(%rsp),%rcx
xor    %eax,%eax
mov    0x8(%rsp),%r8
mov    0x130(%rsp),%rdi
mov    0x138(%rsp),%rbp
nopl   0x0(%rax)
movupd 0x0(%r13,%rax,8),%xmm4
movupd (%rdi,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,-0x10(%r9,%rax,8)
movupd 0x0(%rbp,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
movupd %xmm4,-0x10(%rbx,%rax,8)
movupd 0x10(%r13,%rax,8),%xmm4
movupd 0x10(%rdi,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r9,%rax,8)
movupd 0x10(%rbp,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
movupd %xmm4,(%rbx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d60 <radbg+0xc10>
testb  $0x1,0x150(%rsp)
01
je     1e23 <radbg+0xcd3>
mov    0x80(%rsp),%rcx
mov    0x40(%rsp),%rdi
sub    %rdi,%rcx
imul   %r14,%rdi
imul   %r14,%rcx
movupd 0x0(%r13,%rax,8),%xmm4
lea    (%rax,%r14,1),%rbp
movupd 0x0(%r13,%rbp,8),%xmm5
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
add    %rax,%rdi
movupd %xmm3,(%r8,%rdi,8)
mov    0xd0(%rsp),%rdi
add    %rax,%rdi
movupd 0x0(%r13,%rdi,8),%xmm3
mulpd  %xmm3,%xmm2
add    %rax,%rcx
movupd %xmm2,(%r8,%rcx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%r8
cmp    %r14,%rax
jne    1871 <radbg+0x721>
jmp    18fc <radbg+0x7ac>
xor    %r8d,%r8d
mov    0x30(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r12
jmp    1871 <radbg+0x721>
mov    0x10(%rsp),%rdi
call   1030 <util_free_@plt>
jmp    209b <radbg+0xf4b>
mov    0x10(%rsp),%rdi
call   1030 <util_free_@plt>
cmpq   $0x4,0x98(%rsp)
jb     209b <radbg+0xf4b>
mov    0x110(%rsp),%rcx
cmp    $0x3,%rcx
mov    %r14,%rax
mov    $0x2,%r12d
cmovae %rcx,%r12
lea    -0x4(%r14),%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r14,%r11
and    $0xfffffffffffffffc,%r11
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
mov    %r14,%rbx
neg    %rbx
lea    0x30(,%r14,8),%rcx
add    %r13,%rcx
mov    $0x1,%edx
xor    %esi,%esi
mov    0x130(%rsp),%rdi
jmp    1efc <radbg+0xdac>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    $0x1,%rsi
mov    0x38(%rsp),%rax
add    %rax,%rcx
add    %rax,%rdi
cmp    %r12,%rdx
je     20bb <radbg+0xf6b>
mov    0x30(%rsp),%r8
test   %r8,%r8
je     1ee0 <radbg+0xd90>
mov    %rdx,%r14
imul   %r8,%r14
cmp    $0x4,%r8
jb     1f51 <radbg+0xe01>
mov    %rsi,%rax
imul   %r8,%rax
mov    0xa8(%rsp),%rbp
add    %rax,%rbp
lea    0x0(,%rbp,8),%rbp
add    %r13,%rbp
cmp    %r13,%rbp
jbe    1fc5 <radbg+0xe75>
add    %r8,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
cmp    0x130(%rsp),%rax
jae    1fc5 <radbg+0xe75>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%r8b
je     1f7b <radbg+0xe2b>
add    %rbp,%r14
movsd  0x0(%r13,%r14,8),%xmm0
addsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    %rbx,%rbp
mov    0x30(%rsp),%rbp
je     1ee0 <radbg+0xd90>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
addsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1f90 <radbg+0xe40>
jmp    1ee0 <radbg+0xd90>
cmp    $0x4,%r9
jae    1fcf <radbg+0xe7f>
xor    %eax,%eax
jmp    2049 <radbg+0xef9>
mov    0x70(%rsp),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rax,8),%xmm0
movupd -0x20(%rcx,%rax,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%r13,%rax,8),%xmm1
movupd 0x30(%r13,%rax,8),%xmm3
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rcx,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r13,%rax,8)
movupd %xmm1,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1fe0 <radbg+0xe90>
test   $0x1,%r10b
je     2085 <radbg+0xf35>
lea    (%rax,%r14,1),%rbp
movupd 0x0(%r13,%rbp,8),%xmm0
movupd 0x10(%r13,%rbp,8),%xmm1
movupd 0x0(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
mov    %r11,%rbp
mov    0x30(%rsp),%r8
cmp    %r8,%r11
je     1ee0 <radbg+0xd90>
jmp    1f53 <radbg+0xe03>
mov    0x80(%rsp),%rax
lea    -0x1(%rax),%rdx
mov    0xcc(%rsp),%eax
test   %al,%al
je     25f9 <radbg+0x14a9>
jmp    2c73 <radbg+0x1b23>
cmpq   $0x4,0x98(%rsp)
jb     25e2 <radbg+0x1492>
mov    0x110(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%r10d
cmovae %rax,%r10
mov    0x128(%rsp),%rax
mov    %rax,%rbx
mov    %rax,%r12
imul   %r15,%rbx
mov    %r15,%rax
imul   0x80(%rsp),%rax
mov    %rax,0xf0(%rsp)
lea    -0x2(%r15),%rax
mov    %rax,0x120(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
cmp    $0x1,%r15
setne  %al
mov    0x18(%rsp),%rsi
cmp    $0x1,%rsi
sete   %dl
and    %al,%dl
mov    %dl,0x38(%rsp)
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xd8(%rsp)
mov    %rcx,%rax
mov    %rcx,0xe0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xd0(%rsp)
lea    0x2(%r15),%rax
imul   %rsi,%rax
lea    0x0(,%rax,8),%rbp
add    %r13,%rbp
mov    %r15,%rcx
imul   %rsi,%rcx
lea    0x0(,%rcx,8),%r14
mov    %rsi,%rdx
shl    $0x5,%rdx
mov    %rdx,0x118(%rsp)
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%r8
lea    0x2(%rbx),%rax
imul   %rsi,%rax
mov    %r14,%rdi
neg    %rdi
mov    %rdi,0xa0(%rsp)
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
mov    %rdi,0x88(%rsp)
lea    (%rdx,%rax,8),%r9
lea    0x0(,%rcx,8),%rdi
add    %r13,%rdi
lea    (%rdx,%rcx,8),%r11
imul   %r12,%rcx
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
mov    %rax,0xb0(%rsp)
lea    (%rdx,%rcx,8),%r12
lea    (%r15,%r15,1),%rax
mov    %rax,0xe8(%rsp)
lea    0x0(,%rsi,8),%rax
mov    $0x1,%ecx
mov    %rcx,0x70(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xb8(%rsp)
mov    %r15,0x90(%rsp)
mov    %rbx,0xf8(%rsp)
mov    %rbx,0x60(%rsp)
mov    0x128(%rsp),%rcx
mov    %rcx,0xa8(%rsp)
mov    %r10,0x58(%rsp)
mov    %r14,0x40(%rsp)
jmp    22ba <radbg+0x116a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x70(%rsp),%rdx
add    $0x1,%rdx
addq   $0xffffffffffffffff,0xa8(%rsp)
addq   $0x1,0xb8(%rsp)
mov    0x10(%rsp),%rbp
add    %r14,%rbp
add    %r14,%r8
mov    0xa0(%rsp),%rcx
add    %rcx,0x88(%rsp)
add    %rcx,%r9
mov    0x48(%rsp),%rdi
add    %r14,%rdi
add    %r14,%r11
add    %rcx,0xb0(%rsp)
add    %rcx,%r12
sub    %r15,0x60(%rsp)
add    %r15,0x90(%rsp)
mov    %rdx,0x70(%rsp)
cmp    %r10,%rdx
je     25e2 <radbg+0x1492>
mov    %rdi,0x48(%rsp)
mov    %rbp,0x10(%rsp)
test   %r15,%r15
je     2250 <radbg+0x1100>
cmpb   $0x0,0x38(%rsp)
je     2410 <radbg+0x12c0>
mov    0xb8(%rsp),%rcx
imul   %r15,%rcx
mov    0xf8(%rsp),%rdi
sub    %rcx,%rdi
mov    0xf0(%rsp),%rdx
sub    %rcx,%rdx
mov    0xe8(%rsp),%rsi
add    %rcx,%rsi
add    %r15,%rcx
lea    0x0(,%rdi,8),%rbp
add    %r13,%rbp
lea    0x0(%r13,%rdx,8),%rbx
lea    0x0(%r13,%rcx,8),%r10
lea    0x0(%r13,%rsi,8),%r15
mov    0x8(%rsp),%r13
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
lea    0x0(,%rsi,8),%rsi
add    %r13,%rsi
lea    0x0(,%rdx,8),%r14
add    %r13,%r14
cmp    %r15,%rbp
setb   0xc0(%rsp)
cmp    %rbx,%r10
setb   0x28(%rsp)
cmp    %rsi,%rbp
setb   %dl
cmp    %rbx,%rcx
setb   0x108(%rsp)
cmp    %r14,%rbp
lea    0x0(%r13,%rdi,8),%rbp
setb   %r13b
cmp    %rbx,%rbp
setb   0x100(%rsp)
cmp    %rsi,%r10
setb   %bl
cmp    %r15,%rcx
setb   %sil
cmp    %r14,%r10
setb   %dil
cmp    %r15,%rbp
setb   %r10b
mov    0x28(%rsp),%cl
test   %cl,0xc0(%rsp)
jne    25c7 <radbg+0x1477>
and    0x108(%rsp),%dl
mov    0x50(%rsp),%r15
mov    0x40(%rsp),%r14
jne    25b6 <radbg+0x1466>
and    0x100(%rsp),%r13b
jne    25b6 <radbg+0x1466>
and    %sil,%bl
mov    0x68(%rsp),%r13
jne    25aa <radbg+0x145a>
mov    $0x0,%esi
and    %r10b,%dil
mov    0x58(%rsp),%r10
jne    2412 <radbg+0x12c2>
cmpq   $0x2,0x120(%rsp)
jae    248d <radbg+0x133d>
xor    %edi,%edi
jmp    2526 <radbg+0x13d6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
mov    %r15,%rdi
sub    %rsi,%rdi
mov    0x60(%rsp),%rcx
lea    (%rsi,%rcx,1),%rdx
mov    0x18(%rsp),%rbp
imul   %rbp,%rdx
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
mov    0x8(%rsp),%rbx
lea    (%rbx,%rdx,8),%rdx
add    0x90(%rsp),%rsi
imul   %rbp,%rsi
lea    0x0(,%rsi,8),%rbp
add    %r13,%rbp
lea    (%rbx,%rsi,8),%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,1),%xmm0
addsd  (%rdx,%rbx,1),%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
movsd  (%rsi,%rbx,1),%xmm0
subsd  (%rdx,%rbx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,1)
add    %rax,%rbx
add    $0xffffffffffffffff,%rdi
jne    2460 <radbg+0x1310>
jmp    2250 <radbg+0x1100>
mov    0xd0(%rsp),%r14
xor    %r10d,%r10d
xor    %edi,%edi
mov    0x10(%rsp),%rcx
mov    0x118(%rsp),%rdx
mov    0x88(%rsp),%rbp
mov    0x48(%rsp),%rbx
mov    0xb0(%rsp),%rsi
nopl   0x0(%rax)
movupd (%r11,%r10,1),%xmm0
movupd (%r12,%r10,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%r10,1)
movupd (%r11,%r10,1),%xmm0
movupd (%r12,%r10,1),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%rbx,%r10,1)
movupd (%r8,%r10,1),%xmm0
movupd (%r9,%r10,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%r10,1)
movupd (%r8,%r10,1),%xmm0
movupd (%r9,%r10,1),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%rcx,%r10,1)
add    $0x4,%rdi
add    %rdx,%r10
add    $0xfffffffffffffffe,%r14
jne    24c0 <radbg+0x1370>
testb  $0x1,0xe0(%rsp)
01
mov    0x58(%rsp),%r10
mov    0x40(%rsp),%r14
je     2591 <radbg+0x1441>
mov    0x70(%rsp),%rcx
imul   %r15,%rcx
mov    0xa8(%rsp),%rdx
imul   %r15,%rdx
add    %rdi,%rcx
mov    0x18(%rsp),%rbx
imul   %rbx,%rcx
mov    0x8(%rsp),%rsi
movupd (%rsi,%rcx,8),%xmm0
add    %rdi,%rdx
imul   %rbx,%rdx
movupd (%rsi,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rdx,8)
movupd (%rsi,%rcx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x0(%r13,%rcx,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r15,%rcx
je     2250 <radbg+0x1100>
jmp    2412 <radbg+0x12c2>
xor    %esi,%esi
mov    0x58(%rsp),%r10
jmp    2412 <radbg+0x12c2>
xor    %esi,%esi
mov    0x68(%rsp),%r13
mov    0x58(%rsp),%r10
jmp    2412 <radbg+0x12c2>
xor    %esi,%esi
mov    0x68(%rsp),%r13
mov    0x50(%rsp),%r15
mov    0x58(%rsp),%r10
mov    0x40(%rsp),%r14
jmp    2412 <radbg+0x12c2>
mov    0xcc(%rsp),%eax
mov    0x128(%rsp),%rdx
test   %al,%al
jne    2c73 <radbg+0x1b23>
cmpq   $0x4,0x98(%rsp)
jb     274c <radbg+0x15fc>
mov    0x110(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovae %rax,%rcx
mov    %rcx,0x70(%rsp)
mov    %r15,%rdi
mov    0x18(%rsp),%rcx
imul   %rcx,%rdi
lea    0x0(,%rdi,8),%r11
add    %r13,%r11
lea    0x0(,%rcx,8),%rsi
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,8),%r14
shl    $0x3,%rdi
imul   %r15,%rdx
imul   %rcx,%rdx
lea    0x0(,%rdx,8),%rbp
add    %r13,%rbp
mov    %rdi,0x10(%rsp)
neg    %rdi
mov    %rdi,0x48(%rsp)
lea    (%rax,%rdx,8),%r12
mov    $0x1,%ebx
mov    0x18(%rsp),%r10
jmp    26a5 <radbg+0x1555>
xchg   %ax,%ax
add    $0x1,%rbx
mov    0x10(%rsp),%rax
add    %rax,%r11
add    %rax,%r14
mov    0x48(%rsp),%rax
add    %rax,%rbp
add    %rax,%r12
cmp    0x70(%rsp),%rbx
je     274c <radbg+0x15fc>
test   %r15,%r15
je     2680 <radbg+0x1530>
mov    %r12,%rcx
mov    %rbp,%rax
mov    %r14,%rdi
mov    %r11,%rdx
xor    %r8d,%r8d
jmp    26d5 <radbg+0x1585>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %rsi,%rdx
add    %rsi,%rdi
add    %rsi,%rax
add    %rsi,%rcx
cmp    %r15,%r8
je     2680 <radbg+0x1530>
cmp    $0x3,%r10
jb     26c0 <radbg+0x1570>
mov    $0x2,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%r9,8),%xmm0
addsd  (%rcx,%r9,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r9,8)
movsd  -0x8(%rdi,%r9,8),%xmm0
subsd  (%rcx,%r9,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%r9,8)
movsd  (%rdi,%r9,8),%xmm0
addsd  -0x8(%rcx,%r9,8),%xmm0
movsd  %xmm0,(%rdx,%r9,8)
movsd  (%rdi,%r9,8),%xmm0
subsd  -0x8(%rcx,%r9,8),%xmm0
movsd  %xmm0,(%rax,%r9,8)
add    $0x2,%r9
cmp    %r10,%r9
jb     26f0 <radbg+0x15a0>
jmp    26c0 <radbg+0x1570>
mov    0x30(%rsp),%rdx
shl    $0x3,%rdx
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
mov    %r13,%rsi
call   1060 <memcpy@plt>
cmpq   $0x2,0x80(%rsp)
jb     2c73 <radbg+0x1b23>
mov    0x1b0(%rsp),%r9
mov    0x18(%rsp),%rsi
lea    -0x3(%rsi),%r14
mov    %r14,%r12
shr    %r12
mov    %r15,%rdi
imul   %rsi,%rdi
lea    0x2(%rdi),%rax
mov    %rax,0xe0(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xd8(%rsp)
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rax,1),%rcx
add    $0x3,%rcx
mov    %rcx,0xd0(%rsp)
add    $0x2,%rax
mov    %rax,0x98(%rsp)
lea    0x1(%r12),%rbp
mov    $0x10,%ecx
mov    %r12,%rax
mul    %rcx
mov    %rax,0xb8(%rsp)
seto   %r8b
mov    %rbp,0xf8(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x38(%rsp)
mov    %rbp,%rax
add    %rbp,%rax
mov    %rax,0x118(%rsp)
lea    (%r12,%r12,1),%rax
add    $0x2,%rax
or     $0x2,%rax
mov    %rax,0xf0(%rsp)
lea    0x8(,%rdi,8),%rax
add    %r13,%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rax,0xe8(%rsp)
lea    0x0(,%rsi,8),%r11
lea    0x8(%rbx,%rdi,8),%rax
mov    %rax,0x108(%rsp)
lea    (%rbx,%rdi,8),%rax
mov    %rax,0x100(%rsp)
mov    %rdi,0x120(%rsp)
lea    0x0(%r13,%rdi,8),%rax
mov    %rax,0x58(%rsp)
mov    $0x1,%eax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %r9,%rsi
mov    %r14,0x60(%rsp)
mov    %r8b,0x88(%rsp)
jmp    28f2 <radbg+0x17a2>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xa0(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0x40(%rsp)
mov    0xe8(%rsp),%rax
add    %rax,0x28(%rsp)
add    %rax,0x108(%rsp)
add    %r11,%rsi
add    %rax,0x100(%rsp)
add    %rax,0x58(%rsp)
mov    %rcx,0xa0(%rsp)
cmp    0x80(%rsp),%rcx
mov    0x50(%rsp),%r15
je     2c73 <radbg+0x1b23>
test   %r15,%r15
je     28a0 <radbg+0x1750>
mov    0x120(%rsp),%rdi
mov    0x40(%rsp),%rcx
imul   %rcx,%rdi
mov    0xd8(%rsp),%rax
add    %rdi,%rax
mov    %rax,0x90(%rsp)
mov    0xd0(%rsp),%rax
add    %rdi,%rax
mov    %rax,0xb0(%rsp)
mov    %rcx,%rax
mov    0x18(%rsp),%rdx
imul   %rdx,%rax
mov    0x98(%rsp),%rcx
add    %rax,%rcx
add    0xe0(%rsp),%rdi
mov    %rdi,0x48(%rsp)
lea    (%r9,%rax,8),%rax
mov    %rax,0x30(%rsp)
lea    (%r9,%rcx,8),%rax
mov    %rax,0xa8(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,%rcx
imul   0x50(%rsp),%rcx
mov    %rcx,0x70(%rsp)
lea    -0x1(%rax),%rcx
imul   %rdx,%rcx
mov    0x118(%rsp),%rax
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,0xc0(%rsp)
add    $0x1,%rcx
mov    %rcx,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    0x100(%rsp),%r10
mov    0x108(%rsp),%rbp
mov    0x28(%rsp),%r12
xor    %ecx,%ecx
jmp    29eb <radbg+0x189b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
add    %r11,%r12
add    %r11,%rbp
add    %r11,%r10
add    %r11,%r15
cmp    0x50(%rsp),%rcx
je     28a0 <radbg+0x1750>
mov    0x70(%rsp),%rax
add    %rcx,%rax
mov    0x18(%rsp),%rdx
imul   %rdx,%rax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
cmp    $0x3,%rdx
jb     29d0 <radbg+0x1880>
mov    $0x2,%edx
cmp    $0x2,%r14
jae    2a30 <radbg+0x18e0>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rax
jmp    2c10 <radbg+0x1ac0>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%r14
imul   0x18(%rsp),%r14
mov    0x90(%rsp),%rax
lea    (%rax,%r14,1),%r9
mov    0x48(%rsp),%rax
add    %r14,%rax
lea    (%rbx,%r9,8),%rdi
lea    (%rbx,%rax,8),%rax
mov    0xb8(%rsp),%r13
lea    (%rax,%r13,1),%rbx
cmp    %rax,%rbx
setb   %bl
or     %r8b,%bl
lea    (%rdi,%r13,1),%rax
cmp    %rdi,%rax
setb   %al
test   %bl,%bl
jne    2bbf <radbg+0x1a6f>
or     %r8b,%al
mov    0x68(%rsp),%r13
jne    2bb8 <radbg+0x1a68>
add    0xb0(%rsp),%r14
mov    0x8(%rsp),%rax
lea    (%rax,%r14,8),%rbx
lea    0x0(,%r9,8),%r9
add    %r13,%r9
lea    0x0(,%r14,8),%rax
add    %r13,%rax
cmp    0xa8(%rsp),%rdi
setb   %r14b
cmp    %rbx,0x30(%rsp)
setb   %r13b
cmp    %rax,%rdi
setb   %al
cmp    %rbx,%r9
setb   %bl
test   %r13b,%r14b
jne    2be2 <radbg+0x1a92>
mov    0x10(%rsp),%rdi
and    %bl,%al
mov    0x68(%rsp),%r13
mov    0x8(%rsp),%rbx
mov    0x18(%rsp),%rax
mov    0x1b0(%rsp),%r9
mov    0x60(%rsp),%r14
mov    0x88(%rsp),%r8b
jne    2c10 <radbg+0x1ac0>
mov    0x38(%rsp),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rsi,%rdi,1),%xmm0
movupd 0x10(%rsi,%rdi,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd (%r12,%rdi,1),%xmm1
movupd 0x10(%r12,%rdi,1),%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm1
movapd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm1
mulpd  %xmm4,%xmm0
addpd  %xmm0,%xmm3
mulpd  %xmm2,%xmm4
subpd  %xmm1,%xmm4
movapd %xmm4,%xmm0
unpcklpd %xmm3,%xmm0
unpckhpd %xmm3,%xmm4
movupd %xmm4,0x10(%rbp,%rdi,1)
movupd %xmm0,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rdx
jne    2b20 <radbg+0x19d0>
mov    0xc0(%rsp),%rdi
mov    0xf0(%rsp),%rdx
mov    0x38(%rsp),%rax
cmp    %rax,0xf8(%rsp)
mov    0x18(%rsp),%rax
je     29d0 <radbg+0x1880>
jmp    2c10 <radbg+0x1ac0>
mov    0x10(%rsp),%rdi
jmp    2bec <radbg+0x1a9c>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rbx
mov    0x18(%rsp),%rax
mov    0x1b0(%rsp),%r9
mov    0x60(%rsp),%r14
mov    0x68(%rsp),%r13
jmp    2c10 <radbg+0x1ac0>
mov    0x10(%rsp),%rdi
mov    0x68(%rsp),%r13
mov    0x8(%rsp),%rbx
mov    0x18(%rsp),%rax
mov    0x1b0(%rsp),%r9
mov    0x60(%rsp),%r14
mov    0x88(%rsp),%r8b
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rdi,8),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi),%xmm0
mulsd  -0x8(%r15,%rdx,8),%xmm0
movsd  -0x8(%rdi),%xmm1
mulsd  (%r15,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rdx,8)
movsd  (%r15,%rdx,8),%xmm0
mulsd  (%rdi),%xmm0
movsd  -0x8(%rdi),%xmm1
mulsd  -0x8(%r15,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r10,%rdx,8)
add    $0x2,%rdx
add    $0x10,%rdi
cmp    %rax,%rdx
jb     2c20 <radbg+0x1ad0>
jmp    29d0 <radbg+0x1880>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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