#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 */

/* Variables and functions */
double cos(double);
double sin(double);
void dradbg(long ido, long ip, long l1, long idl1, const double *cc, double *c1,
            double *c2, double *ch, double *ch2, const double *wa) {
  static double tpi = 6.28318530717958647692528676655900577;
  long idij, ipph, i, j, k, l, ik, is, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
      t10, t11, t12;
  double dc2, ai1, ai2, ar1, ar2, ds2;
  long nbd;
  double dcp, arg, dsp, ar1h, ar2h;
  long ipp2;
  t10 = ip * ido;
  t0 = l1 * ido;
  arg = tpi / (double)ip;
  dcp = cos(arg);
  dsp = sin(arg);
  nbd = (ido - 1) >> 1;
  ipp2 = ip;
  ipph = (ip + 1) >> 1;
  if (ido < l1)
    goto L103;
  t1 = 0;
  t2 = 0;
  for (k = 0; k < l1; k++) {
    t3 = t1;
    t4 = t2;
    for (i = 0; i < ido; i++) {
      ch[t3] = cc[t4];
      t3++;
      t4++;
    }
    t1 += ido;
    t2 += t10;
  }
  goto L106;
L103:
  t1 = 0;
  for (i = 0; i < ido; i++) {
    t2 = t1;
    t3 = t1;
    for (k = 0; k < l1; k++) {
      ch[t2] = cc[t3];
      t2 += ido;
      t3 += t10;
    }
    t1++;
  }
L106:
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = (t5 = ido << 1);
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t6 = t5;
    for (k = 0; k < l1; k++) {
      ch[t3] = cc[t6 - 1] + cc[t6 - 1];
      ch[t4] = cc[t6] + cc[t6];
      t3 += ido;
      t4 += ido;
      t6 += t10;
    }
    t5 += t7;
  }
  if (ido == 1)
    goto L116;
  if (nbd < l1)
    goto L112;
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t7 += (ido << 1);
    t8 = t7;
    for (k = 0; k < l1; k++) {
      t5 = t3;
      t6 = t4;
      t9 = t8;
      t11 = t8;
      for (i = 2; i < ido; i += 2) {
        t5 += 2;
        t6 += 2;
        t9 += 2;
        t11 -= 2;
        ch[t5 - 1] = cc[t9 - 1] + cc[t11 - 1];
        ch[t6 - 1] = cc[t9 - 1] - cc[t11 - 1];
        ch[t5] = cc[t9] - cc[t11];
        ch[t6] = cc[t9] + cc[t11];
      }
      t3 += ido;
      t4 += ido;
      t8 += t10;
    }
  }
  goto L116;
L112:
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t7 += (ido << 1);
    t8 = t7;
    t9 = t7;
    for (i = 2; i < ido; i += 2) {
      t3 += 2;
      t4 += 2;
      t8 += 2;
      t9 -= 2;
      t5 = t3;
      t6 = t4;
      t11 = t8;
      t12 = t9;
      for (k = 0; k < l1; k++) {
        ch[t5 - 1] = cc[t11 - 1] + cc[t12 - 1];
        ch[t6 - 1] = cc[t11 - 1] - cc[t12 - 1];
        ch[t5] = cc[t11] - cc[t12];
        ch[t6] = cc[t11] + cc[t12];
        t5 += ido;
        t6 += ido;
        t11 += t10;
        t12 += t10;
      }
    }
  }
L116:
  ar1 = 1.;
  ai1 = 0.;
  t1 = 0;
  t9 = (t2 = ipp2 * idl1);
  t3 = (ip - 1) * idl1;
  for (l = 1; l < ipph; l++) {
    t1 += idl1;
    t2 -= idl1;
    ar1h = dcp * ar1 - dsp * ai1;
    ai1 = dcp * ai1 + dsp * ar1;
    ar1 = ar1h;
    t4 = t1;
    t5 = t2;
    t6 = 0;
    t7 = idl1;
    t8 = t3;
    for (ik = 0; ik < idl1; ik++) {
      c2[t4++] = ch2[t6++] + ar1 * ch2[t7++];
      c2[t5++] = ai1 * ch2[t8++];
    }
    dc2 = ar1;
    ds2 = ai1;
    ar2 = ar1;
    ai2 = ai1;
    t6 = idl1;
    t7 = t9 - idl1;
    for (j = 2; j < ipph; j++) {
      t6 += idl1;
      t7 -= idl1;
      ar2h = dc2 * ar2 - ds2 * ai2;
      ai2 = dc2 * ai2 + ds2 * ar2;
      ar2 = ar2h;
      t4 = t1;
      t5 = t2;
      t11 = t6;
      t12 = t7;
      for (ik = 0; ik < idl1; ik++) {
        c2[t4++] += ar2 * ch2[t11++];
        c2[t5++] += ai2 * ch2[t12++];
      }
    }
  }
  t1 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += idl1;
    t2 = t1;
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += ch2[t2++];
  }
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (k = 0; k < l1; k++) {
      ch[t3] = c1[t3] - c1[t4];
      ch[t4] = c1[t3] + c1[t4];
      t3 += ido;
      t4 += ido;
    }
  }
  if (ido == 1)
    goto L132;
  if (nbd < l1)
    goto L128;
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (k = 0; k < l1; k++) {
      t5 = t3;
      t6 = t4;
      for (i = 2; i < ido; i += 2) {
        t5 += 2;
        t6 += 2;
        ch[t5 - 1] = c1[t5 - 1] - c1[t6];
        ch[t6 - 1] = c1[t5 - 1] + c1[t6];
        ch[t5] = c1[t5] + c1[t6 - 1];
        ch[t6] = c1[t5] - c1[t6 - 1];
      }
      t3 += ido;
      t4 += ido;
    }
  }
  goto L132;
L128:
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (i = 2; i < ido; i += 2) {
      t3 += 2;
      t4 += 2;
      t5 = t3;
      t6 = t4;
      for (k = 0; k < l1; k++) {
        ch[t5 - 1] = c1[t5 - 1] - c1[t6];
        ch[t6 - 1] = c1[t5 - 1] + c1[t6];
        ch[t5] = c1[t5] + c1[t6 - 1];
        ch[t6] = c1[t5] - c1[t6 - 1];
        t5 += ido;
        t6 += ido;
      }
    }
  }
L132:
  if (ido == 1)
    return;
  for (ik = 0; ik < idl1; ik++)
    c2[ik] = ch2[ik];
  t1 = 0;
  for (j = 1; j < ip; j++) {
    t2 = (t1 += t0);
    for (k = 0; k < l1; k++) {
      c1[t2] = ch[t2];
      t2 += ido;
    }
  }
  if (nbd > l1)
    goto L139;
  is = -ido - 1;
  t1 = 0;
  for (j = 1; j < ip; j++) {
    is += ido;
    t1 += t0;
    idij = is;
    t2 = t1;
    for (i = 2; i < ido; i += 2) {
      t2 += 2;
      idij += 2;
      t3 = t2;
      for (k = 0; k < l1; k++) {
        c1[t3 - 1] = wa[idij - 1] * ch[t3 - 1] - wa[idij] * ch[t3];
        c1[t3] = wa[idij - 1] * ch[t3] + wa[idij] * ch[t3 - 1];
        t3 += ido;
      }
    }
  }
  return;
L139:
  is = -ido - 1;
  t1 = 0;
  for (j = 1; j < ip; j++) {
    is += ido;
    t1 += t0;
    t2 = t1;
    for (k = 0; k < l1; k++) {
      idij = is;
      t3 = t2;
      for (i = 2; i < ido; i += 2) {
        idij += 2;
        t3 += 2;
        c1[t3 - 1] = wa[idij - 1] * ch[t3 - 1] - wa[idij] * ch[t3];
        c1[t3] = wa[idij - 1] * ch[t3] + wa[idij] * ch[t3 - 1];
      }
      t2 += ido;
    }
  }
}


x86 assembly (clang, -O0):
<dradbg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
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
imul   -0x8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x18(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movsd  0x3eb8(%rip),%xmm0
cvtsi2sdq -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
call   1040 <cos@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x8(%rbp),%rax
sub    $0x1,%rax
sar    $0x1,%rax
mov    %rax,-0x110(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
sar    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    11f5 <dradbg+0xd5>
jmp    12d9 <dradbg+0x1b9>
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    12d4 <dradbg+0x1b4>
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    12a2 <dradbg+0x182>
mov    -0x28(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    123f <dradbg+0x11f>
mov    -0x8(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0xc8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1210 <dradbg+0xf0>
jmp    139d <dradbg+0x27d>
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1398 <dradbg+0x278>
mov    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    137b <dradbg+0x25b>
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xc8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1315 <dradbg+0x1f5>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    12e9 <dradbg+0x1c9>
jmp    139d <dradbg+0x27d>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,-0xb0(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    151a <dradbg+0x3fa>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    14f4 <dradbg+0x3d4>
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0xc8(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1434 <dradbg+0x314>
mov    -0xb0(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    13d6 <dradbg+0x2b6>
cmpq   $0x1,-0x8(%rbp)
jne    152a <dradbg+0x40a>
jmp    1a90 <dradbg+0x970>
mov    -0x110(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1540 <dradbg+0x420>
jmp    17d4 <dradbg+0x6b4>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0xb0(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    17cf <dradbg+0x6af>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    17b9 <dradbg+0x699>
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    176f <dradbg+0x64f>
mov    -0xa0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xc0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xd0(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    1630 <dradbg+0x510>
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0xc8(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    15e2 <dradbg+0x4c2>
jmp    17be <dradbg+0x69e>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    156e <dradbg+0x44e>
jmp    1a90 <dradbg+0x970>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0xb0(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1a8b <dradbg+0x96b>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1a75 <dradbg+0x955>
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x98(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xc0(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0xc0(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1a5f <dradbg+0x93f>
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xc8(%rbp),%rax
add    -0xd0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    191a <dradbg+0x7fa>
jmp    1a64 <dradbg+0x944>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    1884 <dradbg+0x764>
jmp    1a7a <dradbg+0x95a>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1802 <dradbg+0x6e2>
jmp    1a90 <dradbg+0x970>
movsd  0x1568(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    %rax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1efc <dradbg+0xddc>
mov    -0x20(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x80(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0xa8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xb8(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1cb1 <dradbg+0xb91>
mov    0x20(%rbp),%rax
mov    -0xa8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa8(%rbp)
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb8(%rbp)
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa0(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1be4 <dradbg+0xac4>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xc0(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0xb0(%rbp)
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1ee6 <dradbg+0xdc6>
mov    -0x20(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0xb0(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xb0(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x80(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1ed0 <dradbg+0xdb0>
movsd  -0x100(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xd0(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xd8(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa0(%rbp)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1e0f <dradbg+0xcef>
jmp    1ed5 <dradbg+0xdb5>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1d16 <dradbg+0xbf6>
jmp    1eeb <dradbg+0xdcb>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1ae9 <dradbg+0x9c9>
movq   $0x0,-0x80(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1f9e <dradbg+0xe7e>
mov    -0x20(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1f88 <dradbg+0xe68>
mov    0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1f39 <dradbg+0xe19>
jmp    1f8d <dradbg+0xe6d>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1f0c <dradbg+0xdec>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    20ca <dradbg+0xfaa>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    20b4 <dradbg+0xf94>
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2011 <dradbg+0xef1>
jmp    20b9 <dradbg+0xf99>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1fc1 <dradbg+0xea1>
cmpq   $0x1,-0x8(%rbp)
jne    20da <dradbg+0xfba>
jmp    2515 <dradbg+0x13f5>
mov    -0x110(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    20f0 <dradbg+0xfd0>
jmp    2300 <dradbg+0x11e0>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    22fb <dradbg+0x11db>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    22e5 <dradbg+0x11c5>
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    22b0 <dradbg+0x1190>
mov    -0xa0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    2195 <dradbg+0x1075>
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2163 <dradbg+0x1043>
jmp    22ea <dradbg+0x11ca>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    2113 <dradbg+0xff3>
jmp    2515 <dradbg+0x13f5>
movq   $0x0,-0x80(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    2510 <dradbg+0x13f0>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    24fa <dradbg+0x13da>
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    24e4 <dradbg+0x13c4>
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    23c9 <dradbg+0x12a9>
jmp    24e9 <dradbg+0x13c9>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    2373 <dradbg+0x1253>
jmp    24ff <dradbg+0x13df>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    2323 <dradbg+0x1203>
jmp    2515 <dradbg+0x13f5>
cmpq   $0x1,-0x8(%rbp)
jne    2525 <dradbg+0x1405>
jmp    29b6 <dradbg+0x1896>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    2566 <dradbg+0x1446>
mov    0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    252d <dradbg+0x140d>
movq   $0x0,-0x80(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    2606 <dradbg+0x14e6>
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    25f0 <dradbg+0x14d0>
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    259f <dradbg+0x147f>
jmp    25f5 <dradbg+0x14d5>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    2576 <dradbg+0x1456>
mov    -0x110(%rbp),%rax
cmp    -0x18(%rbp),%rax
jle    261c <dradbg+0x14fc>
jmp    27ee <dradbg+0x16ce>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    27e9 <dradbg+0x16c9>
mov    -0x8(%rbp),%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    27d3 <dradbg+0x16b3>
mov    -0x88(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x88(%rbp)
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    27bd <dradbg+0x169d>
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    26bd <dradbg+0x159d>
jmp    27c2 <dradbg+0x16a2>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    267b <dradbg+0x155b>
jmp    27d8 <dradbg+0x16b8>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    263a <dradbg+0x151a>
jmp    29b6 <dradbg+0x1896>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    29b6 <dradbg+0x1896>
mov    -0x8(%rbp),%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    29a0 <dradbg+0x1880>
mov    -0x70(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    297d <dradbg+0x185d>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    $0x1,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    2871 <dradbg+0x1751>
mov    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2845 <dradbg+0x1725>
jmp    29a5 <dradbg+0x1885>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    280c <dradbg+0x16ec>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,%r12
mov    %rcx,0x30(%rsp)
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    %rsi,%r14
imul   %rdi,%r14
mov    %rdx,%rax
imul   %rdi,%rax
mov    %rax,0x80(%rsp)
cvtsi2sd %rsi,%xmm1
movsd  0x2e96(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0xd0(%rsp)
movsd  (%rsp),%xmm0
call   1030 <sin@plt>
mov    %rbx,0x40(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0xb0(%rsp)
cmp    %r15,%rbp
mov    %r15,%rax
mov    %r15,0x18(%rsp)
mov    %rbp,%rax
mov    %rbp,(%rsp)
mov    %r12,0x10(%rsp)
jge    1451 <dradbg+0x331>
test   %rbp,%rbp
movapd 0xd0(%rsp),%xmm11
jle    16b2 <dradbg+0x592>
lea    -0x1(%r15),%rax
imul   0x40(%rsp),%rax
mov    %rax,0x48(%rsp)
cmp    $0x4,%r15
setae  %al
mov    (%rsp),%rcx
cmp    $0x1,%rcx
sete   %dl
and    %al,%dl
mov    %dl,0x68(%rsp)
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,%rdx
imul   %rcx,%rdx
mov    %rdx,0x50(%rsp)
mov    %rax,0x8(%rsp)
imul   %r14,%rax
mov    %rax,0x78(%rsp)
mov    %r15d,%r11d
and    $0x3,%r11d
mov    %r14,%rdi
shl    $0x5,%rdi
lea    0x0(,%r14,8),%rax
lea    (%rax,%rax,2),%r10
mov    %r14,%r13
shl    $0x4,%r13
mov    0x1c8(%rsp),%rax
add    $0x10,%rax
mov    %rax,0x28(%rsp)
mov    %rcx,%r8
shl    $0x5,%r8
mov    %r11,0x20(%rsp)
neg    %r11
lea    0x0(,%rcx,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x58(%rsp)
shl    $0x4,%rcx
mov    %rcx,0x60(%rsp)
xor    %r9d,%r9d
mov    %r12,0x38(%rsp)
jmp    12a4 <dradbg+0x184>
nopl   0x0(%rax)
add    $0x1,%r9
addq   $0x8,0x38(%rsp)
addq   $0x8,0x28(%rsp)
cmp    (%rsp),%r9
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%r12
je     16b2 <dradbg+0x592>
lea    (%r12,%r9,8),%rdx
mov    0x48(%rsp),%rax
add    %r9,%rax
lea    (%r12,%rax,8),%rcx
cmp    %rcx,%rdx
mov    %rcx,%rax
cmovb  %rdx,%rax
cmova  %rdx,%rcx
test   %r15,%r15
jle    1280 <dradbg+0x160>
cmpb   $0x0,0x68(%rsp)
je     12fd <dradbg+0x1dd>
add    $0x8,%rcx
mov    0x1c8(%rsp),%rsi
lea    (%rsi,%r9,8),%rdx
cmp    %rcx,%rdx
mov    0x18(%rsp),%rbx
jae    13e2 <dradbg+0x2c2>
lea    (%r9,%rbx,1),%rcx
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,%rax
jae    13e2 <dradbg+0x2c2>
xor    %r15d,%r15d
mov    %r9,%rbp
mov    %r9,%rcx
mov    %r15,%r12
not    %r12
add    0x18(%rsp),%r12
cmpq   $0x0,0x20(%rsp)
je     134c <dradbg+0x22c>
xor    %edx,%edx
mov    (%rsp),%rsi
mov    0x1c8(%rsp),%rax
mov    0x10(%rsp),%rbx
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
add    %rsi,%rbp
add    %r14,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%r11
jne    1330 <dradbg+0x210>
sub    %rdx,%r15
cmp    $0x3,%r12
jb     1280 <dradbg+0x160>
mov    0x18(%rsp),%rbx
sub    %r15,%rbx
lea    0x0(,%rbp,8),%rdx
mov    0x58(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
mov    0x60(%rsp),%rax
lea    (%rax,%rbp,8),%rax
add    (%rsp),%rbp
mov    0x10(%rsp),%r15
lea    (%r15,%rcx,8),%r12
add    %r14,%rcx
lea    (%r15,%rcx,8),%rcx
mov    0x1c8(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12),%xmm1
movsd  %xmm1,(%r15,%rdx,1)
movsd  (%rcx),%xmm1
movsd  %xmm1,(%r15,%rbp,8)
movsd  (%r12,%r13,1),%xmm1
movsd  %xmm1,(%r15,%rax,1)
movsd  (%r12,%r10,1),%xmm1
movsd  %xmm1,(%r15,%rsi,1)
add    %r8,%r15
add    %rdi,%r12
add    %rdi,%rcx
add    $0xfffffffffffffffc,%rbx
jne    13a0 <dradbg+0x280>
jmp    1280 <dradbg+0x160>
mov    0x50(%rsp),%rax
lea    (%r9,%rax,1),%rbp
mov    0x78(%rsp),%rax
lea    (%r9,%rax,1),%rcx
mov    0x28(%rsp),%rax
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx),%xmm1
movhpd (%rdx,%r14,8),%xmm1
movsd  (%rdx,%r13,1),%xmm2
movhpd (%rdx,%r10,1),%xmm2
movupd %xmm1,-0x10(%rax)
movupd %xmm2,(%rax)
add    %rdi,%rdx
add    %r8,%rax
add    $0xfffffffffffffffc,%rsi
jne    1410 <dradbg+0x2f0>
mov    0x8(%rsp),%rax
mov    %rax,%r15
cmp    %rbx,%rax
je     1280 <dradbg+0x160>
jmp    1306 <dradbg+0x1e6>
test   %r15,%r15
movapd 0xd0(%rsp),%xmm11
jle    16b2 <dradbg+0x592>
mov    (%rsp),%rax
lea    -0x4(%rax),%rcx
mov    %rcx,0x58(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x8(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x60(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x50(%rsp)
mov    %eax,%edi
and    $0x3,%edi
mov    0x1c8(%rsp),%rdx
lea    0x30(%rdx),%rsi
lea    0x0(,%rax,8),%rax
mov    %rax,0x28(%rsp)
lea    0x30(%r12),%rcx
lea    0x0(,%r14,8),%rax
mov    %rax,0x38(%rsp)
mov    %rdi,0x48(%rsp)
neg    %rdi
lea    0x18(%rdx),%rax
mov    %rax,0x68(%rsp)
lea    0x18(%r12),%rax
mov    %rax,0x20(%rsp)
xor    %r9d,%r9d
xor    %r8d,%r8d
xor    %r13d,%r13d
jmp    150a <dradbg+0x3ea>
nop
add    %r14,%r13
add    $0x1,%r9
add    0x28(%rsp),%rsi
add    0x38(%rsp),%rcx
cmp    %r15,%r9
je     16b2 <dradbg+0x592>
mov    %r8,%rbp
mov    (%rsp),%rax
add    %rax,%r8
test   %rax,%rax
jle    14f0 <dradbg+0x3d0>
mov    (%rsp),%rax
cmp    $0x4,%rax
jb     1550 <dradbg+0x430>
add    %r13,%rax
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rbp,8),%rdx
lea    (%r12,%rax,8),%rax
cmp    %rax,%rdx
jae    161d <dradbg+0x4fd>
lea    (%rbx,%r8,8),%rax
lea    (%r12,%r13,8),%rdx
cmp    %rax,%rdx
jae    161d <dradbg+0x4fd>
xor    %r11d,%r11d
mov    %r13,%r10
mov    %r11,%rax
not    %rax
add    (%rsp),%rax
cmpq   $0x0,0x48(%rsp)
je     15af <dradbg+0x48f>
mov    0x1c8(%rsp),%rdx
lea    (%rdx,%rbp,8),%r15
lea    (%r12,%r10,8),%r12
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%r12),%xmm1
movsd  %xmm1,(%r15)
add    $0xffffffffffffffff,%rbx
add    $0x8,%r15
add    $0x8,%r12
cmp    %rbx,%rdi
jne    1580 <dradbg+0x460>
sub    %rbx,%r11
sub    %rbx,%rbp
sub    %rbx,%r10
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%r12
cmp    $0x3,%rax
jb     14f0 <dradbg+0x3d0>
mov    (%rsp),%rax
sub    %r11,%rax
mov    0x68(%rsp),%rdx
lea    (%rdx,%rbp,8),%rbp
mov    0x20(%rsp),%rdx
lea    (%rdx,%r10,8),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x18(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x18(%rbp,%rdx,8)
movsd  -0x10(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x10(%rbp,%rdx,8)
movsd  -0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    15e0 <dradbg+0x4c0>
jmp    14f0 <dradbg+0x3d0>
cmpq   $0x4,0x58(%rsp)
jae    1629 <dradbg+0x509>
xor    %eax,%eax
jmp    1664 <dradbg+0x544>
mov    0x50(%rsp),%rbx
xor    %eax,%eax
movups -0x30(%rcx,%rax,8),%xmm1
movups -0x20(%rcx,%rax,8),%xmm2
movups %xmm1,-0x30(%rsi,%rax,8)
movups %xmm2,-0x20(%rsi,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
movupd %xmm1,-0x10(%rsi,%rax,8)
movupd %xmm2,(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    1630 <dradbg+0x510>
testb  $0x1,0x60(%rsp)
je     1692 <dradbg+0x572>
lea    (%rax,%rbp,1),%rdx
add    %r13,%rax
movupd (%r12,%rax,8),%xmm1
movupd 0x10(%r12,%rax,8),%xmm2
mov    0x1c8(%rsp),%rax
movupd %xmm1,(%rax,%rdx,8)
movupd %xmm2,0x10(%rax,%rdx,8)
mov    0x8(%rsp),%rax
cmp    (%rsp),%rax
je     14f0 <dradbg+0x3d0>
mov    0x8(%rsp),%r11
add    %r11,%rbp
lea    (%r11,%r13,1),%r10
jmp    1556 <dradbg+0x436>
mov    (%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x108(%rsp)
sarq   0xb0(%rsp)
mov    0x80(%rsp),%r8
mov    %r8,%rdx
mov    0x40(%rsp),%rcx
imul   %rcx,%rdx
mov    %rdx,0x98(%rsp)
add    %rax,%rax
cmp    $0x3,%rcx
jl     1915 <dradbg+0x7f5>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%edx
cmovge %rcx,%rdx
mov    %rdx,0x8(%rsp)
mov    %r15,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x78(%rsp)
mov    0x1c8(%rsp),%r11
lea    (%r11,%r8,8),%rsi
lea    0x0(,%r8,8),%r12
mov    %r8,%rcx
neg    %rcx
mov    %rcx,0x48(%rsp)
lea    0x1(%r15),%rcx
mov    (%rsp),%r10
imul   %r10,%rcx
lea    (%r11,%rcx,8),%rcx
mov    0x10(%rsp),%r9
lea    (%r9,%rax,8),%rdi
mov    %r10,%rdx
shl    $0x4,%rdx
mov    %rdx,0x60(%rsp)
lea    (%r14,%r14,1),%rbp
mov    %rax,%rdx
neg    %rdx
mov    %rdx,0x68(%rsp)
mov    0x40(%rsp),%rbx
lea    0x2(%rbx),%rdx
imul   %r10,%rdx
lea    (%r9,%rdx,8),%rdx
add    $0xffffffffffffffff,%rbx
mov    %r8,%r13
imul   %rbx,%r13
lea    (%r11,%r13,8),%r9
mov    %r12,0x58(%rsp)
neg    %r12
mov    %r12,0xd0(%rsp)
neg    %r13
mov    %r13,0x20(%rsp)
imul   %r15,%rbx
add    $0x1,%rbx
imul   %r10,%rbx
lea    (%r11,%rbx,8),%r11
mov    $0x1,%r10d
xor    %ebx,%ebx
mov    %rbx,0x28(%rsp)
mov    0x98(%rsp),%rbx
mov    %rbx,0x38(%rsp)
mov    %rax,%r13
jmp    182a <dradbg+0x70a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %rax,%r13
add    $0x1,%r10
mov    0x58(%rsp),%rbx
add    %rbx,%rsi
sub    %r8,0x48(%rsp)
add    %rbx,%rcx
mov    0x60(%rsp),%rbx
add    %rbx,%rdi
sub    %rax,0x68(%rsp)
add    %rbx,%rdx
mov    0xd0(%rsp),%rbx
add    %rbx,%r9
add    %r8,0x20(%rsp)
add    %rbx,%r11
cmp    0x8(%rsp),%r10
mov    0x18(%rsp),%r15
je     1915 <dradbg+0x7f5>
add    %r8,0x28(%rsp)
sub    %r8,0x38(%rsp)
test   %r15,%r15
jle    17e0 <dradbg+0x6c0>
mov    0x28(%rsp),%rbx
mov    %r13,%r12
mov    0x38(%rsp),%r15
cmpq   $0x1,0x18(%rsp)
je     18c0 <dradbg+0x7a0>
mov    0x78(%rsp),%rbx
xor    %r12d,%r12d
xor    %r15d,%r15d
nopl   0x0(%rax)
movsd  -0x8(%rdi,%r12,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%rsi,%r15,8)
movsd  (%rdi,%r12,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r9,%r15,8)
movsd  -0x8(%rdx,%r12,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%rcx,%r15,8)
movsd  (%rdx,%r12,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r11,%r15,8)
add    %rax,%r15
add    %rbp,%r12
add    $0xfffffffffffffffe,%rbx
jne    1860 <dradbg+0x740>
mov    %r15,%rbx
sub    0x48(%rsp),%rbx
sub    0x68(%rsp),%r12
sub    0x20(%rsp),%r15
testb  $0x1,0x18(%rsp)
je     17e0 <dradbg+0x6c0>
mov    %rbx,0x50(%rsp)
mov    0x10(%rsp),%rbx
movsd  -0x8(%rbx,%r12,8),%xmm1
addsd  %xmm1,%xmm1
mov    0x1c8(%rsp),%r8
mov    0x50(%rsp),%rbx
movsd  %xmm1,(%r8,%rbx,8)
mov    0x10(%rsp),%rbx
movsd  (%rbx,%r12,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r8,%r15,8)
mov    0x80(%rsp),%r8
jmp    17e0 <dradbg+0x6c0>
sarq   0x108(%rsp)
cmpq   $0x1,(%rsp)
jne    2210 <dradbg+0x10f0>
mov    0x40(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x100(%rsp)
cmp    $0x3,%rax
jl     2cb0 <dradbg+0x1b90>
mov    0x30(%rsp),%r12
mov    %r12,%rdx
mov    0x40(%rsp),%rax
imul   %rax,%rdx
mov    0x100(%rsp),%rsi
imul   %r12,%rsi
movapd 0x26a7(%rip),%xmm10
xorpd  %xmm0,%xmm10
mov    %rdx,%rdi
sub    %r12,%rdi
mov    0xb0(%rsp),%rcx
cmp    $0x4,%rcx
mov    $0x3,%ebp
cmovge %rcx,%rbp
mov    %rbp,0x68(%rsp)
cmp    $0x3,%rcx
mov    $0x2,%ebp
cmovge %rcx,%rbp
mov    %rbp,0x180(%rsp)
lea    (%r12,%r12,1),%rcx
mov    %rcx,0xa8(%rsp)
lea    -0x2(%rax),%rbp
imul   %r12,%rbp
lea    -0x8(,%rax,8),%rax
ff
imul   %r12,%rax
mov    %rax,0xe8(%rsp)
mov    %r12,%rcx
shl    $0x4,%rcx
mov    0x1d0(%rsp),%r8
add    %r8,%rcx
mov    %rcx,0x128(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm9
lea    -0x2(%r12),%rcx
mov    %rcx,0x160(%rsp)
mov    %rcx,%rbx
shr    %rbx
add    $0x1,%rbx
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    %rbx,%rcx
mov    %rbx,0x158(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x148(%rsp)
lea    0x0(,%r12,8),%rcx
mov    %rcx,0x38(%rsp)
neg    %rcx
mov    %rcx,0x48(%rsp)
movsd  0x25c7(%rip),%xmm5
movapd 0x25c6(%rip),%xmm8
lea    (%r12,%r12,2),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%r8,%r12,8),%rcx
mov    %rcx,0x110(%rsp)
mov    %rdi,0x130(%rsp)
lea    (%r8,%rdi,8),%rcx
mov    %rcx,0x170(%rsp)
mov    %rdx,0x20(%rsp)
lea    (%r8,%rdx,8),%rcx
mov    %rcx,0x168(%rsp)
lea    (%rsi,%rax,1),%rcx
mov    %rcx,0x140(%rsp)
mov    %rax,0x90(%rsp)
lea    (%rax,%r12,1),%rax
mov    %rax,0x138(%rsp)
lea    0x10(%r8,%rsi,8),%rax
mov    %rax,0x150(%rsp)
mov    0x1c0(%rsp),%rcx
lea    0x10(%rcx,%rsi,8),%rdx
lea    0x10(%rcx,%r12,8),%rdi
lea    (%rcx,%r12,8),%r14
mov    %rsi,0xb8(%rsp)
lea    (%rcx,%rsi,8),%r11
mov    %rbp,0xc8(%rsp)
lea    (%r8,%rbp,8),%rax
mov    %rax,0x178(%rsp)
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    1b4c <dradbg+0xa2c>
nopw   0x0(%rax,%rax,1)
mov    0x120(%rsp),%rsi
add    $0x1,%rsi
mov    0x118(%rsp),%rcx
add    $0x1,%rcx
mov    0x48(%rsp),%rbp
mov    0xf8(%rsp),%rdx
add    %rbp,%rdx
mov    0x38(%rsp),%rax
mov    0xf0(%rsp),%rdi
add    %rax,%rdi
add    %rax,%r14
add    %rbp,%r11
cmp    0x180(%rsp),%rsi
je     238c <dradbg+0x126c>
mov    %rsi,0x120(%rsp)
mov    %rdi,0xf0(%rsp)
mov    %rdx,0xf8(%rsp)
mov    0xa8(%rsp),%rax
mov    0x8(%rsp),%rsi
add    %rsi,%rax
add    %r12,%rsi
mov    %rcx,0x118(%rsp)
imul   %r12,%rcx
mov    0x130(%rsp),%rdx
sub    %rcx,%rdx
mov    0x1c0(%rsp),%r15
mov    0x20(%rsp),%rcx
lea    (%r15,%rcx,8),%rdi
mov    %rdi,0x60(%rsp)
sub    %r12,%rcx
mov    %rcx,0x20(%rsp)
mov    %rsi,0x8(%rsp)
lea    (%r15,%rsi,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    (%r15,%rax,8),%rax
mov    %rax,0x50(%rsp)
lea    (%r15,%rdx,8),%rax
mov    %rax,0x78(%rsp)
movapd %xmm5,%xmm2
unpckhpd %xmm9,%xmm2
movapd %xmm10,%xmm3
unpcklpd %xmm5,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm11,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm5,%xmm4
unpckhpd %xmm5,%xmm4
test   %r12,%r12
jle    1c6b <dradbg+0xb4b>
cmp    $0x1,%r12
jne    1f70 <dradbg+0xe50>
xor    %edx,%edx
mov    0xb8(%rsp),%r8
mov    %r12,%rdi
mov    0x20(%rsp),%r10
mov    0x8(%rsp),%rbp
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rdx,8),%rax
mov    %r12,%rsi
sub    %rdx,%rsi
lea    (%rcx,%r8,8),%rdx
lea    (%rcx,%rdi,8),%rdi
lea    (%r15,%r10,8),%rcx
lea    (%r15,%rbp,8),%rbp
xor    %ebx,%ebx
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm5,%xmm2
addsd  (%rax,%rbx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1c40 <dradbg+0xb20>
cmpq   $0x5,0x40(%rsp)
jb     1b00 <dradbg+0x9e0>
xorpd  %xmm8,%xmm4
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
mov    0xd0(%rsp),%rax
cmp    0x60(%rsp),%rax
setb   %al
mov    0x78(%rsp),%rcx
cmp    0x50(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0xa0(%rsp)
mov    0x20(%rsp),%rax
mov    0x90(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x88(%rsp)
mov    0x8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xe0(%rsp)
mov    $0x2,%r9d
mov    0x178(%rsp),%r10
mov    0x128(%rsp),%rsi
xor    %r15d,%r15d
mov    0x130(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    %r12,0x28(%rsp)
movapd %xmm5,%xmm2
jmp    1d32 <dradbg+0xc12>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    $0x1,%r15
add    0x38(%rsp),%rsi
add    0x48(%rsp),%r10
cmp    0x68(%rsp),%r9
mov    0x30(%rsp),%r12
je     1b00 <dradbg+0x9e0>
add    %r12,0x28(%rsp)
sub    %r12,0x10(%rsp)
movapd %xmm2,%xmm6
unpckhpd %xmm5,%xmm6
movapd %xmm4,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
mulpd  %xmm3,%xmm2
addpd  %xmm7,%xmm2
test   %r12,%r12
jle    1d10 <dradbg+0xbf0>
movapd %xmm2,%xmm7
unpckhpd %xmm2,%xmm7
mov    0x30(%rsp),%rcx
cmp    $0x1,%rcx
jne    1e00 <dradbg+0xce0>
xor    %r13d,%r13d
mov    0x10(%rsp),%rbp
mov    0x28(%rsp),%r12
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%r8
mov    0x30(%rsp),%rax
sub    %r13,%rax
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rbp,8),%rbp
lea    (%rcx,%r12,8),%rdx
mov    0x1c0(%rsp),%rcx
lea    (%rcx,%rbx,8),%rbx
lea    (%rcx,%r8,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1dc0 <dradbg+0xca0>
jmp    1d10 <dradbg+0xbf0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rax
imul   %rcx,%rax
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
mov    0xc0(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    0xc8(%rsp),%rdi
sub    %rax,%rdi
shl    $0x3,%rax
mov    0x1d0(%rsp),%rcx
mov    %rcx,%rbp
sub    %rax,%rbp
add    0xe8(%rsp),%rbp
lea    (%rcx,%rbx,8),%rax
lea    (%rcx,%rdx,8),%r13
lea    (%rcx,%rdi,8),%rdi
mov    0xd0(%rsp),%rdx
cmp    %r13,%rdx
setb   %r8b
mov    0x50(%rsp),%rbx
cmp    %rbx,%rax
setb   %cl
and    %r8b,%cl
or     0xa0(%rsp),%cl
cmp    %rdx,%rbp
seta   %dl
cmp    %rbx,%rdi
setb   %r12b
mov    0x78(%rsp),%r8
cmp    %r13,%r8
setb   %r13b
mov    0x60(%rsp),%rbx
cmp    %rbx,%rax
setb   0x58(%rsp)
cmp    %r8,%rbp
seta   %al
cmp    %rbx,%rdi
setb   %dil
test   %cl,%cl
jne    1d74 <dradbg+0xc54>
and    %r12b,%dl
jne    1d74 <dradbg+0xc54>
and    0x58(%rsp),%r13b
jne    1d74 <dradbg+0xc54>
mov    $0x0,%r13d
mov    0x10(%rsp),%rbp
mov    0x28(%rsp),%r12
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%r8
and    %dil,%al
jne    1d8b <dradbg+0xc6b>
mov    0x90(%rsp),%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rcx,1),%rbp
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,1),%r12
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm0
mulpd  %xmm6,%xmm0
movupd (%r14,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r14,%rax,8)
movupd (%r10,%rax,8),%xmm0
movupd (%r11,%rax,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1f10 <dradbg+0xdf0>
mov    %rcx,%r13
mov    0x88(%rsp),%rbx
mov    0xe0(%rsp),%r8
cmp    0x30(%rsp),%rcx
je     1d10 <dradbg+0xbf0>
jmp    1d8b <dradbg+0xc6b>
nop
mov    0x60(%rsp),%r13
mov    0xd0(%rsp),%rsi
cmp    %r13,%rsi
setb   0x10(%rsp)
mov    0x50(%rsp),%rdi
mov    0x78(%rsp),%rcx
cmp    %rdi,%rcx
setb   %r10b
mov    0x110(%rsp),%rbp
cmp    %rbp,%rsi
setb   %dl
mov    0x1d0(%rsp),%r8
cmp    %r8,%rdi
seta   0x28(%rsp)
mov    0x128(%rsp),%rbx
cmp    %rbx,%rsi
setb   %r12b
cmp    %rdi,%rbp
setb   0x58(%rsp)
mov    0x168(%rsp),%rax
cmp    %rax,%rsi
setb   %sil
mov    0x170(%rsp),%r15
cmp    %rdi,%r15
setb   0xa0(%rsp)
cmp    %rbp,%rcx
setb   %dil
cmp    %r8,%r13
seta   0x88(%rsp)
cmp    %rbx,%rcx
setb   %r8b
cmp    %r13,%rbp
setb   %bpl
cmp    %rax,%rcx
setb   %r9b
cmp    %r13,%r15
setb   %al
test   %r10b,0x10(%rsp)
jne    21e7 <dradbg+0x10c7>
and    0x28(%rsp),%dl
mov    0x1c0(%rsp),%r15
jne    21d3 <dradbg+0x10b3>
and    0x58(%rsp),%r12b
jne    21d3 <dradbg+0x10b3>
and    0xa0(%rsp),%sil
jne    21d3 <dradbg+0x10b3>
and    0x88(%rsp),%dil
jne    21d3 <dradbg+0x10b3>
and    %bpl,%r8b
jne    21d3 <dradbg+0x10b3>
mov    $0x0,%edx
mov    0xb8(%rsp),%r8
mov    0x30(%rsp),%r12
mov    %r12,%rdi
mov    0x20(%rsp),%r10
mov    0x8(%rsp),%rbp
and    %al,%r9b
jne    1c1c <dradbg+0xafc>
movapd %xmm5,%xmm2
unpcklpd %xmm5,%xmm2
cmpq   $0x2,0x160(%rsp)
mov    0x110(%rsp),%rcx
mov    0x150(%rsp),%rdi
mov    0xf8(%rsp),%rbp
mov    0xf0(%rsp),%rbx
jae    20c6 <dradbg+0xfa6>
xor    %edx,%edx
jmp    213a <dradbg+0x101a>
mov    0x148(%rsp),%rsi
xor    %edx,%edx
mov    0x1d0(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm3
movupd (%rcx,%rdx,8),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%rbx,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rbp,%rdx,8)
movupd 0x10(%rax,%rdx,8),%xmm3
movupd 0x10(%rcx,%rdx,8),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%rbx,%rdx,8)
movupd (%rdi,%rdx,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,0x0(%rbp,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    20e0 <dradbg+0xfc0>
testb  $0x1,0x158(%rsp)
01
je     2196 <dradbg+0x1076>
mov    0xb8(%rsp),%rax
add    %rdx,%rax
lea    (%rdx,%r12,1),%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rdx,1),%rsi
mov    0x8(%rsp),%rdi
add    %rdx,%rdi
mov    0x1d0(%rsp),%rbp
movupd 0x0(%rbp,%rdx,8),%xmm3
movupd 0x0(%rbp,%rcx,8),%xmm6
mulpd  %xmm6,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%r15,%rdi,8)
movupd 0x0(%rbp,%rax,8),%xmm2
mulpd  %xmm4,%xmm2
movupd %xmm2,(%r15,%rsi,8)
cmp    %r12,0x90(%rsp)
je     1c6b <dradbg+0xb4b>
mov    0x20(%rsp),%rax
mov    0x90(%rsp),%rdx
lea    (%rax,%rdx,1),%r10
mov    0x8(%rsp),%rax
lea    (%rax,%rdx,1),%rbp
mov    0x140(%rsp),%r8
mov    0x138(%rsp),%rdi
jmp    1c1c <dradbg+0xafc>
xor    %edx,%edx
mov    0xb8(%rsp),%r8
mov    0x30(%rsp),%r12
jmp    1c0f <dradbg+0xaef>
xor    %edx,%edx
mov    0xb8(%rsp),%r8
mov    0x30(%rsp),%r12
mov    %r12,%rdi
mov    0x20(%rsp),%r10
mov    0x8(%rsp),%rbp
mov    0x1c0(%rsp),%r15
jmp    1c1c <dradbg+0xafc>
cmp    %r15,0x108(%rsp)
jge    25bf <dradbg+0x149f>
cmpq   $0x3,0x40(%rsp)
mov    0x10(%rsp),%rdx
jl     2f5f <dradbg+0x1e3f>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%esi
cmovge %rcx,%rsi
mov    %rsi,0x28(%rsp)
lea    (%rdx,%rax,8),%r9
add    $0xfffffffffffffff0,%r9
mov    (%rsp),%rcx
mov    %rcx,%rsi
shl    $0x4,%rsi
mov    %rsi,0x38(%rsp)
shl    $0x3,%r14
lea    (%rdx,%rax,8),%r8
add    $0x10,%r8
mov    0x40(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0x80(%rsp),%rsi
imul   %rsi,%rax
mov    0x1c8(%rsp),%rdx
lea    (%rdx,%rax,8),%r13
lea    0x0(,%rsi,8),%rax
mov    %rax,0x10(%rsp)
neg    %rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rcx,8),%rcx
lea    (%rdx,%rsi,8),%rax
mov    $0x1,%esi
jmp    22e4 <dradbg+0x11c4>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
mov    0x38(%rsp),%rdx
add    %rdx,%r9
add    %rdx,%r8
add    0x48(%rsp),%r13
add    0x10(%rsp),%rax
cmp    0x28(%rsp),%rsi
je     1928 <dradbg+0x808>
cmpq   $0x3,(%rsp)
jl     22c0 <dradbg+0x11a0>
mov    $0x2,%edx
mov    %rax,%rbp
mov    %r13,%rdi
mov    %r8,%r12
mov    %r9,%r15
jmp    231a <dradbg+0x11fa>
xchg   %ax,%ax
add    $0x2,%rdx
add    $0xfffffffffffffff0,%r15
add    $0x10,%r12
add    $0x10,%rdi
add    $0x10,%rbp
cmp    (%rsp),%rdx
jge    22c0 <dradbg+0x11a0>
cmpq   $0x0,0x18(%rsp)
jle    2300 <dradbg+0x11e0>
mov    $0x10,%ebx
xor    %r10d,%r10d
mov    0x18(%rsp),%r11
nop
movsd  -0x8(%r12,%r10,1),%xmm1
addsd  -0x8(%r15,%r10,1),%xmm1
movsd  %xmm1,-0x8(%rbp,%rbx,1)
movsd  -0x8(%r12,%r10,1),%xmm1
subsd  -0x8(%r15,%r10,1),%xmm1
movsd  %xmm1,-0x8(%rdi,%rbx,1)
movsd  (%r12,%r10,1),%xmm1
subsd  (%r15,%r10,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,1)
movsd  (%r12,%r10,1),%xmm1
addsd  (%r15,%r10,1),%xmm1
movsd  %xmm1,(%rdi,%rbx,1)
add    %r14,%r10
add    %rcx,%rbx
add    $0xffffffffffffffff,%r11
jne    2330 <dradbg+0x1210>
jmp    2300 <dradbg+0x11e0>
cmpq   $0x3,0x40(%rsp)
jl     2cb0 <dradbg+0x1b90>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%r12d
cmovge %rax,%r12
mov    0x30(%rsp),%rbp
lea    -0x4(%rbp),%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %rbp,%r11
and    $0xfffffffffffffffc,%r11
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
mov    %rbp,%r15
neg    %r15
mov    0x1d0(%rsp),%rax
lea    (%rax,%rbp,8),%rcx
add    $0x30,%rcx
lea    0x8(%rax),%r14
mov    $0x1,%esi
xor    %r13d,%r13d
jmp    2412 <dradbg+0x12f2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
add    0x38(%rsp),%rcx
cmp    %r12,%rsi
je     2725 <dradbg+0x1605>
mov    %r13,%rax
add    %rbp,%r13
test   %rbp,%rbp
jle    2400 <dradbg+0x12e0>
cmp    $0x4,%rbp
jae    2430 <dradbg+0x1310>
xor    %ebx,%ebx
mov    %r13,%rdx
jmp    2550 <dradbg+0x1430>
nopl   (%rax)
add    0xa8(%rsp),%rax
mov    0x1d0(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
cmp    %rdi,%rax
jbe    2485 <dradbg+0x1365>
lea    (%rdi,%r13,8),%rax
cmp    0x110(%rsp),%rax
jae    2485 <dradbg+0x1365>
xor    %ebx,%ebx
mov    %r13,%rdx
test   $0x1,%bpl
je     2562 <dradbg+0x1442>
movsd  (%rdi,%rdx,8),%xmm0
add    $0x1,%rdx
addsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
mov    %rbx,%rdi
or     $0x1,%rdi
jmp    2565 <dradbg+0x1445>
cmp    $0x4,%r9
jae    248f <dradbg+0x136f>
xor    %edx,%edx
jmp    24ff <dradbg+0x13df>
mov    %r8,%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rcx,%rdx,8),%xmm0
movupd -0x20(%rcx,%rdx,8),%xmm1
movupd (%rdi,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rdi,%rdx,8),%xmm1
movupd 0x30(%rdi,%rdx,8),%xmm3
movupd %xmm2,(%rdi,%rdx,8)
movupd %xmm0,0x10(%rdi,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rcx,%rdx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rdi,%rdx,8)
movupd %xmm1,0x30(%rdi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    24a0 <dradbg+0x1380>
test   $0x1,%r10b
je     2532 <dradbg+0x1412>
lea    (%rdx,%r13,1),%rax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rdi,%rdx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rdx,8)
movupd %xmm0,0x10(%rdi,%rdx,8)
cmp    %rbp,%r11
je     2400 <dradbg+0x12e0>
lea    (%r11,%r13,1),%rdx
mov    %r11,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x1d0(%rsp),%rdi
test   $0x1,%bpl
jne    2466 <dradbg+0x1346>
mov    %rbx,%rdi
not    %rbx
cmp    %r15,%rbx
je     2400 <dradbg+0x12e0>
mov    %rbp,%rbx
sub    %rdi,%rbx
lea    (%r14,%rdi,8),%rdi
lea    (%r14,%rdx,8),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rax,8),%xmm0
addsd  -0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    2590 <dradbg+0x1470>
jmp    2400 <dradbg+0x12e0>
cmpq   $0x3,0x40(%rsp)
mov    0x10(%rsp),%rdx
jl     2f5f <dradbg+0x1e3f>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%esi
cmovge %rcx,%rsi
mov    %rsi,0x28(%rsp)
lea    (%rdx,%rax,8),%r10
add    $0xfffffffffffffff0,%r10
mov    (%rsp),%rcx
mov    %rcx,%rsi
shl    $0x4,%rsi
mov    %rsi,0x38(%rsp)
shl    $0x3,%r14
lea    (%rdx,%rax,8),%r12
mov    0x40(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0x80(%rsp),%rsi
imul   %rsi,%rax
mov    0x1c8(%rsp),%rdx
lea    (%rdx,%rax,8),%r13
lea    0x0(,%rsi,8),%rax
mov    %rax,0x10(%rsp)
neg    %rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rcx,8),%rcx
lea    (%rdx,%rsi,8),%rdx
mov    $0x1,%esi
mov    0x18(%rsp),%rbx
mov    (%rsp),%r11
jmp    2684 <dradbg+0x1564>
nopl   0x0(%rax)
add    $0x1,%rsi
mov    0x38(%rsp),%rax
add    %rax,%r10
add    %rax,%r12
add    0x48(%rsp),%r13
add    0x10(%rsp),%rdx
cmp    0x28(%rsp),%rsi
je     1928 <dradbg+0x808>
test   %rbx,%rbx
jle    2660 <dradbg+0x1540>
mov    %rdx,%rbp
mov    %r13,%rdi
mov    %r12,%rax
mov    %r10,%r8
xor    %r9d,%r9d
jmp    26ba <dradbg+0x159a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r14,%r8
add    %r14,%rax
add    %rcx,%rdi
add    %rcx,%rbp
mov    0x18(%rsp),%rbx
cmp    %rbx,%r9
je     2660 <dradbg+0x1540>
cmp    $0x3,%r11
jl     26a0 <dradbg+0x1580>
mov    $0x2,%ebx
mov    %r8,%r15
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbx,8),%xmm1
addsd  -0x8(%r15),%xmm1
movsd  %xmm1,-0x8(%rbp,%rbx,8)
movsd  -0x8(%rax,%rbx,8),%xmm1
subsd  -0x8(%r15),%xmm1
movsd  %xmm1,-0x8(%rdi,%rbx,8)
movsd  (%rax,%rbx,8),%xmm1
subsd  (%r15),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
movsd  (%rax,%rbx,8),%xmm1
addsd  (%r15),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffffffffff0,%r15
cmp    %r11,%rbx
jl     26d0 <dradbg+0x15b0>
jmp    26a0 <dradbg+0x1580>
cmpq   $0x3,0x40(%rsp)
jl     2cb0 <dradbg+0x1b90>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovge %rax,%rcx
mov    %rcx,0x60(%rsp)
mov    0x100(%rsp),%r8
mov    %r8,%r11
mov    0x18(%rsp),%rcx
imul   %rcx,%r11
mov    %rcx,%rax
imul   0x40(%rsp),%rax
mov    %rax,0xc0(%rsp)
lea    -0x2(%rcx),%rax
mov    %rax,0xe0(%rsp)
mov    %rax,%rsi
shr    %rsi
add    $0x1,%rsi
cmp    $0x1,%rcx
setne  %dil
mov    (%rsp),%rdx
cmp    $0x1,%rdx
sete   %al
and    %dil,%al
mov    %al,0x78(%rsp)
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x88(%rsp)
imul   %rdx,%rax
mov    %rax,0xf0(%rsp)
mov    %rsi,%rax
mov    %rsi,0xf8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x120(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0xa0(%rsp)
lea    0x2(%rcx),%rax
imul   %rdx,%rax
mov    0x1c8(%rsp),%r9
lea    (%r9,%rax,8),%rdi
mov    0x80(%rsp),%r12
lea    0x0(,%r12,8),%rbx
mov    %rdx,%rsi
shl    $0x5,%rsi
mov    %rsi,0x118(%rsp)
mov    0x70(%rsp),%r10
lea    (%r10,%rax,8),%rsi
mov    %r11,0xe8(%rsp)
lea    0x2(%r11),%rax
imul   %rdx,%rax
mov    %rbx,0xd0(%rsp)
neg    %rbx
mov    %rbx,0x50(%rsp)
lea    (%r9,%rax,8),%rbx
lea    (%r10,%rax,8),%r11
mov    %r12,%rax
imul   %r8,%rax
lea    (%r10,%rax,8),%r14
lea    (%r9,%rax,8),%rbp
shl    $0x4,%rdx
mov    %rdx,0xc8(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    %rax,0x90(%rsp)
lea    (%r10,%r12,8),%r15
lea    (%r9,%r12,8),%rcx
mov    $0x1,%edx
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    28e8 <dradbg+0x17c8>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,0x58(%rsp)
mov    0x10(%rsp),%rdi
mov    0xd0(%rsp),%rax
add    %rax,%rdi
mov    0x48(%rsp),%rsi
add    %rax,%rsi
mov    0x50(%rsp),%rcx
mov    0x28(%rsp),%rbx
add    %rcx,%rbx
add    %rcx,%r11
add    %rcx,%r14
mov    0x38(%rsp),%rbp
add    %rcx,%rbp
add    %rax,%r15
mov    0x68(%rsp),%rcx
add    %rax,%rcx
cmp    0x60(%rsp),%rdx
je     2cb0 <dradbg+0x1b90>
mov    %rdx,0x20(%rsp)
mov    %rcx,0x68(%rsp)
mov    %rsi,0x48(%rsp)
mov    %rbp,0x38(%rsp)
mov    %rbx,0x28(%rsp)
mov    %rdi,0x10(%rsp)
mov    0x80(%rsp),%rax
add    %rax,0x8(%rsp)
sub    %rax,0x98(%rsp)
cmpq   $0x0,0x18(%rsp)
jle    2890 <dradbg+0x1770>
cmpb   $0x0,0x78(%rsp)
je     2a50 <dradbg+0x1930>
mov    0x58(%rsp),%rax
mov    0x18(%rsp),%rcx
imul   %rcx,%rax
lea    (%rax,%rcx,1),%r8
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    0xe8(%rsp),%rsi
sub    %rax,%rsi
mov    0xc0(%rsp),%rdi
sub    %rax,%rdi
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%r8,8),%rax
lea    (%rcx,%rdx,8),%rbp
lea    (%rcx,%rsi,8),%rbx
lea    (%rcx,%rdi,8),%r12
mov    0x70(%rsp),%r13
lea    0x0(,%r8,8),%rcx
add    %r13,%rcx
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
lea    0x0(,%rdi,8),%r9
add    %r13,%r9
cmp    %r12,%rax
setb   %r10b
cmp    %rbp,%rbx
setb   %r8b
cmp    %rdx,%rax
setb   %dil
cmp    %rbp,%rcx
setb   0xa8(%rsp)
cmp    %r9,%rax
lea    0x0(%r13,%rsi,8),%rsi
setb   %al
cmp    %rbp,%rsi
setb   %r13b
cmp    %rdx,%rbx
setb   %bpl
cmp    %r12,%rcx
setb   %cl
cmp    %r9,%rbx
setb   %bl
cmp    %r12,%rsi
setb   %dl
test   %r8b,%r10b
jne    2a50 <dradbg+0x1930>
and    0xa8(%rsp),%dil
mov    (%rsp),%r9
jne    2b9e <dradbg+0x1a7e>
and    %r13b,%al
jne    2b9e <dradbg+0x1a7e>
and    %cl,%bpl
jne    2b9e <dradbg+0x1a7e>
mov    $0x0,%r12d
mov    0x8(%rsp),%rbp
mov    0x98(%rsp),%r8
and    %dl,%bl
jne    2a64 <dradbg+0x1944>
cmpq   $0x2,0xe0(%rsp)
jae    2a77 <dradbg+0x1957>
xor    %ebp,%ebp
jmp    2b10 <dradbg+0x19f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %r12d,%r12d
mov    0x8(%rsp),%rbp
mov    0x98(%rsp),%r8
mov    (%rsp),%r9
testb  $0x1,0x18(%rsp)
jne    2bc0 <dradbg+0x1aa0>
mov    %r12,%rax
jmp    2bfb <dradbg+0x1adb>
mov    0x120(%rsp),%rax
xor    %ecx,%ecx
xor    %ebp,%ebp
mov    0x10(%rsp),%r8
mov    0x118(%rsp),%r10
mov    0x28(%rsp),%rbx
mov    0x38(%rsp),%rsi
mov    0x48(%rsp),%rdx
mov    0x68(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rcx,1),%xmm0
movupd (%r14,%rcx,1),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rcx,1)
movupd (%r15,%rcx,1),%xmm0
movupd (%r14,%rcx,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rcx,1)
movupd (%rdx,%rcx,1),%xmm0
movupd (%r11,%rcx,1),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%r8,%rcx,1)
movupd (%rdx,%rcx,1),%xmm0
movupd (%r11,%rcx,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rcx,1)
add    $0x4,%rbp
add    %r10,%rcx
add    $0xfffffffffffffffe,%rax
jne    2ab0 <dradbg+0x1990>
testb  $0x1,0xf8(%rsp)
01
je     2b61 <dradbg+0x1a41>
imul   %r9,%rbp
mov    0x8(%rsp),%rax
add    %rbp,%rax
add    0x98(%rsp),%rbp
mov    0x70(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd (%rcx,%rbp,8),%xmm1
subpd  %xmm1,%xmm0
mov    0x1c8(%rsp),%rdx
movupd %xmm0,(%rdx,%rax,8)
movupd (%rcx,%rax,8),%xmm0
movupd (%rcx,%rbp,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rbp,8)
mov    0x88(%rsp),%rax
cmp    0x18(%rsp),%rax
je     2890 <dradbg+0x1770>
mov    0xf0(%rsp),%rcx
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,1),%rbp
mov    0x98(%rsp),%rax
lea    (%rax,%rcx,1),%r8
mov    0x88(%rsp),%r12
jmp    2a60 <dradbg+0x1940>
xor    %r12d,%r12d
mov    0x8(%rsp),%rbp
mov    0x98(%rsp),%r8
testb  $0x1,0x18(%rsp)
je     2a6f <dradbg+0x194f>
nopl   0x0(%rax)
mov    0x70(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
subsd  (%rax,%r8,8),%xmm0
mov    0x1c8(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
addsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%r8,8)
add    %r9,%rbp
add    %r9,%r8
mov    %r12,%rax
or     $0x1,%rax
not    %r12
cmp    0xa0(%rsp),%r12
mov    0xc8(%rsp),%r10
je     2890 <dradbg+0x1770>
mov    0x18(%rsp),%rbx
sub    %rax,%rbx
mov    0x70(%rsp),%rsi
lea    (%rsi,%rbp,8),%rcx
mov    0x1c8(%rsp),%rdi
lea    (%rdi,%rbp,8),%r12
mov    (%rsp),%rax
add    %rax,%rbp
lea    (%rdi,%rbp,8),%r9
lea    (%rsi,%rbp,8),%rbp
lea    (%rsi,%r8,8),%rdx
lea    (%rdi,%r8,8),%r13
add    %rax,%r8
lea    (%rdi,%r8,8),%rax
lea    (%rsi,%r8,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rdi,1),%xmm0
subsd  (%rdx,%rdi,1),%xmm0
movsd  %xmm0,(%r12,%rdi,1)
movsd  (%rcx,%rdi,1),%xmm0
addsd  (%rdx,%rdi,1),%xmm0
movsd  %xmm0,0x0(%r13,%rdi,1)
movsd  0x0(%rbp,%rdi,1),%xmm0
subsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
movsd  0x0(%rbp,%rdi,1),%xmm0
addsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,(%rax,%rdi,1)
add    %r10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2c60 <dradbg+0x1b40>
jmp    2890 <dradbg+0x1770>
cmpq   $0x1,(%rsp)
mov    0x18(%rsp),%rax
je     398e <dradbg+0x286e>
cmp    %rax,0x108(%rsp)
jge    2e1e <dradbg+0x1cfe>
cmpq   $0x3,0x40(%rsp)
jl     2f5f <dradbg+0x1e3f>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovge %rax,%rcx
mov    %rcx,0x10(%rsp)
mov    0x80(%rsp),%rdx
mov    0x100(%rsp),%rsi
imul   %rdx,%rsi
mov    0x70(%rsp),%rcx
lea    (%rcx,%rsi,8),%r11
add    $0x10,%r11
lea    0x0(,%rdx,8),%r9
mov    %r9,%r10
neg    %r10
mov    (%rsp),%rax
lea    0x0(,%rax,8),%rdi
mov    0x1c8(%rsp),%rax
lea    (%rax,%rsi,8),%r14
add    $0x10,%r14
lea    (%rcx,%rdx,8),%r15
add    $0x10,%r15
lea    (%rax,%rdx,8),%r12
add    $0x10,%r12
mov    $0x1,%r13d
jmp    2d7b <dradbg+0x1c5b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r10,%r11
add    %r10,%r14
add    %r9,%r15
add    %r9,%r12
cmp    0x10(%rsp),%r13
je     2f5f <dradbg+0x1e3f>
cmpq   $0x3,(%rsp)
jl     2d60 <dradbg+0x1c40>
mov    $0x2,%ecx
mov    %r12,%rdx
mov    %r15,%rax
mov    %r14,%rbp
mov    %r11,%rsi
jmp    2dba <dradbg+0x1c9a>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rcx
add    $0x10,%rsi
add    $0x10,%rbp
add    $0x10,%rax
add    $0x10,%rdx
cmp    (%rsp),%rcx
jge    2d60 <dradbg+0x1c40>
cmpq   $0x0,0x18(%rsp)
jle    2da0 <dradbg+0x1c80>
xor    %ebx,%ebx
mov    0x18(%rsp),%r8
nopl   0x0(%rax)
movsd  -0x8(%rax,%rbx,1),%xmm0
subsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbx,1)
movsd  -0x8(%rax,%rbx,1),%xmm0
addsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%rbx,1)
movsd  (%rax,%rbx,1),%xmm0
addsd  -0x8(%rsi,%rbx,1),%xmm0
movsd  %xmm0,(%rdx,%rbx,1)
movsd  (%rax,%rbx,1),%xmm0
subsd  -0x8(%rsi,%rbx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,1)
add    %rdi,%rbx
add    $0xffffffffffffffff,%r8
jne    2dd0 <dradbg+0x1cb0>
jmp    2da0 <dradbg+0x1c80>
cmpq   $0x3,0x40(%rsp)
jl     2f5f <dradbg+0x1e3f>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovge %rax,%rcx
mov    %rcx,0x10(%rsp)
mov    0x80(%rsp),%rdx
mov    0x100(%rsp),%rsi
imul   %rdx,%rsi
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rsi,8),%r11
lea    0x0(,%rdx,8),%r9
mov    %r9,%r10
neg    %r10
mov    (%rsp),%rax
lea    0x0(,%rax,8),%rdi
mov    0x70(%rsp),%rax
lea    (%rax,%rsi,8),%r14
lea    (%rcx,%rdx,8),%r15
lea    (%rax,%rdx,8),%r12
mov    $0x1,%r13d
mov    (%rsp),%r8
jmp    2ebb <dradbg+0x1d9b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r10,%r11
add    %r10,%r14
add    %r9,%r15
add    %r9,%r12
cmp    0x10(%rsp),%r13
je     2f5f <dradbg+0x1e3f>
cmpq   $0x0,0x18(%rsp)
jle    2ea0 <dradbg+0x1d80>
mov    %r12,%rdx
mov    %r15,%rax
mov    %r14,%rbp
mov    %r11,%rcx
xor    %esi,%esi
jmp    2ef7 <dradbg+0x1dd7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
add    %rdi,%rcx
add    %rdi,%rbp
add    %rdi,%rax
add    %rdi,%rdx
cmp    0x18(%rsp),%rsi
je     2ea0 <dradbg+0x1d80>
cmp    $0x3,%r8
jl     2ee0 <dradbg+0x1dc0>
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rdx,%rbx,8),%xmm0
subsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbx,8)
movsd  -0x8(%rdx,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm0
addsd  -0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm0
subsd  -0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %r8,%rbx
jl     2f10 <dradbg+0x1df0>
jmp    2ee0 <dradbg+0x1dc0>
mov    0x30(%rsp),%rbp
test   %rbp,%rbp
mov    0x18(%rsp),%r9
mov    0x1d0(%rsp),%rdi
mov    0x1c0(%rsp),%rbx
jle    3100 <dradbg+0x1fe0>
cmp    $0x4,%rbp
jb     2f9a <dradbg+0x1e7a>
lea    (%rdi,%rbp,8),%rax
cmp    %rbx,%rax
jbe    300c <dradbg+0x1eec>
lea    (%rbx,%rbp,8),%rax
cmp    %rdi,%rax
jbe    300c <dradbg+0x1eec>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     2fc4 <dradbg+0x1ea4>
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2fb0 <dradbg+0x1e90>
cmp    $0x3,%rcx
jb     3100 <dradbg+0x1fe0>
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2fd0 <dradbg+0x1eb0>
jmp    3100 <dradbg+0x1fe0>
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0xc,%rsi
jae    3031 <dradbg+0x1f11>
xor    %esi,%esi
jmp    30ac <dradbg+0x1f8c>
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rsi,8),%xmm0
movups 0x10(%rdi,%rsi,8),%xmm1
movups %xmm0,(%rbx,%rsi,8)
movups %xmm1,0x10(%rbx,%rsi,8)
movups 0x20(%rdi,%rsi,8),%xmm0
movups 0x30(%rdi,%rsi,8),%xmm1
movups %xmm0,0x20(%rbx,%rsi,8)
movups %xmm1,0x30(%rbx,%rsi,8)
movups 0x40(%rdi,%rsi,8),%xmm0
movups 0x50(%rdi,%rsi,8),%xmm1
movups %xmm0,0x40(%rbx,%rsi,8)
movups %xmm1,0x50(%rbx,%rsi,8)
movupd 0x60(%rdi,%rsi,8),%xmm0
movupd 0x70(%rdi,%rsi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rsi,8)
movupd %xmm1,0x70(%rbx,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    3050 <dradbg+0x1f30>
test   %rcx,%rcx
je     30ef <dradbg+0x1fcf>
lea    (%rbx,%rsi,8),%rdx
add    $0x10,%rdx
mov    0x1d0(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nop
movupd -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    30d0 <dradbg+0x1fb0>
cmp    %rbp,%rax
mov    0x1d0(%rsp),%rdi
jne    2f9c <dradbg+0x1e7c>
cmpq   $0x2,0x40(%rsp)
mov    (%rsp),%rcx
jl     398e <dradbg+0x286e>
lea    -0x4(%r9),%rax
mov    %rax,0x78(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    $0x4,%r9
setae  %al
cmp    $0x1,%rcx
sete   %bl
and    %al,%bl
mov    %bl,0x38(%rsp)
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
imul   %rcx,%rax
mov    %rax,0xe8(%rsp)
mov    %rdx,%rax
mov    %rdx,0xa8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xc0(%rsp)
mov    %r9d,%r13d
and    $0x3,%r13d
lea    0x4(%r9),%rax
imul   %rcx,%rax
mov    0x70(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
add    $0x10,%rsi
mov    %rsi,0x90(%rsp)
mov    %rcx,%rsi
shl    $0x6,%rsi
mov    %rsi,0x88(%rsp)
mov    0x1c8(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
add    $0x10,%rax
mov    %rax,0xe0(%rsp)
mov    %r13,0x48(%rsp)
neg    %r13
mov    %rcx,%r8
shl    $0x5,%r8
lea    0x0(,%rcx,8),%r12
lea    (%r12,%r12,2),%rax
lea    (%rdx,%rax,1),%rdi
mov    %rdi,0x58(%rsp)
add    %rsi,%rax
mov    %rax,0x8(%rsp)
shl    $0x4,%rcx
lea    (%rdx,%rcx,1),%rax
mov    %rax,0xd0(%rsp)
add    %rsi,%rcx
mov    %rcx,0x60(%rsp)
mov    0x1d8(%rsp),%r14
lea    (%r9,%r9,1),%rax
mov    %rax,0x20(%rsp)
mov    0x80(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x68(%rsp)
lea    0x10(%rsi,%rax,8),%rcx
mov    %rcx,0xa0(%rsp)
lea    (%rdx,%rax,8),%rax
add    $0x10,%rax
mov    %rax,0xc8(%rsp)
mov    $0x1,%r10d
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
jmp    3289 <dradbg+0x2169>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
addq   $0x1,0x28(%rsp)
mov    0x10(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x10(%rsp)
cmp    0x40(%rsp),%r10
mov    0x18(%rsp),%r9
je     34ca <dradbg+0x23aa>
mov    0x30(%rsp),%rax
add    0x80(%rsp),%rax
mov    %rax,0x30(%rsp)
test   %r9,%r9
jle    3260 <dradbg+0x2140>
cmpb   $0x0,0x38(%rsp)
je     3300 <dradbg+0x21e0>
mov    0x28(%rsp),%rax
mov    0x18(%rsp),%r9
imul   %r9,%rax
mov    0x20(%rsp),%rcx
add    %rax,%rcx
add    %r9,%rax
mov    0x70(%rsp),%r11
lea    (%r11,%rax,8),%rdx
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rcx,8),%rsi
cmp    %rsi,%rdx
jae    330c <dradbg+0x21ec>
lea    (%r11,%rcx,8),%rcx
lea    (%rbx,%rax,8),%rax
cmp    %rcx,%rax
jae    330c <dradbg+0x21ec>
xor    %edi,%edi
mov    0x30(%rsp),%rbp
mov    (%rsp),%rcx
jmp    33f6 <dradbg+0x22d6>
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
mov    0x30(%rsp),%rbp
jmp    33e0 <dradbg+0x22c0>
cmpq   $0x4,0x78(%rsp)
jae    3318 <dradbg+0x21f8>
xor    %edi,%edi
jmp    3388 <dradbg+0x2268>
mov    0xc0(%rsp),%rax
mov    0x10(%rsp),%rdx
xor    %edi,%edi
mov    0xa0(%rsp),%rsi
mov    0xc8(%rsp),%rbp
mov    0x90(%rsp),%rcx
mov    0x88(%rsp),%r15
mov    0xe0(%rsp),%r9
nop
movups -0x10(%rsi,%rdx,1),%xmm0
movups (%rsi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rdx,1)
movups %xmm1,0x0(%rbp,%rdx,1)
movupd -0x10(%r9,%rdx,1),%xmm0
movupd (%r9,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x8,%rdi
add    %r15,%rdx
add    $0xfffffffffffffffe,%rax
jne    3350 <dradbg+0x2230>
testb  $0x1,0xa8(%rsp)
01
je     33b4 <dradbg+0x2294>
imul   (%rsp),%rdi
add    0x30(%rsp),%rdi
movupd (%rbx,%rdi,8),%xmm0
movupd 0x10(%rbx,%rdi,8),%xmm1
movupd %xmm0,(%r11,%rdi,8)
movupd %xmm1,0x10(%r11,%rdi,8)
mov    0x18(%rsp),%rax
cmp    %rax,0x50(%rsp)
je     3260 <dradbg+0x2140>
mov    0xe8(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    0x50(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%r9
mov    (%rsp),%rcx
mov    0x70(%rsp),%r11
mov    0x1c8(%rsp),%rbx
mov    %rdi,%rdx
not    %rdx
add    %r9,%rdx
cmpq   $0x0,0x48(%rsp)
je     342a <dradbg+0x230a>
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%r11,%rbp,8)
add    %rcx,%rbp
add    $0xffffffffffffffff,%rax
cmp    %rax,%r13
jne    3410 <dradbg+0x22f0>
sub    %rax,%rdi
cmp    $0x3,%rdx
jb     3260 <dradbg+0x2140>
mov    0x18(%rsp),%rbx
sub    %rdi,%rbx
mov    0x1c8(%rsp),%rax
lea    (%rax,%rbp,8),%rdi
mov    0x70(%rsp),%r15
lea    (%r15,%rbp,8),%rsi
mov    0x58(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rbp,8),%rdx
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rbp,8),%r9
mov    0x60(%rsp),%rcx
lea    (%rcx,%rbp,8),%r11
add    (%rsp),%rbp
lea    (%r15,%rbp,8),%r15
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rbp,8),%rbp
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  (%rdi,%rcx,1),%xmm0
movsd  %xmm0,(%rsi,%rcx,1)
movsd  0x0(%rbp,%rcx,1),%xmm0
movsd  %xmm0,(%r15,%rcx,1)
movsd  (%r11,%rcx,1),%xmm0
movsd  %xmm0,(%r9,%rcx,1)
movsd  (%rdx,%rcx,1),%xmm0
movsd  %xmm0,(%rax,%rcx,1)
add    %r8,%rcx
add    $0xfffffffffffffffc,%rbx
jne    3490 <dradbg+0x2370>
jmp    3260 <dradbg+0x2140>
cmp    %r9,0x108(%rsp)
jle    3899 <dradbg+0x2779>
cmpq   $0x2,0x40(%rsp)
mov    (%rsp),%r10
jl     398e <dradbg+0x286e>
mov    %r10,%rax
not    %rax
mov    %rax,0x30(%rsp)
mov    0x80(%rsp),%rdx
lea    0x1(%rdx),%rax
mov    %rax,0xe0(%rsp)
lea    -0x3(%r10),%rcx
mov    %rcx,%rax
shr    %rax
mov    %rcx,0x10(%rsp)
and    $0xfffffffffffffffe,%rcx
lea    (%rdx,%rcx,1),%rdi
add    $0x3,%rdi
mov    %rdi,0xf0(%rsp)
add    $0x2,%rcx
mov    %rcx,0xf8(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,0xa0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xd0(%rsp)
add    %rcx,%rcx
mov    %rcx,0x50(%rsp)
add    %rax,%rax
add    $0x2,%rax
or     $0x2,%rax
mov    %rax,0xc8(%rsp)
mov    0x70(%rsp),%rax
lea    (%rax,%rdx,8),%rcx
add    $0x8,%rcx
mov    %rcx,0xc0(%rsp)
mov    0x1c8(%rsp),%rcx
lea    0x8(%rcx,%rdx,8),%rdx
mov    %rdx,0x90(%rsp)
lea    0x10(%r14),%rdx
mov    %rdx,0x28(%rsp)
add    $0x10,%rax
mov    %rax,0x38(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x48(%rsp)
mov    $0x1,%edx
xor    %eax,%eax
mov    %rax,0x88(%rsp)
mov    %r14,%rcx
xor    %edi,%edi
jmp    3615 <dradbg+0x24f5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe8(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,0x88(%rsp)
mov    0x68(%rsp),%rax
add    %rax,0xc0(%rsp)
add    %rax,0x90(%rsp)
add    %r12,%rcx
mov    0xa8(%rsp),%rdi
cmp    0x40(%rsp),%rdx
mov    0x18(%rsp),%r9
je     398e <dradbg+0x286e>
mov    %rdx,0xe8(%rsp)
add    %r10,0x30(%rsp)
mov    0x80(%rsp),%rax
add    %rdi,%rax
mov    %rax,0xa8(%rsp)
test   %r9,%r9
jle    35d0 <dradbg+0x24b0>
mov    %rdi,%rdx
mov    0xe0(%rsp),%rax
add    %rdi,%rax
mov    %rax,0x8(%rsp)
add    0xf0(%rsp),%rdx
mov    %rdx,0x20(%rsp)
mov    0x88(%rsp),%rax
imul   %r10,%rax
mov    0xf8(%rsp),%rdx
add    %rax,%rdx
lea    (%r14,%rax,8),%rax
mov    %rax,0x58(%rsp)
lea    (%r14,%rdx,8),%rax
mov    %rax,0x60(%rsp)
mov    0x30(%rsp),%rax
mov    0x50(%rsp),%rdx
add    %rdx,%rax
mov    %rax,0x78(%rsp)
mov    0x90(%rsp),%r15
mov    0xc0(%rsp),%r13
xor    %r11d,%r11d
mov    0xa8(%rsp),%rdx
jmp    36d8 <dradbg+0x25b8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r10,%rdx
add    $0x1,%r11
add    %r12,%r13
add    %r12,%r15
cmp    0x18(%rsp),%r11
je     35d0 <dradbg+0x24b0>
cmp    $0x3,%r10
jl     36c0 <dradbg+0x25a0>
mov    $0x2,%edi
cmpq   $0x2,0x10(%rsp)
jb     3810 <dradbg+0x26f0>
mov    %r11,%rax
imul   (%rsp),%rax
mov    0x8(%rsp),%rsi
add    %rax,%rsi
add    0x20(%rsp),%rax
mov    0x70(%rsp),%rbx
lea    (%rbx,%rsi,8),%rbp
lea    (%rbx,%rax,8),%r10
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rsi,8),%rsi
lea    (%rbx,%rax,8),%rax
cmp    0x60(%rsp),%rbp
setb   %r8b
cmp    %r10,0x58(%rsp)
setb   %r9b
cmp    %rax,%rbp
setb   %al
cmp    %r10,%rsi
setb   %bl
test   %r9b,%r8b
jne    3810 <dradbg+0x26f0>
mov    0x30(%rsp),%rsi
mov    %rdx,%r8
and    %bl,%al
mov    (%rsp),%r10
jne    381c <dradbg+0x26fc>
mov    0x50(%rsp),%rax
lea    (%rdx,%rax,1),%r8
mov    0xd0(%rsp),%rdi
xor    %ebx,%ebx
nop
movupd (%rcx,%rbx,1),%xmm0
movupd 0x10(%rcx,%rbx,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd (%r15,%rbx,1),%xmm1
movupd 0x10(%r15,%rbx,1),%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm1
movapd %xmm1,%xmm3
mulpd  %xmm0,%xmm3
mulpd  %xmm2,%xmm1
mulpd  %xmm4,%xmm2
subpd  %xmm3,%xmm2
mulpd  %xmm0,%xmm4
addpd  %xmm4,%xmm1
movapd %xmm2,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm2,%xmm1
movups %xmm1,0x10(%r13,%rbx,1)
movupd %xmm0,0x0(%r13,%rbx,1)
add    $0x20,%rbx
add    $0xfffffffffffffffe,%rdi
jne    3770 <dradbg+0x2650>
mov    0x78(%rsp),%rsi
mov    0xc8(%rsp),%rdi
mov    0xd0(%rsp),%rax
cmp    %rax,0xa0(%rsp)
mov    (%rsp),%r10
je     36c0 <dradbg+0x25a0>
jmp    381c <dradbg+0x26fc>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rsi
mov    %rdx,%r8
mov    (%rsp),%r10
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,8),%rbx
mov    0x38(%rsp),%rax
lea    (%rax,%r8,8),%r9
mov    0x48(%rsp),%rax
lea    (%rax,%r8,8),%rbp
xor    %esi,%esi
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm0
mulsd  (%rbx,%rsi,8),%xmm0
movsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  -0x8(%rbp,%rsi,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r9,%rsi,8)
movsd  (%rbx,%rsi,8),%xmm0
mulsd  -0x8(%rbp,%rsi,8),%xmm0
movsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  0x0(%rbp,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rsi,8)
lea    (%rdi,%rsi,1),%rax
add    $0x2,%rax
add    $0x2,%rsi
cmp    %r10,%rax
jl     3840 <dradbg+0x2720>
jmp    36c0 <dradbg+0x25a0>
cmpq   $0x2,0x40(%rsp)
mov    (%rsp),%rax
mov    0xa0(%rsp),%r11
mov    0xc8(%rsp),%r15
jl     398e <dradbg+0x286e>
mov    %rax,%r8
not    %r8
mov    $0x1,%r10d
jmp    38ee <dradbg+0x27ce>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x68(%rsp),%rax
add    %rax,%r11
add    %rax,%r15
cmp    0x40(%rsp),%r10
mov    (%rsp),%rax
je     398e <dradbg+0x286e>
add    %rax,%r8
cmp    $0x3,%rax
jl     38d0 <dradbg+0x27b0>
mov    $0x2,%edx
mov    %r15,%rdi
mov    %r11,%rsi
mov    %r8,%rbp
jmp    3925 <dradbg+0x2805>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rdx
add    $0x10,%rsi
add    $0x10,%rdi
mov    %rbx,%rbp
cmp    (%rsp),%rdx
jge    38d0 <dradbg+0x27b0>
lea    0x2(%rbp),%rbx
test   %r9,%r9
jle    3910 <dradbg+0x27f0>
xor    %eax,%eax
mov    %r9,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r14,%rbp,8),%xmm0
movsd  (%rsi,%rax,1),%xmm1
mulsd  (%r14,%rbx,8),%xmm1
mulsd  -0x8(%rsi,%rax,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,1)
movsd  0x8(%r14,%rbp,8),%xmm0
movsd  (%r14,%rbx,8),%xmm1
mulsd  -0x8(%rsi,%rax,1),%xmm1
mulsd  (%rsi,%rax,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %r12,%rax
add    $0xffffffffffffffff,%rcx
jne    3940 <dradbg+0x2820>
jmp    3910 <dradbg+0x27f0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @dradbg(i64 %0, i64 %1, i64 %2, i64 %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double* %7, double* nocapture %8, double* nocapture %9) {
%11 = mul i64 %1, %0
%12 = mul i64 %2, %0
%13 = sitofp i64 %1 to double
%14 = fdiv double 0x401921FB54442D18, %13
%15 = tail call double @cos(double %14)
%16 = tail call double @sin(double %14)
%17 = add nsw i64 %0, -1
%18 = ashr i64 %17, 1
%19 = add nsw i64 %1, 1
%20 = ashr i64 %19, 1
%21 = icmp slt i64 %0, %2
br i1 %21, label %38, label %22
22: ; preds = %10
%23 = icmp sgt i64 %2, 0
br i1 %23, label %24, label %277
24: ; preds = %22
%25 = icmp sgt i64 %0, 0
%26 = add i64 %0, -4
%27 = lshr i64 %26, 2
%28 = add nuw nsw i64 %27, 1
%29 = icmp ult i64 %0, 4
%30 = and i64 %0, -4
%31 = and i64 %28, 1
%32 = icmp ult i64 %26, 4
%33 = and i64 %28, 9223372036854775806
%34 = icmp eq i64 %31, 0
%35 = icmp eq i64 %30, %0
%36 = and i64 %0, 3
%37 = icmp eq i64 %36, 0
br label %55
38: ; preds = %10
%39 = icmp sgt i64 %0, 0
br i1 %39, label %40, label %277
40: ; preds = %38
%41 = icmp sgt i64 %2, 0
%42 = add i64 %2, -1
%43 = mul i64 %42, %1
%44 = icmp ugt i64 %2, 3
%45 = icmp eq i64 %0, 1
%46 = and i1 %44, %45
%47 = and i64 %2, -4
%48 = mul i64 %47, %0
%49 = mul i64 %47, %11
%50 = shl i64 %11, 1
%51 = mul i64 %11, 3
%52 = icmp eq i64 %47, %2
%53 = and i64 %2, 3
%54 = icmp eq i64 %53, 0
br label %175
55: ; preds = %24, %170
%56 = phi i64 [ 0, %24 ], [ %173, %170 ]
%57 = phi i64 [ 0, %24 ], [ %171, %170 ]
%58 = phi i64 [ 0, %24 ], [ %172, %170 ]
%59 = getelementptr double, double* %7, i64 %57
%60 = add i64 %57, %0
%61 = getelementptr double, double* %7, i64 %60
%62 = getelementptr double, double* %4, i64 %58
%63 = add i64 %58, %0
%64 = getelementptr double, double* %4, i64 %63
br i1 %25, label %65, label %170
65: ; preds = %55
br i1 %29, label %120, label %66
66: ; preds = %65
%67 = icmp ult double* %59, %64
%68 = icmp ult double* %62, %61
%69 = and i1 %67, %68
br i1 %69, label %120, label %70
70: ; preds = %66
%71 = add i64 %57, %30
%72 = add i64 %58, %30
br i1 %32, label %104, label %73
73: ; preds = %70, %73
%74 = phi i64 [ %101, %73 ], [ 0, %70 ]
%75 = phi i64 [ %102, %73 ], [ 0, %70 ]
%76 = add i64 %57, %74
%77 = add i64 %58, %74
%78 = getelementptr inbounds double, double* %4, i64 %77
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = getelementptr inbounds double, double* %78, i64 2
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = getelementptr inbounds double, double* %7, i64 %76
%85 = bitcast double* %84 to <2 x double>*
store <2 x double> %80, <2 x double>* %85
%86 = getelementptr inbounds double, double* %84, i64 2
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %83, <2 x double>* %87
%88 = or i64 %74, 4
%89 = add i64 %57, %88
%90 = add i64 %58, %88
%91 = getelementptr inbounds double, double* %4, i64 %90
%92 = bitcast double* %91 to <2 x double>*
%93 = load <2 x double>, <2 x double>* %92
%94 = getelementptr inbounds double, double* %91, i64 2
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %7, i64 %89
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %93, <2 x double>* %98
%99 = getelementptr inbounds double, double* %97, i64 2
%100 = bitcast double* %99 to <2 x double>*
store <2 x double> %96, <2 x double>* %100
%101 = add nuw i64 %74, 8
%102 = add i64 %75, 2
%103 = icmp eq i64 %102, %33
br i1 %103, label %104, label %73
104: ; preds = %73, %70
%105 = phi i64 [ 0, %70 ], [ %101, %73 ]
br i1 %34, label %119, label %106
106: ; preds = %104
%107 = add i64 %57, %105
%108 = add i64 %58, %105
%109 = getelementptr inbounds double, double* %4, i64 %108
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr inbounds double, double* %109, i64 2
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %7, i64 %107
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %111, <2 x double>* %116
%117 = getelementptr inbounds double, double* %115, i64 2
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> %114, <2 x double>* %118
br label %119
119: ; preds = %104, %106
br i1 %35, label %170, label %120
120: ; preds = %66, %65, %119
%121 = phi i64 [ 0, %66 ], [ 0, %65 ], [ %30, %119 ]
%122 = phi i64 [ %57, %66 ], [ %57, %65 ], [ %71, %119 ]
%123 = phi i64 [ %58, %66 ], [ %58, %65 ], [ %72, %119 ]
%124 = xor i64 %121, -1
%125 = add i64 %124, %0
br i1 %37, label %139, label %126
126: ; preds = %120, %126
%127 = phi i64 [ %136, %126 ], [ %121, %120 ]
%128 = phi i64 [ %134, %126 ], [ %122, %120 ]
%129 = phi i64 [ %135, %126 ], [ %123, %120 ]
%130 = phi i64 [ %137, %126 ], [ 0, %120 ]
%131 = getelementptr inbounds double, double* %4, i64 %129
%132 = load double, double* %131
%133 = getelementptr inbounds double, double* %7, i64 %128
store double %132, double* %133
%134 = add nsw i64 %128, 1
%135 = add nsw i64 %129, 1
%136 = add nuw nsw i64 %127, 1
%137 = add i64 %130, 1
%138 = icmp eq i64 %137, %36
br i1 %138, label %139, label %126
139: ; preds = %126, %120
%140 = phi i64 [ %121, %120 ], [ %136, %126 ]
%141 = phi i64 [ %122, %120 ], [ %134, %126 ]
%142 = phi i64 [ %123, %120 ], [ %135, %126 ]
%143 = icmp ult i64 %125, 3
br i1 %143, label %170, label %144
144: ; preds = %139, %144
%145 = phi i64 [ %168, %144 ], [ %140, %139 ]
%146 = phi i64 [ %166, %144 ], [ %141, %139 ]
%147 = phi i64 [ %167, %144 ], [ %142, %139 ]
%148 = getelementptr inbounds double, double* %4, i64 %147
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %7, i64 %146
store double %149, double* %150
%151 = add nsw i64 %146, 1
%152 = add nsw i64 %147, 1
%153 = getelementptr inbounds double, double* %4, i64 %152
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %7, i64 %151
store double %154, double* %155
%156 = add nsw i64 %146, 2
%157 = add nsw i64 %147, 2
%158 = getelementptr inbounds double, double* %4, i64 %157
%159 = load double, double* %158
%160 = getelementptr inbounds double, double* %7, i64 %156
store double %159, double* %160
%161 = add nsw i64 %146, 3
%162 = add nsw i64 %147, 3
%163 = getelementptr inbounds double, double* %4, i64 %162
%164 = load double, double* %163
%165 = getelementptr inbounds double, double* %7, i64 %161
store double %164, double* %165
%166 = add nsw i64 %146, 4
%167 = add nsw i64 %147, 4
%168 = add nuw nsw i64 %145, 4
%169 = icmp eq i64 %168, %0
br i1 %169, label %170, label %144
170: ; preds = %139, %144, %119, %55
%171 = add nsw i64 %57, %0
%172 = add nsw i64 %58, %11
%173 = add nuw nsw i64 %56, 1
%174 = icmp eq i64 %173, %2
br i1 %174, label %277, label %55
175: ; preds = %40, %274
%176 = phi i64 [ 0, %40 ], [ %275, %274 ]
%177 = getelementptr double, double* %7, i64 %176
%178 = add i64 %176, %2
%179 = getelementptr double, double* %7, i64 %178
%180 = getelementptr double, double* %4, i64 %176
%181 = add i64 %43, %176
%182 = getelementptr double, double* %4, i64 %181
%183 = icmp ult double* %180, %182
%184 = select i1 %183, double* %180, double* %182
%185 = icmp ugt double* %180, %182
%186 = select i1 %185, double* %180, double* %182
%187 = getelementptr double, double* %186, i64 1
br i1 %41, label %188, label %274
188: ; preds = %175
br i1 %46, label %189, label %224
189: ; preds = %188
%190 = icmp ult double* %177, %187
%191 = icmp ult double* %184, %179
%192 = and i1 %190, %191
br i1 %192, label %224, label %193
193: ; preds = %189
%194 = add i64 %176, %48
%195 = add i64 %176, %49
br label %196
196: ; preds = %196, %193
%197 = phi i64 [ 0, %193 ], [ %221, %196 ]
%198 = mul i64 %197, %0
%199 = add i64 %176, %198
%200 = mul i64 %197, %11
%201 = add i64 %176, %200
%202 = add i64 %201, %11
%203 = add i64 %201, %50
%204 = add i64 %201, %51
%205 = getelementptr inbounds double, double* %4, i64 %201
%206 = getelementptr inbounds double, double* %4, i64 %202
%207 = getelementptr inbounds double, double* %4, i64 %203
%208 = getelementptr inbounds double, double* %4, i64 %204
%209 = load double, double* %205
%210 = load double, double* %206
%211 = insertelement <2 x double> poison, double %209, i64 0
%212 = insertelement <2 x double> %211, double %210, i64 1
%213 = load double, double* %207
%214 = load double, double* %208
%215 = insertelement <2 x double> poison, double %213, i64 0
%216 = insertelement <2 x double> %215, double %214, i64 1
%217 = getelementptr inbounds double, double* %7, i64 %199
%218 = bitcast double* %217 to <2 x double>*
store <2 x double> %212, <2 x double>* %218
%219 = getelementptr inbounds double, double* %217, i64 2
%220 = bitcast double* %219 to <2 x double>*
store <2 x double> %216, <2 x double>* %220
%221 = add nuw i64 %197, 4
%222 = icmp eq i64 %221, %47
br i1 %222, label %223, label %196
223: ; preds = %196
br i1 %52, label %274, label %224
224: ; preds = %189, %188, %223
%225 = phi i64 [ 0, %189 ], [ 0, %188 ], [ %47, %223 ]
%226 = phi i64 [ %176, %189 ], [ %176, %188 ], [ %194, %223 ]
%227 = phi i64 [ %176, %189 ], [ %176, %188 ], [ %195, %223 ]
%228 = xor i64 %225, -1
%229 = add i64 %228, %2
br i1 %54, label %243, label %230
230: ; preds = %224, %230
%231 = phi i64 [ %240, %230 ], [ %225, %224 ]
%232 = phi i64 [ %238, %230 ], [ %226, %224 ]
%233 = phi i64 [ %239, %230 ], [ %227, %224 ]
%234 = phi i64 [ %241, %230 ], [ 0, %224 ]
%235 = getelementptr inbounds double, double* %4, i64 %233
%236 = load double, double* %235
%237 = getelementptr inbounds double, double* %7, i64 %232
store double %236, double* %237
%238 = add nsw i64 %232, %0
%239 = add nsw i64 %233, %11
%240 = add nuw nsw i64 %231, 1
%241 = add i64 %234, 1
%242 = icmp eq i64 %241, %53
br i1 %242, label %243, label %230
243: ; preds = %230, %224
%244 = phi i64 [ %225, %224 ], [ %240, %230 ]
%245 = phi i64 [ %226, %224 ], [ %238, %230 ]
%246 = phi i64 [ %227, %224 ], [ %239, %230 ]
%247 = icmp ult i64 %229, 3
br i1 %247, label %274, label %248
248: ; preds = %243, %248
%249 = phi i64 [ %272, %248 ], [ %244, %243 ]
%250 = phi i64 [ %270, %248 ], [ %245, %243 ]
%251 = phi i64 [ %271, %248 ], [ %246, %243 ]
%252 = getelementptr inbounds double, double* %4, i64 %251
%253 = load double, double* %252
%254 = getelementptr inbounds double, double* %7, i64 %250
store double %253, double* %254
%255 = add nsw i64 %250, %0
%256 = add nsw i64 %251, %11
%257 = getelementptr inbounds double, double* %4, i64 %256
%258 = load double, double* %257
%259 = getelementptr inbounds double, double* %7, i64 %255
store double %258, double* %259
%260 = add nsw i64 %255, %0
%261 = add nsw i64 %256, %11
%262 = getelementptr inbounds double, double* %4, i64 %261
%263 = load double, double* %262
%264 = getelementptr inbounds double, double* %7, i64 %260
store double %263, double* %264
%265 = add nsw i64 %260, %0
%266 = add nsw i64 %261, %11
%267 = getelementptr inbounds double, double* %4, i64 %266
%268 = load double, double* %267
%269 = getelementptr inbounds double, double* %7, i64 %265
store double %268, double* %269
%270 = add nsw i64 %265, %0
%271 = add nsw i64 %266, %11
%272 = add nuw nsw i64 %249, 4
%273 = icmp eq i64 %272, %2
br i1 %273, label %274, label %248
274: ; preds = %243, %248, %223, %175
%275 = add nuw nsw i64 %176, 1
%276 = icmp eq i64 %275, %0
br i1 %276, label %277, label %175
277: ; preds = %170, %274, %22, %38
%278 = mul nsw i64 %12, %1
%279 = shl i64 %0, 1
%280 = icmp sgt i64 %1, 2
br i1 %280, label %281, label %345
281: ; preds = %277
%282 = icmp sgt i64 %2, 0
%283 = call i64 @llvm.smax.i64(i64 %20, i64 2)
%284 = and i64 %2, 1
%285 = icmp eq i64 %2, 1
%286 = and i64 %2, -2
%287 = icmp eq i64 %284, 0
br label %288
288: ; preds = %281, %341
%289 = phi i64 [ 1, %281 ], [ %343, %341 ]
%290 = phi i64 [ 0, %281 ], [ %293, %341 ]
%291 = phi i64 [ %278, %281 ], [ %294, %341 ]
%292 = phi i64 [ %279, %281 ], [ %342, %341 ]
%293 = add nsw i64 %290, %12
%294 = sub nsw i64 %291, %12
br i1 %282, label %295, label %341
295: ; preds = %288
br i1 %285, label %327, label %296
296: ; preds = %295, %296
%297 = phi i64 [ %322, %296 ], [ %293, %295 ]
%298 = phi i64 [ %324, %296 ], [ %292, %295 ]
%299 = phi i64 [ %323, %296 ], [ %294, %295 ]
%300 = phi i64 [ %325, %296 ], [ 0, %295 ]
%301 = add nsw i64 %298, -1
%302 = getelementptr inbounds double, double* %4, i64 %301
%303 = load double, double* %302
%304 = fadd double %303, %303
%305 = getelementptr inbounds double, double* %7, i64 %297
store double %304, double* %305
%306 = getelementptr inbounds double, double* %4, i64 %298
%307 = load double, double* %306
%308 = fadd double %307, %307
%309 = getelementptr inbounds double, double* %7, i64 %299
store double %308, double* %309
%310 = add nsw i64 %297, %0
%311 = add nsw i64 %299, %0
%312 = add nsw i64 %298, %11
%313 = add nsw i64 %312, -1
%314 = getelementptr inbounds double, double* %4, i64 %313
%315 = load double, double* %314
%316 = fadd double %315, %315
%317 = getelementptr inbounds double, double* %7, i64 %310
store double %316, double* %317
%318 = getelementptr inbounds double, double* %4, i64 %312
%319 = load double, double* %318
%320 = fadd double %319, %319
%321 = getelementptr inbounds double, double* %7, i64 %311
store double %320, double* %321
%322 = add nsw i64 %310, %0
%323 = add nsw i64 %311, %0
%324 = add nsw i64 %312, %11
%325 = add i64 %300, 2
%326 = icmp eq i64 %325, %286
br i1 %326, label %327, label %296
327: ; preds = %296, %295
%328 = phi i64 [ %293, %295 ], [ %322, %296 ]
%329 = phi i64 [ %292, %295 ], [ %324, %296 ]
%330 = phi i64 [ %294, %295 ], [ %323, %296 ]
br i1 %287, label %341, label %331
331: ; preds = %327
%332 = add nsw i64 %329, -1
%333 = getelementptr inbounds double, double* %4, i64 %332
%334 = load double, double* %333
%335 = fadd double %334, %334
%336 = getelementptr inbounds double, double* %7, i64 %328
store double %335, double* %336
%337 = getelementptr inbounds double, double* %4, i64 %329
%338 = load double, double* %337
%339 = fadd double %338, %338
%340 = getelementptr inbounds double, double* %7, i64 %330
store double %339, double* %340
br label %341
341: ; preds = %331, %327, %288
%342 = add nsw i64 %292, %279
%343 = add nuw nsw i64 %289, 1
%344 = icmp eq i64 %343, %283
br i1 %344, label %345, label %288
345: ; preds = %341, %277
%346 = icmp eq i64 %0, 1
br i1 %346, label %477, label %347
347: ; preds = %345
%348 = icmp slt i64 %18, %2
br i1 %348, label %354, label %349
349: ; preds = %347
br i1 %280, label %350, label %1245
350: ; preds = %349
%351 = icmp sgt i64 %2, 0
%352 = icmp sgt i64 %0, 2
%353 = call i64 @llvm.smax.i64(i64 %20, i64 2)
br label %359
354: ; preds = %347
br i1 %280, label %355, label %1245
355: ; preds = %354
%356 = icmp sgt i64 %0, 2
%357 = icmp sgt i64 %2, 0
%358 = call i64 @llvm.smax.i64(i64 %20, i64 2)
br label %417
359: ; preds = %350, %414
%360 = phi i64 [ 1, %350 ], [ %415, %414 ]
%361 = phi i64 [ 0, %350 ], [ %364, %414 ]
%362 = phi i64 [ %278, %350 ], [ %365, %414 ]
%363 = phi i64 [ 0, %350 ], [ %366, %414 ]
%364 = add nsw i64 %361, %12
%365 = sub nsw i64 %362, %12
%366 = add nsw i64 %363, %279
br i1 %351, label %367, label %414
367: ; preds = %359, %408
%368 = phi i64 [ %412, %408 ], [ 0, %359 ]
%369 = phi i64 [ %409, %408 ], [ %364, %359 ]
%370 = phi i64 [ %411, %408 ], [ %366, %359 ]
%371 = phi i64 [ %410, %408 ], [ %365, %359 ]
br i1 %352, label %372, label %408
372: ; preds = %367, %372
%373 = phi i64 [ %406, %372 ], [ 2, %367 ]
%374 = phi i64 [ %381, %372 ], [ %370, %367 ]
%375 = phi i64 [ %380, %372 ], [ %370, %367 ]
%376 = phi i64 [ %379, %372 ], [ %371, %367 ]
%377 = phi i64 [ %378, %372 ], [ %369, %367 ]
%378 = add nsw i64 %377, 2
%379 = add nsw i64 %376, 2
%380 = add nsw i64 %375, 2
%381 = add nsw i64 %374, -2
%382 = add nsw i64 %375, 1
%383 = getelementptr inbounds double, double* %4, i64 %382
%384 = load double, double* %383
%385 = add nsw i64 %374, -3
%386 = getelementptr inbounds double, double* %4, i64 %385
%387 = load double, double* %386
%388 = fadd double %384, %387
%389 = add nsw i64 %377, 1
%390 = getelementptr inbounds double, double* %7, i64 %389
store double %388, double* %390
%391 = load double, double* %383
%392 = load double, double* %386
%393 = fsub double %391, %392
%394 = add nsw i64 %376, 1
%395 = getelementptr inbounds double, double* %7, i64 %394
store double %393, double* %395
%396 = getelementptr inbounds double, double* %4, i64 %380
%397 = load double, double* %396
%398 = getelementptr inbounds double, double* %4, i64 %381
%399 = load double, double* %398
%400 = fsub double %397, %399
%401 = getelementptr inbounds double, double* %7, i64 %378
store double %400, double* %401
%402 = load double, double* %396
%403 = load double, double* %398
%404 = fadd double %402, %403
%405 = getelementptr inbounds double, double* %7, i64 %379
store double %404, double* %405
%406 = add nuw nsw i64 %373, 2
%407 = icmp slt i64 %406, %0
br i1 %407, label %372, label %408
408: ; preds = %372, %367
%409 = add nsw i64 %369, %0
%410 = add nsw i64 %371, %0
%411 = add nsw i64 %370, %11
%412 = add nuw nsw i64 %368, 1
%413 = icmp eq i64 %412, %2
br i1 %413, label %414, label %367
414: ; preds = %408, %359
%415 = add nuw nsw i64 %360, 1
%416 = icmp eq i64 %415, %353
br i1 %416, label %477, label %359
417: ; preds = %355, %474
%418 = phi i64 [ 1, %355 ], [ %475, %474 ]
%419 = phi i64 [ 0, %355 ], [ %422, %474 ]
%420 = phi i64 [ %278, %355 ], [ %423, %474 ]
%421 = phi i64 [ 0, %355 ], [ %424, %474 ]
%422 = add nsw i64 %419, %12
%423 = sub nsw i64 %420, %12
%424 = add nsw i64 %421, %279
br i1 %356, label %425, label %474
425: ; preds = %417, %471
%426 = phi i64 [ %472, %471 ], [ 2, %417 ]
%427 = phi i64 [ %431, %471 ], [ %422, %417 ]
%428 = phi i64 [ %434, %471 ], [ %424, %417 ]
%429 = phi i64 [ %433, %471 ], [ %424, %417 ]
%430 = phi i64 [ %432, %471 ], [ %423, %417 ]
%431 = add nsw i64 %427, 2
%432 = add nsw i64 %430, 2
%433 = add nsw i64 %429, 2
%434 = add nsw i64 %428, -2
br i1 %357, label %435, label %471
435: ; preds = %425, %435
%436 = phi i64 [ %469, %435 ], [ 0, %425 ]
%437 = phi i64 [ %468, %435 ], [ %434, %425 ]
%438 = phi i64 [ %467, %435 ], [ %433, %425 ]
%439 = phi i64 [ %466, %435 ], [ %432, %425 ]
%440 = phi i64 [ %465, %435 ], [ %431, %425 ]
%441 = add nsw i64 %438, -1
%442 = getelementptr inbounds double, double* %4, i64 %441
%443 = load double, double* %442
%444 = add nsw i64 %437, -1
%445 = getelementptr inbounds double, double* %4, i64 %444
%446 = load double, double* %445
%447 = fadd double %443, %446
%448 = add nsw i64 %440, -1
%449 = getelementptr inbounds double, double* %7, i64 %448
store double %447, double* %449
%450 = load double, double* %442
%451 = load double, double* %445
%452 = fsub double %450, %451
%453 = add nsw i64 %439, -1
%454 = getelementptr inbounds double, double* %7, i64 %453
store double %452, double* %454
%455 = getelementptr inbounds double, double* %4, i64 %438
%456 = load double, double* %455
%457 = getelementptr inbounds double, double* %4, i64 %437
%458 = load double, double* %457
%459 = fsub double %456, %458
%460 = getelementptr inbounds double, double* %7, i64 %440
store double %459, double* %460
%461 = load double, double* %455
%462 = load double, double* %457
%463 = fadd double %461, %462
%464 = getelementptr inbounds double, double* %7, i64 %439
store double %463, double* %464
%465 = add nsw i64 %440, %0
%466 = add nsw i64 %439, %0
%467 = add nsw i64 %438, %11
%468 = add nsw i64 %437, %11
%469 = add nuw nsw i64 %436, 1
%470 = icmp eq i64 %469, %2
br i1 %470, label %471, label %435
471: ; preds = %435, %425
%472 = add nuw nsw i64 %426, 2
%473 = icmp slt i64 %472, %0
br i1 %473, label %425, label %474
474: ; preds = %471, %417
%475 = add nuw nsw i64 %418, 1
%476 = icmp eq i64 %475, %358
br i1 %476, label %477, label %417
477: ; preds = %414, %474, %345
%478 = mul i64 %3, %1
%479 = add i64 %1, -1
%480 = mul nsw i64 %479, %3
br i1 %280, label %481, label %1136
481: ; preds = %477
%482 = fneg double %16
%483 = icmp sgt i64 %3, 0
%484 = sub i64 %478, %3
%485 = icmp ugt i64 %1, 4
%486 = call i64 @llvm.smax.i64(i64 %20, i64 3)
%487 = call i64 @llvm.smax.i64(i64 %20, i64 2)
%488 = shl i64 %3, 1
%489 = mul i64 %3, 3
%490 = add i64 %1, -2
%491 = mul i64 %490, %3
%492 = shl i64 %1, 3
%493 = add i64 %492, -8
%494 = mul i64 %493, %3
%495 = shl i64 %3, 1
%496 = getelementptr double, double* %8, i64 %3
%497 = getelementptr double, double* %8, i64 %495
%498 = getelementptr double, double* %8, i64 %484
%499 = getelementptr double, double* %8, i64 %478
%500 = insertelement <2 x double> poison, double %15, i64 0
%501 = shufflevector <2 x double> %500, <2 x double> poison, <2 x i32> zeroinitializer
%502 = insertelement <2 x double> poison, double %15, i64 0
%503 = shufflevector <2 x double> %502, <2 x double> poison, <2 x i32> zeroinitializer
%504 = insertelement <2 x double> poison, double %16, i64 1
%505 = insertelement <2 x double> poison, double %482, i64 0
%506 = add i64 %3, -2
%507 = lshr i64 %506, 1
%508 = add nuw i64 %507, 1
%509 = icmp eq i64 %3, 1
%510 = and i64 %3, -2
%511 = add i64 %480, %510
%512 = add i64 %510, %3
%513 = and i64 %508, 1
%514 = icmp ult i64 %506, 2
%515 = and i64 %508, -2
%516 = icmp eq i64 %513, 0
%517 = icmp eq i64 %510, %3
%518 = icmp eq i64 %3, 1
%519 = and i64 %3, -2
%520 = icmp eq i64 %519, %3
br label %540
521: ; preds = %820
br i1 %280, label %522, label %1136
522: ; preds = %521
%523 = icmp sgt i64 %3, 0
%524 = call i64 @llvm.smax.i64(i64 %20, i64 2)
%525 = getelementptr double, double* %8, i64 %3
%526 = shl i64 %3, 1
%527 = add i64 %3, -4
%528 = lshr i64 %527, 2
%529 = add nuw nsw i64 %528, 1
%530 = icmp ult i64 %3, 4
%531 = and i64 %3, -4
%532 = and i64 %529, 1
%533 = icmp ult i64 %527, 4
%534 = and i64 %529, 9223372036854775806
%535 = icmp eq i64 %532, 0
%536 = icmp eq i64 %531, %3
%537 = and i64 %3, 1
%538 = icmp eq i64 %537, 0
%539 = sub i64 0, %3
br label %848
540: ; preds = %481, %820
%541 = phi i64 [ 0, %481 ], [ %823, %820 ]
%542 = phi i64 [ 1, %481 ], [ %821, %820 ]
%543 = phi i64 [ 0, %481 ], [ %564, %820 ]
%544 = phi i64 [ %478, %481 ], [ %565, %820 ]
%545 = phi <2 x double> [ <double 1.000000e+00, double 0.000000e+00>, %481 ], [ %569, %820 ]
%546 = add i64 %543, %3
%547 = getelementptr double, double* %6, i64 %546
%548 = add i64 %495, %543
%549 = getelementptr double, double* %6, i64 %548
%550 = mul i64 %541, %3
%551 = sub i64 %484, %550
%552 = getelementptr double, double* %6, i64 %551
%553 = getelementptr double, double* %6, i64 %544
%554 = add i64 %543, %3
%555 = getelementptr double, double* %6, i64 %554
%556 = bitcast double* %555 to i8*
%557 = add i64 %488, %543
%558 = getelementptr double, double* %6, i64 %557
%559 = mul i64 %541, %3
%560 = sub i64 %484, %559
%561 = getelementptr double, double* %6, i64 %560
%562 = bitcast double* %561 to i8*
%563 = getelementptr double, double* %6, i64 %544
%564 = add nsw i64 %543, %3
%565 = sub nsw i64 %544, %3
%566 = shufflevector <2 x double> %504, <2 x double> %545, <2 x i32> <i32 3, i32 1>
%567 = shufflevector <2 x double> %505, <2 x double> %545, <2 x i32> <i32 0, i32 2>
%568 = fmul <2 x double> %566, %567
%569 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %503, <2 x double> %545, <2 x double> %568)
%570 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %501, <2 x double> %545, <2 x double> %568)
br i1 %483, label %571, label %703
571: ; preds = %540
br i1 %509, label %673, label %572
572: ; preds = %571
%573 = icmp ult double* %547, %553
%574 = icmp ult double* %552, %549
%575 = and i1 %573, %574
%576 = icmp ult double* %547, %496
%577 = icmp ugt double* %549, %8
%578 = and i1 %576, %577
%579 = or i1 %575, %578
%580 = icmp ult double* %547, %497
%581 = icmp ult double* %496, %549
%582 = and i1 %580, %581
%583 = or i1 %579, %582
%584 = icmp ult double* %547, %499
%585 = icmp ult double* %498, %549
%586 = and i1 %584, %585
%587 = or i1 %583, %586
%588 = icmp ult double* %552, %496
%589 = icmp ugt double* %553, %8
%590 = and i1 %588, %589
%591 = or i1 %587, %590
%592 = icmp ult double* %552, %497
%593 = icmp ult double* %496, %553
%594 = and i1 %592, %593
%595 = or i1 %591, %594
%596 = icmp ult double* %552, %499
%597 = icmp ult double* %498, %553
%598 = and i1 %596, %597
%599 = or i1 %595, %598
br i1 %599, label %673, label %600
600: ; preds = %572
%601 = add i64 %565, %510
%602 = add i64 %564, %510
%603 = shufflevector <2 x double> %570, <2 x double> poison, <2 x i32> zeroinitializer
%604 = shufflevector <2 x double> %570, <2 x double> undef, <2 x i32> <i32 1, i32 1>
br i1 %514, label %650, label %605
605: ; preds = %600, %605
%606 = phi i64 [ %647, %605 ], [ 0, %600 ]
%607 = phi i64 [ %648, %605 ], [ 0, %600 ]
%608 = add i64 %480, %606
%609 = add i64 %606, %3
%610 = add i64 %565, %606
%611 = add i64 %564, %606
%612 = getelementptr inbounds double, double* %8, i64 %606
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds double, double* %8, i64 %609
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %603, <2 x double> %617, <2 x double> %614)
%619 = getelementptr inbounds double, double* %6, i64 %611
%620 = bitcast double* %619 to <2 x double>*
store <2 x double> %618, <2 x double>* %620
%621 = getelementptr inbounds double, double* %8, i64 %608
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = fmul <2 x double> %604, %623
%625 = getelementptr inbounds double, double* %6, i64 %610
%626 = bitcast double* %625 to <2 x double>*
store <2 x double> %624, <2 x double>* %626
%627 = or i64 %606, 2
%628 = add i64 %480, %627
%629 = add i64 %627, %3
%630 = add i64 %565, %627
%631 = add i64 %564, %627
%632 = getelementptr inbounds double, double* %8, i64 %627
%633 = bitcast double* %632 to <2 x double>*
%634 = load <2 x double>, <2 x double>* %633
%635 = getelementptr inbounds double, double* %8, i64 %629
%636 = bitcast double* %635 to <2 x double>*
%637 = load <2 x double>, <2 x double>* %636
%638 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %603, <2 x double> %637, <2 x double> %634)
%639 = getelementptr inbounds double, double* %6, i64 %631
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %638, <2 x double>* %640
%641 = getelementptr inbounds double, double* %8, i64 %628
%642 = bitcast double* %641 to <2 x double>*
%643 = load <2 x double>, <2 x double>* %642
%644 = fmul <2 x double> %604, %643
%645 = getelementptr inbounds double, double* %6, i64 %630
%646 = bitcast double* %645 to <2 x double>*
store <2 x double> %644, <2 x double>* %646
%647 = add nuw i64 %606, 4
%648 = add nuw i64 %607, 2
%649 = icmp eq i64 %648, %515
br i1 %649, label %650, label %605
650: ; preds = %605, %600
%651 = phi i64 [ 0, %600 ], [ %647, %605 ]
br i1 %516, label %672, label %652
652: ; preds = %650
%653 = add i64 %480, %651
%654 = add i64 %651, %3
%655 = add i64 %565, %651
%656 = add i64 %564, %651
%657 = getelementptr inbounds double, double* %8, i64 %651
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %8, i64 %654
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %603, <2 x double> %662, <2 x double> %659)
%664 = getelementptr inbounds double, double* %6, i64 %656
%665 = bitcast double* %664 to <2 x double>*
store <2 x double> %663, <2 x double>* %665
%666 = getelementptr inbounds double, double* %8, i64 %653
%667 = bitcast double* %666 to <2 x double>*
%668 = load <2 x double>, <2 x double>* %667
%669 = fmul <2 x double> %604, %668
%670 = getelementptr inbounds double, double* %6, i64 %655
%671 = bitcast double* %670 to <2 x double>*
store <2 x double> %669, <2 x double>* %671
br label %672
672: ; preds = %650, %652
br i1 %517, label %703, label %673
673: ; preds = %572, %571, %672
%674 = phi i64 [ 0, %572 ], [ 0, %571 ], [ %510, %672 ]
%675 = phi i64 [ %480, %572 ], [ %480, %571 ], [ %511, %672 ]
%676 = phi i64 [ %3, %572 ], [ %3, %571 ], [ %512, %672 ]
%677 = phi i64 [ %565, %572 ], [ %565, %571 ], [ %601, %672 ]
%678 = phi i64 [ %564, %572 ], [ %564, %571 ], [ %602, %672 ]
%679 = extractelement <2 x double> %570, i64 0
%680 = extractelement <2 x double> %570, i64 1
br label %681
681: ; preds = %673, %681
%682 = phi i64 [ %687, %681 ], [ %674, %673 ]
%683 = phi i64 [ %696, %681 ], [ %675, %673 ]
%684 = phi i64 [ %690, %681 ], [ %676, %673 ]
%685 = phi i64 [ %700, %681 ], [ %677, %673 ]
%686 = phi i64 [ %694, %681 ], [ %678, %673 ]
%687 = add nuw nsw i64 %682, 1
%688 = getelementptr inbounds double, double* %8, i64 %682
%689 = load double, double* %688
%690 = add nsw i64 %684, 1
%691 = getelementptr inbounds double, double* %8, i64 %684
%692 = load double, double* %691
%693 = tail call double @llvm.fmuladd.f64(double %679, double %692, double %689)
%694 = add nsw i64 %686, 1
%695 = getelementptr inbounds double, double* %6, i64 %686
store double %693, double* %695
%696 = add nsw i64 %683, 1
%697 = getelementptr inbounds double, double* %8, i64 %683
%698 = load double, double* %697
%699 = fmul double %680, %698
%700 = add nsw i64 %685, 1
%701 = getelementptr inbounds double, double* %6, i64 %685
store double %699, double* %701
%702 = icmp eq i64 %687, %3
br i1 %702, label %703, label %681
703: ; preds = %681, %672, %540
br i1 %485, label %704, label %820
704: ; preds = %703
%705 = extractelement <2 x double> %570, i64 1
%706 = fneg double %705
%707 = insertelement <2 x double> poison, double %706, i64 0
%708 = shufflevector <2 x double> %570, <2 x double> undef, <2 x i32> zeroinitializer
%709 = icmp ult double* %555, %563
%710 = icmp ult double* %561, %558
%711 = and i1 %709, %710
%712 = add i64 %565, %519
%713 = add i64 %564, %519
br label %714
714: ; preds = %704, %816
%715 = phi i64 [ 0, %704 ], [ %819, %816 ]
%716 = phi i64 [ 2, %704 ], [ %817, %816 ]
%717 = phi i64 [ %484, %704 ], [ %733, %816 ]
%718 = phi i64 [ %3, %704 ], [ %732, %816 ]
%719 = phi <2 x double> [ %570, %704 ], [ %737, %816 ]
%720 = mul i64 %715, %3
%721 = add i64 %488, %720
%722 = getelementptr double, double* %8, i64 %721
%723 = add i64 %489, %720
%724 = getelementptr double, double* %8, i64 %723
%725 = mul i64 %715, %3
%726 = sub i64 0, %725
%727 = sub i64 %491, %725
%728 = getelementptr double, double* %8, i64 %727
%729 = getelementptr double, double* %8, i64 %726
%730 = bitcast double* %729 to i8*
%731 = getelementptr i8, i8* %730, i64 %494
%732 = add nsw i64 %718, %3
%733 = sub nsw i64 %717, %3
%734 = shufflevector <2 x double> %719, <2 x double> %570, <2 x i32> <i32 1, i32 3>
%735 = shufflevector <2 x double> %707, <2 x double> %719, <2 x i32> <i32 0, i32 2>
%736 = fmul <2 x double> %734, %735
%737 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %708, <2 x double> %719, <2 x double> %736)
br i1 %483, label %738, label %816
738: ; preds = %714
br i1 %518, label %786, label %739
739: ; preds = %738
%740 = icmp ult double* %555, %724
%741 = icmp ult double* %722, %558
%742 = and i1 %740, %741
%743 = or i1 %711, %742
%744 = icmp ugt i8* %731, %556
%745 = icmp ult double* %728, %558
%746 = and i1 %744, %745
%747 = or i1 %743, %746
%748 = icmp ult double* %561, %724
%749 = icmp ult double* %722, %563
%750 = and i1 %748, %749
%751 = or i1 %747, %750
%752 = icmp ugt i8* %731, %562
%753 = icmp ult double* %728, %563
%754 = and i1 %752, %753
%755 = or i1 %751, %754
br i1 %755, label %786, label %756
756: ; preds = %739
%757 = add i64 %733, %519
%758 = add i64 %732, %519
%759 = shufflevector <2 x double> %737, <2 x double> poison, <2 x i32> zeroinitializer
%760 = shufflevector <2 x double> %737, <2 x double> undef, <2 x i32> <i32 1, i32 1>
br label %761
761: ; preds = %761, %756
%762 = phi i64 [ 0, %756 ], [ %783, %761 ]
%763 = add i64 %733, %762
%764 = add i64 %732, %762
%765 = add i64 %565, %762
%766 = add i64 %564, %762
%767 = getelementptr inbounds double, double* %8, i64 %764
%768 = bitcast double* %767 to <2 x double>*
%769 = load <2 x double>, <2 x double>* %768
%770 = getelementptr inbounds double, double* %6, i64 %766
%771 = bitcast double* %770 to <2 x double>*
%772 = load <2 x double>, <2 x double>* %771
%773 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %759, <2 x double> %769, <2 x double> %772)
%774 = bitcast double* %770 to <2 x double>*
store <2 x double> %773, <2 x double>* %774
%775 = getelementptr inbounds double, double* %8, i64 %763
%776 = bitcast double* %775 to <2 x double>*
%777 = load <2 x double>, <2 x double>* %776
%778 = getelementptr inbounds double, double* %6, i64 %765
%779 = bitcast double* %778 to <2 x double>*
%780 = load <2 x double>, <2 x double>* %779
%781 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %760, <2 x double> %777, <2 x double> %780)
%782 = bitcast double* %778 to <2 x double>*
store <2 x double> %781, <2 x double>* %782
%783 = add nuw i64 %762, 2
%784 = icmp eq i64 %783, %519
br i1 %784, label %785, label %761
785: ; preds = %761
br i1 %520, label %816, label %786
786: ; preds = %739, %738, %785
%787 = phi i64 [ 0, %739 ], [ 0, %738 ], [ %519, %785 ]
%788 = phi i64 [ %733, %739 ], [ %733, %738 ], [ %757, %785 ]
%789 = phi i64 [ %732, %739 ], [ %732, %738 ], [ %758, %785 ]
%790 = phi i64 [ %565, %739 ], [ %565, %738 ], [ %712, %785 ]
%791 = phi i64 [ %564, %739 ], [ %564, %738 ], [ %713, %785 ]
%792 = extractelement <2 x double> %737, i64 0
%793 = extractelement <2 x double> %737, i64 1
br label %794
794: ; preds = %786, %794
%795 = phi i64 [ %814, %794 ], [ %787, %786 ]
%796 = phi i64 [ %807, %794 ], [ %788, %786 ]
%797 = phi i64 [ %800, %794 ], [ %789, %786 ]
%798 = phi i64 [ %810, %794 ], [ %790, %786 ]
%799 = phi i64 [ %803, %794 ], [ %791, %786 ]
%800 = add nsw i64 %797, 1
%801 = getelementptr inbounds double, double* %8, i64 %797
%802 = load double, double* %801
%803 = add nsw i64 %799, 1
%804 = getelementptr inbounds double, double* %6, i64 %799
%805 = load double, double* %804
%806 = tail call double @llvm.fmuladd.f64(double %792, double %802, double %805)
store double %806, double* %804
%807 = add nsw i64 %796, 1
%808 = getelementptr inbounds double, double* %8, i64 %796
%809 = load double, double* %808
%810 = add nsw i64 %798, 1
%811 = getelementptr inbounds double, double* %6, i64 %798
%812 = load double, double* %811
%813 = tail call double @llvm.fmuladd.f64(double %793, double %809, double %812)
store double %813, double* %811
%814 = add nuw nsw i64 %795, 1
%815 = icmp eq i64 %814, %3
br i1 %815, label %816, label %794
816: ; preds = %794, %785, %714
%817 = add nuw nsw i64 %716, 1
%818 = icmp eq i64 %817, %486
%819 = add i64 %715, 1
br i1 %818, label %820, label %714
820: ; preds = %816, %703
%821 = add nuw nsw i64 %542, 1
%822 = icmp eq i64 %821, %487
%823 = add i64 %541, 1
br i1 %822, label %521, label %540
824: ; preds = %959
br i1 %280, label %825, label %1136
825: ; preds = %824
%826 = icmp sgt i64 %2, 0
%827 = call i64 @llvm.smax.i64(i64 %20, i64 2)
%828 = shl i64 %2, 1
%829 = mul i64 %479, %2
%830 = mul i64 %2, %1
%831 = add i64 %2, -2
%832 = lshr i64 %831, 1
%833 = add nuw i64 %832, 1
%834 = icmp ne i64 %2, 1
%835 = icmp eq i64 %0, 1
%836 = and i1 %834, %835
%837 = and i64 %2, -2
%838 = mul i64 %837, %0
%839 = mul i64 %837, %0
%840 = and i64 %833, 1
%841 = icmp ult i64 %831, 2
%842 = and i64 %833, -2
%843 = icmp eq i64 %840, 0
%844 = icmp eq i64 %837, %2
%845 = and i64 %2, 1
%846 = icmp eq i64 %845, 0
%847 = sub i64 0, %2
br label %962
848: ; preds = %522, %959
%849 = phi i64 [ 1, %522 ], [ %960, %959 ]
%850 = phi i64 [ 0, %522 ], [ %855, %959 ]
%851 = add i64 %850, %3
%852 = getelementptr double, double* %8, i64 %851
%853 = add i64 %526, %850
%854 = getelementptr double, double* %8, i64 %853
%855 = add nsw i64 %850, %3
br i1 %523, label %856, label %959
856: ; preds = %848
br i1 %530, label %925, label %857
857: ; preds = %856
%858 = icmp ugt double* %854, %8
%859 = icmp ult double* %852, %525
%860 = and i1 %858, %859
br i1 %860, label %925, label %861
861: ; preds = %857
%862 = add i64 %855, %531
br i1 %533, label %904, label %863
863: ; preds = %861, %863
%864 = phi i64 [ %901, %863 ], [ 0, %861 ]
%865 = phi i64 [ %902, %863 ], [ 0, %861 ]
%866 = add i64 %855, %864
%867 = getelementptr inbounds double, double* %8, i64 %866
%868 = bitcast double* %867 to <2 x double>*
%869 = load <2 x double>, <2 x double>* %868
%870 = getelementptr inbounds double, double* %867, i64 2
%871 = bitcast double* %870 to <2 x double>*
%872 = load <2 x double>, <2 x double>* %871
%873 = getelementptr inbounds double, double* %8, i64 %864
%874 = bitcast double* %873 to <2 x double>*
%875 = load <2 x double>, <2 x double>* %874
%876 = getelementptr inbounds double, double* %873, i64 2
%877 = bitcast double* %876 to <2 x double>*
%878 = load <2 x double>, <2 x double>* %877
%879 = fadd <2 x double> %869, %875
%880 = fadd <2 x double> %872, %878
%881 = bitcast double* %873 to <2 x double>*
store <2 x double> %879, <2 x double>* %881
%882 = bitcast double* %876 to <2 x double>*
store <2 x double> %880, <2 x double>* %882
%883 = or i64 %864, 4
%884 = add i64 %855, %883
%885 = getelementptr inbounds double, double* %8, i64 %884
%886 = bitcast double* %885 to <2 x double>*
%887 = load <2 x double>, <2 x double>* %886
%888 = getelementptr inbounds double, double* %885, i64 2
%889 = bitcast double* %888 to <2 x double>*
%890 = load <2 x double>, <2 x double>* %889
%891 = getelementptr inbounds double, double* %8, i64 %883
%892 = bitcast double* %891 to <2 x double>*
%893 = load <2 x double>, <2 x double>* %892
%894 = getelementptr inbounds double, double* %891, i64 2
%895 = bitcast double* %894 to <2 x double>*
%896 = load <2 x double>, <2 x double>* %895
%897 = fadd <2 x double> %887, %893
%898 = fadd <2 x double> %890, %896
%899 = bitcast double* %891 to <2 x double>*
store <2 x double> %897, <2 x double>* %899
%900 = bitcast double* %894 to <2 x double>*
store <2 x double> %898, <2 x double>* %900
%901 = add nuw i64 %864, 8
%902 = add i64 %865, 2
%903 = icmp eq i64 %902, %534
br i1 %903, label %904, label %863
904: ; preds = %863, %861
%905 = phi i64 [ 0, %861 ], [ %901, %863 ]
br i1 %535, label %924, label %906
906: ; preds = %904
%907 = add i64 %855, %905
%908 = getelementptr inbounds double, double* %8, i64 %907
%909 = bitcast double* %908 to <2 x double>*
%910 = load <2 x double>, <2 x double>* %909
%911 = getelementptr inbounds double, double* %908, i64 2
%912 = bitcast double* %911 to <2 x double>*
%913 = load <2 x double>, <2 x double>* %912
%914 = getelementptr inbounds double, double* %8, i64 %905
%915 = bitcast double* %914 to <2 x double>*
%916 = load <2 x double>, <2 x double>* %915
%917 = getelementptr inbounds double, double* %914, i64 2
%918 = bitcast double* %917 to <2 x double>*
%919 = load <2 x double>, <2 x double>* %918
%920 = fadd <2 x double> %910, %916
%921 = fadd <2 x double> %913, %919
%922 = bitcast double* %914 to <2 x double>*
store <2 x double> %920, <2 x double>* %922
%923 = bitcast double* %917 to <2 x double>*
store <2 x double> %921, <2 x double>* %923
br label %924
924: ; preds = %904, %906
br i1 %536, label %959, label %925
925: ; preds = %857, %856, %924
%926 = phi i64 [ 0, %857 ], [ 0, %856 ], [ %531, %924 ]
%927 = phi i64 [ %855, %857 ], [ %855, %856 ], [ %862, %924 ]
%928 = xor i64 %926, -1
br i1 %538, label %937, label %929
929: ; preds = %925
%930 = add nsw i64 %927, 1
%931 = getelementptr inbounds double, double* %8, i64 %927
%932 = load double, double* %931
%933 = getelementptr inbounds double, double* %8, i64 %926
%934 = load double, double* %933
%935 = fadd double %932, %934
store double %935, double* %933
%936 = or i64 %926, 1
br label %937
937: ; preds = %929, %925
%938 = phi i64 [ %926, %925 ], [ %936, %929 ]
%939 = phi i64 [ %927, %925 ], [ %930, %929 ]
%940 = icmp eq i64 %928, %539
br i1 %940, label %959, label %941
941: ; preds = %937, %941
%942 = phi i64 [ %957, %941 ], [ %938, %937 ]
%943 = phi i64 [ %951, %941 ], [ %939, %937 ]
%944 = add nsw i64 %943, 1
%945 = getelementptr inbounds double, double* %8, i64 %943
%946 = load double, double* %945
%947 = getelementptr inbounds double, double* %8, i64 %942
%948 = load double, double* %947
%949 = fadd double %946, %948
store double %949, double* %947
%950 = add nuw nsw i64 %942, 1
%951 = add nsw i64 %943, 2
%952 = getelementptr inbounds double, double* %8, i64 %944
%953 = load double, double* %952
%954 = getelementptr inbounds double, double* %8, i64 %950
%955 = load double, double* %954
%956 = fadd double %953, %955
store double %956, double* %954
%957 = add nuw nsw i64 %942, 2
%958 = icmp eq i64 %957, %3
br i1 %958, label %959, label %941
959: ; preds = %937, %941, %924, %848
%960 = add nuw nsw i64 %849, 1
%961 = icmp eq i64 %960, %524
br i1 %961, label %824, label %848
962: ; preds = %825, %1132
%963 = phi i64 [ 0, %825 ], [ %1135, %1132 ]
%964 = phi i64 [ 1, %825 ], [ %1133, %1132 ]
%965 = phi i64 [ 0, %825 ], [ %981, %1132 ]
%966 = phi i64 [ %278, %825 ], [ %982, %1132 ]
%967 = mul i64 %963, %2
%968 = add i64 %967, %2
%969 = getelementptr double, double* %7, i64 %968
%970 = add i64 %828, %967
%971 = getelementptr double, double* %7, i64 %970
%972 = mul i64 %963, %2
%973 = sub i64 %829, %972
%974 = getelementptr double, double* %7, i64 %973
%975 = sub i64 %830, %972
%976 = getelementptr double, double* %7, i64 %975
%977 = getelementptr double, double* %5, i64 %968
%978 = getelementptr double, double* %5, i64 %970
%979 = getelementptr double, double* %5, i64 %973
%980 = getelementptr double, double* %5, i64 %975
%981 = add nsw i64 %965, %12
%982 = sub nsw i64 %966, %12
br i1 %826, label %983, label %1132
983: ; preds = %962
br i1 %836, label %984, label %1078
984: ; preds = %983
%985 = icmp ult double* %969, %976
%986 = icmp ult double* %974, %971
%987 = and i1 %985, %986
%988 = icmp ult double* %969, %978
%989 = icmp ult double* %977, %971
%990 = and i1 %988, %989
%991 = or i1 %987, %990
%992 = icmp ult double* %969, %980
%993 = icmp ult double* %979, %971
%994 = and i1 %992, %993
%995 = or i1 %991, %994
%996 = icmp ult double* %974, %978
%997 = icmp ult double* %977, %976
%998 = and i1 %996, %997
%999 = or i1 %995, %998
%1000 = icmp ult double* %974, %980
%1001 = icmp ult double* %979, %976
%1002 = and i1 %1000, %1001
%1003 = or i1 %999, %1002
br i1 %1003, label %1078, label %1004
1004: ; preds = %984
%1005 = add i64 %981, %838
%1006 = add i64 %982, %839
br i1 %841, label %1054, label %1007
1007: ; preds = %1004, %1007
%1008 = phi i64 [ %1051, %1007 ], [ 0, %1004 ]
%1009 = phi i64 [ %1052, %1007 ], [ 0, %1004 ]
%1010 = mul i64 %1008, %0
%1011 = add i64 %981, %1010
%1012 = mul i64 %1008, %0
%1013 = add i64 %982, %1012
%1014 = getelementptr inbounds double, double* %5, i64 %1011
%1015 = bitcast double* %1014 to <2 x double>*
%1016 = load <2 x double>, <2 x double>* %1015
%1017 = getelementptr inbounds double, double* %5, i64 %1013
%1018 = bitcast double* %1017 to <2 x double>*
%1019 = load <2 x double>, <2 x double>* %1018
%1020 = fsub <2 x double> %1016, %1019
%1021 = getelementptr inbounds double, double* %7, i64 %1011
%1022 = bitcast double* %1021 to <2 x double>*
store <2 x double> %1020, <2 x double>* %1022
%1023 = bitcast double* %1014 to <2 x double>*
%1024 = load <2 x double>, <2 x double>* %1023
%1025 = bitcast double* %1017 to <2 x double>*
%1026 = load <2 x double>, <2 x double>* %1025
%1027 = fadd <2 x double> %1024, %1026
%1028 = getelementptr inbounds double, double* %7, i64 %1013
%1029 = bitcast double* %1028 to <2 x double>*
store <2 x double> %1027, <2 x double>* %1029
%1030 = or i64 %1008, 2
%1031 = mul i64 %1030, %0
%1032 = add i64 %981, %1031
%1033 = mul i64 %1030, %0
%1034 = add i64 %982, %1033
%1035 = getelementptr inbounds double, double* %5, i64 %1032
%1036 = bitcast double* %1035 to <2 x double>*
%1037 = load <2 x double>, <2 x double>* %1036
%1038 = getelementptr inbounds double, double* %5, i64 %1034
%1039 = bitcast double* %1038 to <2 x double>*
%1040 = load <2 x double>, <2 x double>* %1039
%1041 = fsub <2 x double> %1037, %1040
%1042 = getelementptr inbounds double, double* %7, i64 %1032
%1043 = bitcast double* %1042 to <2 x double>*
store <2 x double> %1041, <2 x double>* %1043
%1044 = bitcast double* %1035 to <2 x double>*
%1045 = load <2 x double>, <2 x double>* %1044
%1046 = bitcast double* %1038 to <2 x double>*
%1047 = load <2 x double>, <2 x double>* %1046
%1048 = fadd <2 x double> %1045, %1047
%1049 = getelementptr inbounds double, double* %7, i64 %1034
%1050 = bitcast double* %1049 to <2 x double>*
store <2 x double> %1048, <2 x double>* %1050
%1051 = add nuw i64 %1008, 4
%1052 = add nuw i64 %1009, 2
%1053 = icmp eq i64 %1052, %842
br i1 %1053, label %1054, label %1007
1054: ; preds = %1007, %1004
%1055 = phi i64 [ 0, %1004 ], [ %1051, %1007 ]
br i1 %843, label %1077, label %1056
1056: ; preds = %1054
%1057 = mul i64 %1055, %0
%1058 = add i64 %981, %1057
%1059 = mul i64 %1055, %0
%1060 = add i64 %982, %1059
%1061 = getelementptr inbounds double, double* %5, i64 %1058
%1062 = bitcast double* %1061 to <2 x double>*
%1063 = load <2 x double>, <2 x double>* %1062
%1064 = getelementptr inbounds double, double* %5, i64 %1060
%1065 = bitcast double* %1064 to <2 x double>*
%1066 = load <2 x double>, <2 x double>* %1065
%1067 = fsub <2 x double> %1063, %1066
%1068 = getelementptr inbounds double, double* %7, i64 %1058
%1069 = bitcast double* %1068 to <2 x double>*
store <2 x double> %1067, <2 x double>* %1069
%1070 = bitcast double* %1061 to <2 x double>*
%1071 = load <2 x double>, <2 x double>* %1070
%1072 = bitcast double* %1064 to <2 x double>*
%1073 = load <2 x double>, <2 x double>* %1072
%1074 = fadd <2 x double> %1071, %1073
%1075 = getelementptr inbounds double, double* %7, i64 %1060
%1076 = bitcast double* %1075 to <2 x double>*
store <2 x double> %1074, <2 x double>* %1076
br label %1077
1077: ; preds = %1054, %1056
br i1 %844, label %1132, label %1078
1078: ; preds = %984, %983, %1077
%1079 = phi i64 [ 0, %984 ], [ 0, %983 ], [ %837, %1077 ]
%1080 = phi i64 [ %981, %984 ], [ %981, %983 ], [ %1005, %1077 ]
%1081 = phi i64 [ %982, %984 ], [ %982, %983 ], [ %1006, %1077 ]
%1082 = xor i64 %1079, -1
br i1 %846, label %1097, label %1083
1083: ; preds = %1078
%1084 = getelementptr inbounds double, double* %5, i64 %1080
%1085 = load double, double* %1084
%1086 = getelementptr inbounds double, double* %5, i64 %1081
%1087 = load double, double* %1086
%1088 = fsub double %1085, %1087
%1089 = getelementptr inbounds double, double* %7, i64 %1080
store double %1088, double* %1089
%1090 = load double, double* %1084
%1091 = load double, double* %1086
%1092 = fadd double %1090, %1091
%1093 = getelementptr inbounds double, double* %7, i64 %1081
store double %1092, double* %1093
%1094 = add nsw i64 %1080, %0
%1095 = add nsw i64 %1081, %0
%1096 = or i64 %1079, 1
br label %1097
1097: ; preds = %1083, %1078
%1098 = phi i64 [ %1079, %1078 ], [ %1096, %1083 ]
%1099 = phi i64 [ %1080, %1078 ], [ %1094, %1083 ]
%1100 = phi i64 [ %1081, %1078 ], [ %1095, %1083 ]
%1101 = icmp eq i64 %1082, %847
br i1 %1101, label %1132, label %1102
1102: ; preds = %1097, %1102
%1103 = phi i64 [ %1130, %1102 ], [ %1098, %1097 ]
%1104 = phi i64 [ %1128, %1102 ], [ %1099, %1097 ]
%1105 = phi i64 [ %1129, %1102 ], [ %1100, %1097 ]
%1106 = getelementptr inbounds double, double* %5, i64 %1104
%1107 = load double, double* %1106
%1108 = getelementptr inbounds double, double* %5, i64 %1105
%1109 = load double, double* %1108
%1110 = fsub double %1107, %1109
%1111 = getelementptr inbounds double, double* %7, i64 %1104
store double %1110, double* %1111
%1112 = load double, double* %1106
%1113 = load double, double* %1108
%1114 = fadd double %1112, %1113
%1115 = getelementptr inbounds double, double* %7, i64 %1105
store double %1114, double* %1115
%1116 = add nsw i64 %1104, %0
%1117 = add nsw i64 %1105, %0
%1118 = getelementptr inbounds double, double* %5, i64 %1116
%1119 = load double, double* %1118
%1120 = getelementptr inbounds double, double* %5, i64 %1117
%1121 = load double, double* %1120
%1122 = fsub double %1119, %1121
%1123 = getelementptr inbounds double, double* %7, i64 %1116
store double %1122, double* %1123
%1124 = load double, double* %1118
%1125 = load double, double* %1120
%1126 = fadd double %1124, %1125
%1127 = getelementptr inbounds double, double* %7, i64 %1117
store double %1126, double* %1127
%1128 = add nsw i64 %1116, %0
%1129 = add nsw i64 %1117, %0
%1130 = add nuw nsw i64 %1103, 2
%1131 = icmp eq i64 %1130, %2
br i1 %1131, label %1132, label %1102
1132: ; preds = %1097, %1102, %1077, %962
%1133 = add nuw nsw i64 %964, 1
%1134 = icmp eq i64 %1133, %827
%1135 = add i64 %963, 1
br i1 %1134, label %1136, label %962
1136: ; preds = %1132, %477, %521, %824
br i1 %346, label %1693, label %1137
1137: ; preds = %1136
%1138 = icmp slt i64 %18, %2
br i1 %1138, label %1144, label %1139
1139: ; preds = %1137
br i1 %280, label %1140, label %1245
1140: ; preds = %1139
%1141 = icmp sgt i64 %2, 0
%1142 = icmp sgt i64 %0, 2
%1143 = call i64 @llvm.smax.i64(i64 %20, i64 2)
br label %1149
1144: ; preds = %1137
br i1 %280, label %1145, label %1245
1145: ; preds = %1144
%1146 = icmp sgt i64 %0, 2
%1147 = icmp sgt i64 %2, 0
%1148 = call i64 @llvm.smax.i64(i64 %20, i64 2)
br label %1197
1149: ; preds = %1140, %1194
%1150 = phi i64 [ 1, %1140 ], [ %1195, %1194 ]
%1151 = phi i64 [ 0, %1140 ], [ %1153, %1194 ]
%1152 = phi i64 [ %278, %1140 ], [ %1154, %1194 ]
%1153 = add nsw i64 %1151, %12
%1154 = sub nsw i64 %1152, %12
br i1 %1141, label %1155, label %1194
1155: ; preds = %1149, %1189
%1156 = phi i64 [ %1192, %1189 ], [ 0, %1149 ]
%1157 = phi i64 [ %1190, %1189 ], [ %1153, %1149 ]
%1158 = phi i64 [ %1191, %1189 ], [ %1154, %1149 ]
br i1 %1142, label %1159, label %1189
1159: ; preds = %1155, %1159
%1160 = phi i64 [ %1187, %1159 ], [ 2, %1155 ]
%1161 = phi i64 [ %1164, %1159 ], [ %1158, %1155 ]
%1162 = phi i64 [ %1163, %1159 ], [ %1157, %1155 ]
%1163 = add nsw i64 %1162, 2
%1164 = add nsw i64 %1161, 2
%1165 = add nsw i64 %1162, 1
%1166 = getelementptr inbounds double, double* %5, i64 %1165
%1167 = load double, double* %1166
%1168 = getelementptr inbounds double, double* %5, i64 %1164
%1169 = load double, double* %1168
%1170 = fsub double %1167, %1169
%1171 = getelementptr inbounds double, double* %7, i64 %1165
store double %1170, double* %1171
%1172 = load double, double* %1166
%1173 = load double, double* %1168
%1174 = fadd double %1172, %1173
%1175 = add nsw i64 %1161, 1
%1176 = getelementptr inbounds double, double* %7, i64 %1175
store double %1174, double* %1176
%1177 = getelementptr inbounds double, double* %5, i64 %1163
%1178 = load double, double* %1177
%1179 = getelementptr inbounds double, double* %5, i64 %1175
%1180 = load double, double* %1179
%1181 = fadd double %1178, %1180
%1182 = getelementptr inbounds double, double* %7, i64 %1163
store double %1181, double* %1182
%1183 = load double, double* %1177
%1184 = load double, double* %1179
%1185 = fsub double %1183, %1184
%1186 = getelementptr inbounds double, double* %7, i64 %1164
store double %1185, double* %1186
%1187 = add nuw nsw i64 %1160, 2
%1188 = icmp slt i64 %1187, %0
br i1 %1188, label %1159, label %1189
1189: ; preds = %1159, %1155
%1190 = add nsw i64 %1157, %0
%1191 = add nsw i64 %1158, %0
%1192 = add nuw nsw i64 %1156, 1
%1193 = icmp eq i64 %1192, %2
br i1 %1193, label %1194, label %1155
1194: ; preds = %1189, %1149
%1195 = add nuw nsw i64 %1150, 1
%1196 = icmp eq i64 %1195, %1143
br i1 %1196, label %1245, label %1149
1197: ; preds = %1145, %1242
%1198 = phi i64 [ 1, %1145 ], [ %1243, %1242 ]
%1199 = phi i64 [ 0, %1145 ], [ %1201, %1242 ]
%1200 = phi i64 [ %278, %1145 ], [ %1202, %1242 ]
%1201 = add nsw i64 %1199, %12
%1202 = sub nsw i64 %1200, %12
br i1 %1146, label %1203, label %1242
1203: ; preds = %1197, %1239
%1204 = phi i64 [ %1240, %1239 ], [ 2, %1197 ]
%1205 = phi i64 [ %1207, %1239 ], [ %1201, %1197 ]
%1206 = phi i64 [ %1208, %1239 ], [ %1202, %1197 ]
%1207 = add nsw i64 %1205, 2
%1208 = add nsw i64 %1206, 2
br i1 %1147, label %1209, label %1239
1209: ; preds = %1203, %1209
%1210 = phi i64 [ %1237, %1209 ], [ 0, %1203 ]
%1211 = phi i64 [ %1236, %1209 ], [ %1208, %1203 ]
%1212 = phi i64 [ %1235, %1209 ], [ %1207, %1203 ]
%1213 = add nsw i64 %1212, -1
%1214 = getelementptr inbounds double, double* %5, i64 %1213
%1215 = load double, double* %1214
%1216 = getelementptr inbounds double, double* %5, i64 %1211
%1217 = load double, double* %1216
%1218 = fsub double %1215, %1217
%1219 = getelementptr inbounds double, double* %7, i64 %1213
store double %1218, double* %1219
%1220 = load double, double* %1214
%1221 = load double, double* %1216
%1222 = fadd double %1220, %1221
%1223 = add nsw i64 %1211, -1
%1224 = getelementptr inbounds double, double* %7, i64 %1223
store double %1222, double* %1224
%1225 = getelementptr inbounds double, double* %5, i64 %1212
%1226 = load double, double* %1225
%1227 = getelementptr inbounds double, double* %5, i64 %1223
%1228 = load double, double* %1227
%1229 = fadd double %1226, %1228
%1230 = getelementptr inbounds double, double* %7, i64 %1212
store double %1229, double* %1230
%1231 = load double, double* %1225
%1232 = load double, double* %1227
%1233 = fsub double %1231, %1232
%1234 = getelementptr inbounds double, double* %7, i64 %1211
store double %1233, double* %1234
%1235 = add nsw i64 %1212, %0
%1236 = add nsw i64 %1211, %0
%1237 = add nuw nsw i64 %1210, 1
%1238 = icmp eq i64 %1237, %2
br i1 %1238, label %1239, label %1209
1239: ; preds = %1209, %1203
%1240 = add nuw nsw i64 %1204, 2
%1241 = icmp slt i64 %1240, %0
br i1 %1241, label %1203, label %1242
1242: ; preds = %1239, %1197
%1243 = add nuw nsw i64 %1198, 1
%1244 = icmp eq i64 %1243, %1148
br i1 %1244, label %1245, label %1197
1245: ; preds = %1194, %1242, %354, %349, %1139, %1144
%1246 = icmp sgt i64 %3, 0
br i1 %1246, label %1247, label %1352
1247: ; preds = %1245
%1248 = icmp ult i64 %3, 4
br i1 %1248, label %1334, label %1249
1249: ; preds = %1247
%1250 = getelementptr double, double* %6, i64 %3
%1251 = getelementptr double, double* %8, i64 %3
%1252 = icmp ugt double* %1251, %6
%1253 = icmp ugt double* %1250, %8
%1254 = and i1 %1252, %1253
br i1 %1254, label %1334, label %1255
1255: ; preds = %1249
%1256 = and i64 %3, -4
%1257 = add i64 %1256, -4
%1258 = lshr exact i64 %1257, 2
%1259 = add nuw nsw i64 %1258, 1
%1260 = and i64 %1259, 3
%1261 = icmp ult i64 %1257, 12
br i1 %1261, label %1313, label %1262
1262: ; preds = %1255
%1263 = and i64 %1259, 9223372036854775804
br label %1264
1264: ; preds = %1264, %1262
%1265 = phi i64 [ 0, %1262 ], [ %1310, %1264 ]
%1266 = phi i64 [ 0, %1262 ], [ %1311, %1264 ]
%1267 = getelementptr inbounds double, double* %8, i64 %1265
%1268 = bitcast double* %1267 to <2 x double>*
%1269 = load <2 x double>, <2 x double>* %1268
%1270 = getelementptr inbounds double, double* %1267, i64 2
%1271 = bitcast double* %1270 to <2 x double>*
%1272 = load <2 x double>, <2 x double>* %1271
%1273 = getelementptr inbounds double, double* %6, i64 %1265
%1274 = bitcast double* %1273 to <2 x double>*
store <2 x double> %1269, <2 x double>* %1274
%1275 = getelementptr inbounds double, double* %1273, i64 2
%1276 = bitcast double* %1275 to <2 x double>*
store <2 x double> %1272, <2 x double>* %1276
%1277 = or i64 %1265, 4
%1278 = getelementptr inbounds double, double* %8, i64 %1277
%1279 = bitcast double* %1278 to <2 x double>*
%1280 = load <2 x double>, <2 x double>* %1279
%1281 = getelementptr inbounds double, double* %1278, i64 2
%1282 = bitcast double* %1281 to <2 x double>*
%1283 = load <2 x double>, <2 x double>* %1282
%1284 = getelementptr inbounds double, double* %6, i64 %1277
%1285 = bitcast double* %1284 to <2 x double>*
store <2 x double> %1280, <2 x double>* %1285
%1286 = getelementptr inbounds double, double* %1284, i64 2
%1287 = bitcast double* %1286 to <2 x double>*
store <2 x double> %1283, <2 x double>* %1287
%1288 = or i64 %1265, 8
%1289 = getelementptr inbounds double, double* %8, i64 %1288
%1290 = bitcast double* %1289 to <2 x double>*
%1291 = load <2 x double>, <2 x double>* %1290
%1292 = getelementptr inbounds double, double* %1289, i64 2
%1293 = bitcast double* %1292 to <2 x double>*
%1294 = load <2 x double>, <2 x double>* %1293
%1295 = getelementptr inbounds double, double* %6, i64 %1288
%1296 = bitcast double* %1295 to <2 x double>*
store <2 x double> %1291, <2 x double>* %1296
%1297 = getelementptr inbounds double, double* %1295, i64 2
%1298 = bitcast double* %1297 to <2 x double>*
store <2 x double> %1294, <2 x double>* %1298
%1299 = or i64 %1265, 12
%1300 = getelementptr inbounds double, double* %8, i64 %1299
%1301 = bitcast double* %1300 to <2 x double>*
%1302 = load <2 x double>, <2 x double>* %1301
%1303 = getelementptr inbounds double, double* %1300, i64 2
%1304 = bitcast double* %1303 to <2 x double>*
%1305 = load <2 x double>, <2 x double>* %1304
%1306 = getelementptr inbounds double, double* %6, i64 %1299
%1307 = bitcast double* %1306 to <2 x double>*
store <2 x double> %1302, <2 x double>* %1307
%1308 = getelementptr inbounds double, double* %1306, i64 2
%1309 = bitcast double* %1308 to <2 x double>*
store <2 x double> %1305, <2 x double>* %1309
%1310 = add nuw i64 %1265, 16
%1311 = add nuw i64 %1266, 4
%1312 = icmp eq i64 %1311, %1263
br i1 %1312, label %1313, label %1264
1313: ; preds = %1264, %1255
%1314 = phi i64 [ 0, %1255 ], [ %1310, %1264 ]
%1315 = icmp eq i64 %1260, 0
br i1 %1315, label %1332, label %1316
1316: ; preds = %1313, %1316
%1317 = phi i64 [ %1329, %1316 ], [ %1314, %1313 ]
%1318 = phi i64 [ %1330, %1316 ], [ 0, %1313 ]
%1319 = getelementptr inbounds double, double* %8, i64 %1317
%1320 = bitcast double* %1319 to <2 x double>*
%1321 = load <2 x double>, <2 x double>* %1320
%1322 = getelementptr inbounds double, double* %1319, i64 2
%1323 = bitcast double* %1322 to <2 x double>*
%1324 = load <2 x double>, <2 x double>* %1323
%1325 = getelementptr inbounds double, double* %6, i64 %1317
%1326 = bitcast double* %1325 to <2 x double>*
store <2 x double> %1321, <2 x double>* %1326
%1327 = getelementptr inbounds double, double* %1325, i64 2
%1328 = bitcast double* %1327 to <2 x double>*
store <2 x double> %1324, <2 x double>* %1328
%1329 = add nuw i64 %1317, 4
%1330 = add i64 %1318, 1
%1331 = icmp eq i64 %1330, %1260
br i1 %1331, label %1332, label %1316
1332: ; preds = %1316, %1313
%1333 = icmp eq i64 %1256, %3
br i1 %1333, label %1352, label %1334
1334: ; preds = %1249, %1247, %1332
%1335 = phi i64 [ 0, %1249 ], [ 0, %1247 ], [ %1256, %1332 ]
%1336 = xor i64 %1335, -1
%1337 = add i64 %1336, %3
%1338 = and i64 %3, 3
%1339 = icmp eq i64 %1338, 0
br i1 %1339, label %1349, label %1340
1340: ; preds = %1334, %1340
%1341 = phi i64 [ %1346, %1340 ], [ %1335, %1334 ]
%1342 = phi i64 [ %1347, %1340 ], [ 0, %1334 ]
%1343 = getelementptr inbounds double, double* %8, i64 %1341
%1344 = load double, double* %1343
%1345 = getelementptr inbounds double, double* %6, i64 %1341
store double %1344, double* %1345
%1346 = add nuw nsw i64 %1341, 1
%1347 = add i64 %1342, 1
%1348 = icmp eq i64 %1347, %1338
br i1 %1348, label %1349, label %1340
1349: ; preds = %1340, %1334
%1350 = phi i64 [ %1335, %1334 ], [ %1346, %1340 ]
%1351 = icmp ult i64 %1337, 3
br i1 %1351, label %1352, label %1372
1352: ; preds = %1349, %1372, %1332, %1245
%1353 = icmp sgt i64 %1, 1
br i1 %1353, label %1354, label %1693
1354: ; preds = %1352
%1355 = icmp sgt i64 %2, 0
%1356 = shl i64 %2, 1
%1357 = add i64 %2, -4
%1358 = lshr i64 %1357, 2
%1359 = add nuw nsw i64 %1358, 1
%1360 = icmp ugt i64 %2, 3
%1361 = icmp eq i64 %0, 1
%1362 = and i1 %1360, %1361
%1363 = and i64 %2, -4
%1364 = mul i64 %1363, %0
%1365 = and i64 %1359, 1
%1366 = icmp ult i64 %1357, 4
%1367 = and i64 %1359, 9223372036854775806
%1368 = icmp eq i64 %1365, 0
%1369 = icmp eq i64 %1363, %2
%1370 = and i64 %2, 3
%1371 = icmp eq i64 %1370, 0
br label %1391
1372: ; preds = %1349, %1372
%1373 = phi i64 [ %1389, %1372 ], [ %1350, %1349 ]
%1374 = getelementptr inbounds double, double* %8, i64 %1373
%1375 = load double, double* %1374
%1376 = getelementptr inbounds double, double* %6, i64 %1373
store double %1375, double* %1376
%1377 = add nuw nsw i64 %1373, 1
%1378 = getelementptr inbounds double, double* %8, i64 %1377
%1379 = load double, double* %1378
%1380 = getelementptr inbounds double, double* %6, i64 %1377
store double %1379, double* %1380
%1381 = add nuw nsw i64 %1373, 2
%1382 = getelementptr inbounds double, double* %8, i64 %1381
%1383 = load double, double* %1382
%1384 = getelementptr inbounds double, double* %6, i64 %1381
store double %1383, double* %1384
%1385 = add nuw nsw i64 %1373, 3
%1386 = getelementptr inbounds double, double* %8, i64 %1385
%1387 = load double, double* %1386
%1388 = getelementptr inbounds double, double* %6, i64 %1385
store double %1387, double* %1388
%1389 = add nuw nsw i64 %1373, 4
%1390 = icmp eq i64 %1389, %3
br i1 %1390, label %1352, label %1372
1391: ; preds = %1354, %1498
%1392 = phi i64 [ 0, %1354 ], [ %1501, %1498 ]
%1393 = phi i64 [ 1, %1354 ], [ %1499, %1498 ]
%1394 = phi i64 [ 0, %1354 ], [ %1402, %1498 ]
%1395 = mul i64 %1392, %2
%1396 = add i64 %1395, %2
%1397 = getelementptr double, double* %5, i64 %1396
%1398 = add i64 %1356, %1395
%1399 = getelementptr double, double* %5, i64 %1398
%1400 = getelementptr double, double* %7, i64 %1396
%1401 = getelementptr double, double* %7, i64 %1398
%1402 = add nsw i64 %1394, %12
br i1 %1355, label %1403, label %1498
1403: ; preds = %1391
br i1 %1362, label %1404, label %1457
1404: ; preds = %1403
%1405 = icmp ult double* %1397, %1401
%1406 = icmp ult double* %1400, %1399
%1407 = and i1 %1405, %1406
br i1 %1407, label %1457, label %1408
1408: ; preds = %1404
%1409 = add i64 %1402, %1364
br i1 %1366, label %1441, label %1410
1410: ; preds = %1408, %1410
%1411 = phi i64 [ %1438, %1410 ], [ 0, %1408 ]
%1412 = phi i64 [ %1439, %1410 ], [ 0, %1408 ]
%1413 = mul i64 %1411, %0
%1414 = add i64 %1402, %1413
%1415 = getelementptr inbounds double, double* %7, i64 %1414
%1416 = bitcast double* %1415 to <2 x double>*
%1417 = load <2 x double>, <2 x double>* %1416
%1418 = getelementptr inbounds double, double* %1415, i64 2
%1419 = bitcast double* %1418 to <2 x double>*
%1420 = load <2 x double>, <2 x double>* %1419
%1421 = getelementptr inbounds double, double* %5, i64 %1414
%1422 = bitcast double* %1421 to <2 x double>*
store <2 x double> %1417, <2 x double>* %1422
%1423 = getelementptr inbounds double, double* %1421, i64 2
%1424 = bitcast double* %1423 to <2 x double>*
store <2 x double> %1420, <2 x double>* %1424
%1425 = or i64 %1411, 4
%1426 = mul i64 %1425, %0
%1427 = add i64 %1402, %1426
%1428 = getelementptr inbounds double, double* %7, i64 %1427
%1429 = bitcast double* %1428 to <2 x double>*
%1430 = load <2 x double>, <2 x double>* %1429
%1431 = getelementptr inbounds double, double* %1428, i64 2
%1432 = bitcast double* %1431 to <2 x double>*
%1433 = load <2 x double>, <2 x double>* %1432
%1434 = getelementptr inbounds double, double* %5, i64 %1427
%1435 = bitcast double* %1434 to <2 x double>*
store <2 x double> %1430, <2 x double>* %1435
%1436 = getelementptr inbounds double, double* %1434, i64 2
%1437 = bitcast double* %1436 to <2 x double>*
store <2 x double> %1433, <2 x double>* %1437
%1438 = add nuw i64 %1411, 8
%1439 = add i64 %1412, 2
%1440 = icmp eq i64 %1439, %1367
br i1 %1440, label %1441, label %1410
1441: ; preds = %1410, %1408
%1442 = phi i64 [ 0, %1408 ], [ %1438, %1410 ]
br i1 %1368, label %1456, label %1443
1443: ; preds = %1441
%1444 = mul i64 %1442, %0
%1445 = add i64 %1402, %1444
%1446 = getelementptr inbounds double, double* %7, i64 %1445
%1447 = bitcast double* %1446 to <2 x double>*
%1448 = load <2 x double>, <2 x double>* %1447
%1449 = getelementptr inbounds double, double* %1446, i64 2
%1450 = bitcast double* %1449 to <2 x double>*
%1451 = load <2 x double>, <2 x double>* %1450
%1452 = getelementptr inbounds double, double* %5, i64 %1445
%1453 = bitcast double* %1452 to <2 x double>*
store <2 x double> %1448, <2 x double>* %1453
%1454 = getelementptr inbounds double, double* %1452, i64 2
%1455 = bitcast double* %1454 to <2 x double>*
store <2 x double> %1451, <2 x double>* %1455
br label %1456
1456: ; preds = %1441, %1443
br i1 %1369, label %1498, label %1457
1457: ; preds = %1404, %1403, %1456
%1458 = phi i64 [ 0, %1404 ], [ 0, %1403 ], [ %1363, %1456 ]
%1459 = phi i64 [ %1402, %1404 ], [ %1402, %1403 ], [ %1409, %1456 ]
%1460 = xor i64 %1458, -1
%1461 = add i64 %1460, %2
br i1 %1371, label %1473, label %1462
1462: ; preds = %1457, %1462
%1463 = phi i64 [ %1470, %1462 ], [ %1458, %1457 ]
%1464 = phi i64 [ %1469, %1462 ], [ %1459, %1457 ]
%1465 = phi i64 [ %1471, %1462 ], [ 0, %1457 ]
%1466 = getelementptr inbounds double, double* %7, i64 %1464
%1467 = load double, double* %1466
%1468 = getelementptr inbounds double, double* %5, i64 %1464
store double %1467, double* %1468
%1469 = add nsw i64 %1464, %0
%1470 = add nuw nsw i64 %1463, 1
%1471 = add i64 %1465, 1
%1472 = icmp eq i64 %1471, %1370
br i1 %1472, label %1473, label %1462
1473: ; preds = %1462, %1457
%1474 = phi i64 [ %1458, %1457 ], [ %1470, %1462 ]
%1475 = phi i64 [ %1459, %1457 ], [ %1469, %1462 ]
%1476 = icmp ult i64 %1461, 3
br i1 %1476, label %1498, label %1477
1477: ; preds = %1473, %1477
%1478 = phi i64 [ %1496, %1477 ], [ %1474, %1473 ]
%1479 = phi i64 [ %1495, %1477 ], [ %1475, %1473 ]
%1480 = getelementptr inbounds double, double* %7, i64 %1479
%1481 = load double, double* %1480
%1482 = getelementptr inbounds double, double* %5, i64 %1479
store double %1481, double* %1482
%1483 = add nsw i64 %1479, %0
%1484 = getelementptr inbounds double, double* %7, i64 %1483
%1485 = load double, double* %1484
%1486 = getelementptr inbounds double, double* %5, i64 %1483
store double %1485, double* %1486
%1487 = add nsw i64 %1483, %0
%1488 = getelementptr inbounds double, double* %7, i64 %1487
%1489 = load double, double* %1488
%1490 = getelementptr inbounds double, double* %5, i64 %1487
store double %1489, double* %1490
%1491 = add nsw i64 %1487, %0
%1492 = getelementptr inbounds double, double* %7, i64 %1491
%1493 = load double, double* %1492
%1494 = getelementptr inbounds double, double* %5, i64 %1491
store double %1493, double* %1494
%1495 = add nsw i64 %1491, %0
%1496 = add nuw nsw i64 %1478, 4
%1497 = icmp eq i64 %1496, %2
br i1 %1497, label %1498, label %1477
1498: ; preds = %1473, %1477, %1456, %1391
%1499 = add nuw nsw i64 %1393, 1
%1500 = icmp eq i64 %1499, %1
%1501 = add i64 %1392, 1
br i1 %1500, label %1502, label %1391
1502: ; preds = %1498
%1503 = icmp sgt i64 %18, %2
br i1 %1503, label %1555, label %1504
1504: ; preds = %1502
br i1 %1353, label %1505, label %1693
1505: ; preds = %1504
%1506 = xor i64 %0, -1
%1507 = icmp sgt i64 %0, 2
%1508 = icmp sgt i64 %2, 0
br label %1509
1509: ; preds = %1505, %1552
%1510 = phi i64 [ 1, %1505 ], [ %1553, %1552 ]
%1511 = phi i64 [ %1506, %1505 ], [ %1513, %1552 ]
%1512 = phi i64 [ 0, %1505 ], [ %1514, %1552 ]
%1513 = add nsw i64 %1511, %0
%1514 = add nsw i64 %1512, %12
br i1 %1507, label %1515, label %1552
1515: ; preds = %1509, %1549
%1516 = phi i64 [ %1520, %1549 ], [ %1513, %1509 ]
%1517 = phi i64 [ %1550, %1549 ], [ 2, %1509 ]
%1518 = phi i64 [ %1519, %1549 ], [ %1514, %1509 ]
%1519 = add nsw i64 %1518, 2
%1520 = add nsw i64 %1516, 2
br i1 %1508, label %1521, label %1549
1521: ; preds = %1515
%1522 = add nsw i64 %1516, 1
%1523 = getelementptr inbounds double, double* %9, i64 %1522
%1524 = getelementptr inbounds double, double* %9, i64 %1520
br label %1525
1525: ; preds = %1521, %1525
%1526 = phi i64 [ 0, %1521 ], [ %1547, %1525 ]
%1527 = phi i64 [ %1519, %1521 ], [ %1546, %1525 ]
%1528 = load double, double* %1523
%1529 = add nsw i64 %1527, -1
%1530 = getelementptr inbounds double, double* %7, i64 %1529
%1531 = load double, double* %1530
%1532 = load double, double* %1524
%1533 = getelementptr inbounds double, double* %7, i64 %1527
%1534 = load double, double* %1533
%1535 = fneg double %1532
%1536 = fmul double %1534, %1535
%1537 = tail call double @llvm.fmuladd.f64(double %1528, double %1531, double %1536)
%1538 = getelementptr inbounds double, double* %5, i64 %1529
store double %1537, double* %1538
%1539 = load double, double* %1523
%1540 = load double, double* %1533
%1541 = load double, double* %1524
%1542 = load double, double* %1530
%1543 = fmul double %1541, %1542
%1544 = tail call double @llvm.fmuladd.f64(double %1539, double %1540, double %1543)
%1545 = getelementptr inbounds double, double* %5, i64 %1527
store double %1544, double* %1545
%1546 = add nsw i64 %1527, %0
%1547 = add nuw nsw i64 %1526, 1
%1548 = icmp eq i64 %1547, %2
br i1 %1548, label %1549, label %1525
1549: ; preds = %1525, %1515
%1550 = add nuw nsw i64 %1517, 2
%1551 = icmp slt i64 %1550, %0
br i1 %1551, label %1515, label %1552
1552: ; preds = %1549, %1509
%1553 = add nuw nsw i64 %1510, 1
%1554 = icmp eq i64 %1553, %1
br i1 %1554, label %1693, label %1509
1555: ; preds = %1502
br i1 %1353, label %1556, label %1693
1556: ; preds = %1555
%1557 = xor i64 %0, -1
%1558 = icmp sgt i64 %2, 0
%1559 = icmp sgt i64 %0, 2
%1560 = add i64 %12, 1
%1561 = add i64 %0, -3
%1562 = lshr i64 %1561, 1
%1563 = and i64 %1561, -2
%1564 = add i64 %12, %1563
%1565 = add i64 %1564, 3
%1566 = add i64 %1563, 2
%1567 = add nuw i64 %1562, 1
%1568 = icmp ult i64 %1561, 2
%1569 = and i64 %1567, -2
%1570 = shl i64 %1569, 1
%1571 = shl i64 %1567, 1
%1572 = or i64 %1571, 2
%1573 = shl i64 %1569, 1
%1574 = getelementptr inbounds double, double* %7, i64 -1
%1575 = getelementptr inbounds double, double* %5, i64 -1
%1576 = icmp eq i64 %1567, %1569
br label %1577
1577: ; preds = %1556, %1689
%1578 = phi i64 [ 0, %1556 ], [ %1692, %1689 ]
%1579 = phi i64 [ 1, %1556 ], [ %1690, %1689 ]
%1580 = phi i64 [ %1557, %1556 ], [ %1588, %1689 ]
%1581 = phi i64 [ 0, %1556 ], [ %1589, %1689 ]
%1582 = add i64 %1560, %1581
%1583 = add i64 %1565, %1581
%1584 = mul i64 %1578, %0
%1585 = getelementptr double, double* %9, i64 %1584
%1586 = add i64 %1566, %1584
%1587 = getelementptr double, double* %9, i64 %1586
%1588 = add nsw i64 %1580, %0
%1589 = add nsw i64 %1581, %12
br i1 %1558, label %1590, label %1689
1590: ; preds = %1577
%1591 = add i64 %1588, %1570
br label %1592
1592: ; preds = %1590, %1685
%1593 = phi i64 [ %1687, %1685 ], [ 0, %1590 ]
%1594 = phi i64 [ %1686, %1685 ], [ %1589, %1590 ]
%1595 = mul i64 %1593, %0
%1596 = add i64 %1582, %1595
%1597 = getelementptr double, double* %5, i64 %1596
%1598 = add i64 %1583, %1595
%1599 = getelementptr double, double* %5, i64 %1598
%1600 = getelementptr double, double* %7, i64 %1596
%1601 = getelementptr double, double* %7, i64 %1598
br i1 %1559, label %1602, label %1685
1602: ; preds = %1592
br i1 %1568, label %1652, label %1603
1603: ; preds = %1602
%1604 = icmp ult double* %1597, %1587
%1605 = icmp ult double* %1585, %1599
%1606 = and i1 %1604, %1605
%1607 = icmp ult double* %1597, %1601
%1608 = icmp ult double* %1600, %1599
%1609 = and i1 %1607, %1608
%1610 = or i1 %1606, %1609
br i1 %1610, label %1652, label %1611
1611: ; preds = %1603
%1612 = add i64 %1594, %1573
br label %1613
1613: ; preds = %1613, %1611
%1614 = phi i64 [ 0, %1611 ], [ %1649, %1613 ]
%1615 = shl i64 %1614, 1
%1616 = add i64 %1588, %1615
%1617 = shl i64 %1614, 1
%1618 = add i64 %1594, %1617
%1619 = add nsw i64 %1618, 2
%1620 = add nsw i64 %1616, 1
%1621 = getelementptr inbounds double, double* %9, i64 %1620
%1622 = bitcast double* %1621 to <4 x double>*
%1623 = load <4 x double>, <4 x double>* %1622
%1624 = shufflevector <4 x double> %1623, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%1625 = shufflevector <4 x double> %1623, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%1626 = add nsw i64 %1618, 1
%1627 = getelementptr inbounds double, double* %7, i64 %1626
%1628 = bitcast double* %1627 to <4 x double>*
%1629 = load <4 x double>, <4 x double>* %1628
%1630 = shufflevector <4 x double> %1629, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%1631 = shufflevector <4 x double> %1629, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%1632 = fneg <2 x double> %1625
%1633 = fmul <2 x double> %1631, %1632
%1634 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1624, <2 x double> %1630, <2 x double> %1633)
%1635 = bitcast double* %1621 to <4 x double>*
%1636 = load <4 x double>, <4 x double>* %1635
%1637 = shufflevector <4 x double> %1636, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%1638 = shufflevector <4 x double> %1636, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%1639 = getelementptr inbounds double, double* %1574, i64 %1619
%1640 = bitcast double* %1639 to <4 x double>*
%1641 = load <4 x double>, <4 x double>* %1640
%1642 = shufflevector <4 x double> %1641, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%1643 = shufflevector <4 x double> %1641, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%1644 = fmul <2 x double> %1638, %1642
%1645 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1637, <2 x double> %1643, <2 x double> %1644)
%1646 = getelementptr inbounds double, double* %1575, i64 %1619
%1647 = bitcast double* %1646 to <4 x double>*
%1648 = shufflevector <2 x double> %1634, <2 x double> %1645, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %1648, <4 x double>* %1647
%1649 = add nuw i64 %1614, 2
%1650 = icmp eq i64 %1649, %1569
br i1 %1650, label %1651, label %1613
1651: ; preds = %1613
br i1 %1576, label %1685, label %1652
1652: ; preds = %1603, %1602, %1651
%1653 = phi i64 [ %1588, %1603 ], [ %1588, %1602 ], [ %1591, %1651 ]
%1654 = phi i64 [ 2, %1603 ], [ 2, %1602 ], [ %1572, %1651 ]
%1655 = phi i64 [ %1594, %1603 ], [ %1594, %1602 ], [ %1612, %1651 ]
br label %1656
1656: ; preds = %1652, %1656
%1657 = phi i64 [ %1660, %1656 ], [ %1653, %1652 ]
%1658 = phi i64 [ %1683, %1656 ], [ %1654, %1652 ]
%1659 = phi i64 [ %1661, %1656 ], [ %1655, %1652 ]
%1660 = add nsw i64 %1657, 2
%1661 = add nsw i64 %1659, 2
%1662 = add nsw i64 %1657, 1
%1663 = getelementptr inbounds double, double* %9, i64 %1662
%1664 = load double, double* %1663
%1665 = add nsw i64 %1659, 1
%1666 = getelementptr inbounds double, double* %7, i64 %1665
%1667 = load double, double* %1666
%1668 = getelementptr inbounds double, double* %9, i64 %1660
%1669 = load double, double* %1668
%1670 = getelementptr inbounds double, double* %7, i64 %1661
%1671 = load double, double* %1670
%1672 = fneg double %1669
%1673 = fmul double %1671, %1672
%1674 = tail call double @llvm.fmuladd.f64(double %1664, double %1667, double %1673)
%1675 = getelementptr inbounds double, double* %5, i64 %1665
store double %1674, double* %1675
%1676 = load double, double* %1663
%1677 = load double, double* %1670
%1678 = load double, double* %1668
%1679 = load double, double* %1666
%1680 = fmul double %1678, %1679
%1681 = tail call double @llvm.fmuladd.f64(double %1676, double %1677, double %1680)
%1682 = getelementptr inbounds double, double* %5, i64 %1661
store double %1681, double* %1682
%1683 = add nuw nsw i64 %1658, 2
%1684 = icmp slt i64 %1683, %0
br i1 %1684, label %1656, label %1685
1685: ; preds = %1656, %1651, %1592
%1686 = add nsw i64 %1594, %0
%1687 = add nuw nsw i64 %1593, 1
%1688 = icmp eq i64 %1687, %2
br i1 %1688, label %1689, label %1592
1689: ; preds = %1685, %1577
%1690 = add nuw nsw i64 %1579, 1
%1691 = icmp eq i64 %1690, %1
%1692 = add i64 %1578, 1
br i1 %1691, label %1693, label %1577
1693: ; preds = %1552, %1689, %1352, %1504, %1555, %1136
ret void
}