void dradbg(int ido, int ip, int l1, int idl1, double *cc, double *c1,
            double *c2, double *ch, double *ch2, double *wa) {
  static double tpi = 6.28318530717958647692528676655900577;
  int 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;
  int nbd;
  double dcp, arg, dsp, ar1h, ar2h;
  int 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    $0xe0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  0x3ec5(%rip),%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <cos@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11db <dradbg+0xbb>
jmp    127a <dradbg+0x15a>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1275 <dradbg+0x155>
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1255 <dradbg+0x135>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120f <dradbg+0xef>
mov    -0x4(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f0 <dradbg+0xd0>
jmp    1309 <dradbg+0x1e9>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1304 <dradbg+0x1e4>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ed <dradbg+0x1cd>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a7 <dradbg+0x187>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1288 <dradbg+0x168>
jmp    1309 <dradbg+0x1e9>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    %eax,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    140d <dradbg+0x2ed>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f6 <dradbg+0x2d6>
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1369 <dradbg+0x249>
mov    -0x60(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1330 <dradbg+0x210>
cmpl   $0x1,-0x4(%rbp)
jne    141c <dradbg+0x2fc>
jmp    17da <dradbg+0x6ba>
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1430 <dradbg+0x310>
jmp    15fb <dradbg+0x4db>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15f6 <dradbg+0x4d6>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15e3 <dradbg+0x4c3>
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15ba <dradbg+0x49a>
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c2 <dradbg+0x3a2>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1497 <dradbg+0x377>
jmp    15e8 <dradbg+0x4c8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1452 <dradbg+0x332>
jmp    17da <dradbg+0x6ba>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    17d5 <dradbg+0x6b5>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17c2 <dradbg+0x6a2>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x64(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17af <dradbg+0x68f>
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b7 <dradbg+0x597>
jmp    17b4 <dradbg+0x694>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1668 <dradbg+0x548>
jmp    17c7 <dradbg+0x6a7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    161d <dradbg+0x4fd>
jmp    17da <dradbg+0x6ba>
movsd  0x181e(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b6b <dradbg+0xa4b>
mov    -0x10(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1992 <dradbg+0x872>
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x5c(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18ed <dradbg+0x7cd>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b58 <dradbg+0xa38>
mov    -0x10(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x60(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b45 <dradbg+0xa25>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x70(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x74(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aa5 <dradbg+0x985>
jmp    1b4a <dradbg+0xa2a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19e5 <dradbg+0x8c5>
jmp    1b5d <dradbg+0xa3d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1820 <dradbg+0x700>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1bf1 <dradbg+0xad1>
mov    -0x10(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1bde <dradbg+0xabe>
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x4c(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b9b <dradbg+0xa7b>
jmp    1be3 <dradbg+0xac3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b79 <dradbg+0xa59>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ccc <dradbg+0xbac>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1cb9 <dradbg+0xb99>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c3f <dradbg+0xb1f>
jmp    1cbe <dradbg+0xb9e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c0c <dradbg+0xaec>
cmpl   $0x1,-0x4(%rbp)
jne    1cdb <dradbg+0xbbb>
jmp    200a <dradbg+0xeea>
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1cef <dradbg+0xbcf>
jmp    1e7a <dradbg+0xd5a>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e75 <dradbg+0xd55>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1e62 <dradbg+0xd42>
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e42 <dradbg+0xd22>
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d5c <dradbg+0xc3c>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d3d <dradbg+0xc1d>
jmp    1e67 <dradbg+0xd47>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d0a <dradbg+0xbea>
jmp    200a <dradbg+0xeea>
movl   $0x0,-0x48(%rbp)
mov    -0xdc(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2005 <dradbg+0xee5>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ff2 <dradbg+0xed2>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fdf <dradbg+0xebf>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ef9 <dradbg+0xdd9>
jmp    1fe4 <dradbg+0xec4>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ec8 <dradbg+0xda8>
jmp    1ff7 <dradbg+0xed7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e95 <dradbg+0xd75>
jmp    200a <dradbg+0xeea>
cmpl   $0x1,-0x4(%rbp)
jne    2019 <dradbg+0xef9>
jmp    23e5 <dradbg+0x12c5>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2054 <dradbg+0xf34>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2020 <dradbg+0xf00>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    20d1 <dradbg+0xfb1>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    20be <dradbg+0xf9e>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2081 <dradbg+0xf61>
jmp    20c3 <dradbg+0xfa3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2062 <dradbg+0xf42>
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    20e5 <dradbg+0xfc5>
jmp    226a <dradbg+0x114a>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2265 <dradbg+0x1145>
mov    -0x4(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2252 <dradbg+0x1132>
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    223f <dradbg+0x111f>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x50(%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    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    215a <dradbg+0x103a>
jmp    2244 <dradbg+0x1124>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    212f <dradbg+0x100f>
jmp    2257 <dradbg+0x1137>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20fe <dradbg+0xfde>
jmp    23e5 <dradbg+0x12c5>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    23e5 <dradbg+0x12c5>
mov    -0x4(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    23d2 <dradbg+0x12b2>
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    23bb <dradbg+0x129b>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x50(%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    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    22cd <dradbg+0x11ad>
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    22ae <dradbg+0x118e>
jmp    23d7 <dradbg+0x12b7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2283 <dradbg+0x1163>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,0x80(%rsp)
mov    %r8,0x20(%rsp)
mov    %ecx,0x58(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%ebx
mov    0x1b8(%rsp),%r15
mov    %esi,%eax
imul   %edi,%eax
mov    %eax,0x54(%rsp)
cvtsi2sd %esi,%xmm1
movsd  0x2e9a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0xf0(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%rbx),%eax
mov    %rax,0xb0(%rsp)
mov    %rbp,0x48(%rsp)
lea    0x1(%rbp),%eax
mov    %eax,0x50(%rsp)
cmp    %r14d,%ebx
mov    %r14,0x38(%rsp)
mov    %rbx,0x8(%rsp)
jge    13d8 <dradbg+0x2b8>
test   %ebx,%ebx
movapd 0xf0(%rsp),%xmm11
jle    1680 <dradbg+0x560>
mov    0x8(%rsp),%edx
movslq 0x54(%rsp),%r10
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%esi
mov    %esi,0x18(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %esi,0x10(%rsp)
and    $0xfffffffc,%eax
mov    %eax,0x88(%rsp)
mov    %r10,%r8
shl    $0x5,%r8
lea    (%r10,%r10,2),%rax
mov    0x20(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
mov    %rax,0xa8(%rsp)
mov    %r10,%rax
shl    $0x4,%rax
add    %rsi,%rax
mov    %rax,0x40(%rsp)
lea    (%rsi,%r10,8),%rax
mov    %rax,0xc8(%rsp)
mov    %rdx,%r9
shl    $0x5,%r9
lea    (%rdx,%rdx,2),%rsi
lea    (%r15,%rsi,8),%rsi
mov    %rsi,0xc0(%rsp)
mov    %rdx,%rsi
shl    $0x4,%rsi
add    %r15,%rsi
mov    %rsi,0xb8(%rsp)
lea    (%r15,%rdx,8),%rsi
mov    %rsi,0xd0(%rsp)
lea    0x0(,%r10,8),%rbx
lea    0x0(,%rdx,8),%rax
xor    %ecx,%ecx
xor    %r11d,%r11d
mov    %rbx,0x68(%rsp)
mov    %rax,0x78(%rsp)
mov    %r9,0x28(%rsp)
jmp    1291 <dradbg+0x171>
nop
add    $0x1,%r11
add    $0x8,%rcx
cmp    %rdx,%r11
je     1680 <dradbg+0x560>
cmpl   $0x0,0x38(%rsp)
jle    1280 <dradbg+0x160>
mov    %r11,%rbp
mov    %r11,0x60(%rsp)
mov    %r11,%rsi
cmpl   $0x3,0x18(%rsp)
mov    %r8,%rax
jb     1385 <dradbg+0x265>
mov    0x88(%rsp),%r14d
mov    0xd0(%rsp),%r13
mov    0xb8(%rsp),%r11
mov    0xc0(%rsp),%r15
mov    0x1b8(%rsp),%r12
mov    0xc8(%rsp),%r9
mov    0x40(%rsp),%r8
mov    0xa8(%rsp),%rbx
mov    0x20(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    %rsi,%rbp
mov    %rcx,0x30(%rsp)
movsd  (%rdi,%rcx,1),%xmm1
movsd  %xmm1,(%r12,%rcx,1)
add    %rdx,%rsi
add    %r10,%rbp
movsd  (%r9,%rcx,1),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,1)
add    %rdx,%rsi
add    %r10,%rbp
movsd  (%r8,%rcx,1),%xmm1
movsd  %xmm1,(%r11,%rcx,1)
add    %rdx,%rsi
add    %r10,%rbp
movsd  (%rbx,%rcx,1),%xmm1
movsd  %xmm1,(%r15,%rcx,1)
add    %rdx,%rsi
add    %r10,%rbp
add    %rax,%rdi
add    %rax,%rbx
add    %rax,%r8
add    %rax,%r9
mov    %rdx,%rcx
mov    %r10,%rdx
mov    %rax,%r10
mov    0x28(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r11
add    %rax,%r13
mov    %r10,%rax
mov    %rdx,%r10
mov    %rcx,%rdx
mov    0x30(%rsp),%rcx
add    $0xfffffffc,%r14d
jne    1300 <dradbg+0x1e0>
cmpl   $0x0,0x10(%rsp)
mov    0x1b8(%rsp),%r15
mov    %rax,%r8
mov    0x68(%rsp),%rbx
mov    0x78(%rsp),%rax
mov    0x60(%rsp),%r11
je     1280 <dradbg+0x160>
mov    0x20(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdi
lea    (%r15,%rsi,8),%rsi
mov    0x10(%rsp),%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm1
movsd  %xmm1,(%rsi)
add    %rbx,%rdi
add    %rax,%rsi
add    $0xffffffff,%ebp
jne    13c0 <dradbg+0x2a0>
jmp    1280 <dradbg+0x160>
test   %r14d,%r14d
movapd 0xf0(%rsp),%xmm11
jle    1680 <dradbg+0x560>
movslq 0x8(%rsp),%r13
movslq 0x54(%rsp),%r12
mov    0xb0(%rsp),%rax
lea    0x1(%rax),%r9
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x78(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x88(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x20(%rsp),%rax
lea    0x30(%rax),%rdi
lea    0x0(,%r12,8),%rcx
mov    %rcx,0x30(%rsp)
lea    0x30(%r15),%rdx
lea    0x0(,%r13,8),%rcx
mov    %rcx,0x28(%rsp)
add    $0x18,%rax
mov    %rax,0x10(%rsp)
lea    0x18(%r15),%rax
mov    %rax,0x18(%rsp)
xor    %r8d,%r8d
xor    %r10d,%r10d
xor    %r11d,%r11d
mov    %r9,0x60(%rsp)
jmp    14af <dradbg+0x38f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r13,%r10
add    %r12,%r8
add    $0x1,%r11d
add    0x30(%rsp),%rdi
add    0x28(%rsp),%rdx
cmp    0x38(%rsp),%r11d
je     1680 <dradbg+0x560>
cmpl   $0x0,0x8(%rsp)
jle    1490 <dradbg+0x370>
xor    %ebp,%ebp
cmpl   $0x3,0xb0(%rsp)
03
jae    14d0 <dradbg+0x3b0>
mov    %r8,%rax
mov    %r10,%r14
jmp    15a0 <dradbg+0x480>
nopl   (%rax)
lea    (%r9,%r8,1),%rax
lea    (%r15,%r10,8),%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
cmp    %rax,%rcx
jae    1506 <dradbg+0x3e6>
lea    (%r9,%r10,1),%rax
lea    (%r15,%rax,8),%rcx
mov    0x20(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    %r8,%rax
mov    %r10,%r14
cmp    %rcx,%rsi
jb     15a0 <dradbg+0x480>
cmpq   $0x0,0x78(%rsp)
je     166b <dradbg+0x54b>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups -0x30(%rdi,%rax,8),%xmm1
movups -0x20(%rdi,%rax,8),%xmm2
movups %xmm1,-0x30(%rdx,%rax,8)
movups %xmm2,-0x20(%rdx,%rax,8)
movupd -0x10(%rdi,%rax,8),%xmm1
movupd (%rdi,%rax,8),%xmm2
movupd %xmm1,-0x10(%rdx,%rax,8)
movupd %xmm2,(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1520 <dradbg+0x400>
testb  $0x1,0x88(%rsp)
01
je     1582 <dradbg+0x462>
lea    (%r8,%rax,1),%rcx
add    %r10,%rax
mov    0x20(%rsp),%rsi
movupd (%rsi,%rcx,8),%xmm1
movupd 0x10(%rsi,%rcx,8),%xmm2
movupd %xmm1,(%r15,%rax,8)
movupd %xmm2,0x10(%r15,%rax,8)
cmp    0x68(%rsp),%r9
je     1490 <dradbg+0x370>
mov    0x68(%rsp),%rcx
lea    (%r8,%rcx,1),%rax
lea    (%r10,%rcx,1),%r14
mov    %ecx,%ebp
nopl   0x0(%rax)
mov    0x8(%rsp),%rsi
mov    %esi,%ecx
sub    %ebp,%ecx
mov    %ebp,%ebx
not    %ebx
add    %esi,%ebx
and    $0x3,%ecx
je     1606 <dradbg+0x4e6>
mov    %r12,%r9
mov    %r13,%r12
mov    0x20(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
lea    (%r15,%r14,8),%r15
neg    %ecx
xor    %r13d,%r13d
nopl   0x0(%rax)
movsd  (%rsi),%xmm1
movsd  %xmm1,(%r15)
add    $0xffffffffffffffff,%r13
add    $0x8,%rsi
add    $0x8,%r15
cmp    %r13d,%ecx
jne    15d0 <dradbg+0x4b0>
sub    %r13,%rax
sub    %r13,%r14
sub    %r13d,%ebp
mov    0x1b8(%rsp),%r15
mov    %r12,%r13
mov    %r9,%r12
mov    0x60(%rsp),%r9
cmp    $0x3,%ebx
jb     1490 <dradbg+0x370>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%r14,8),%rcx
mov    0x8(%rsp),%rsi
sub    %ebp,%esi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rbx,8),%xmm1
movsd  %xmm1,-0x18(%rcx,%rbx,8)
movsd  -0x10(%rax,%rbx,8),%xmm1
movsd  %xmm1,-0x10(%rcx,%rbx,8)
movsd  -0x8(%rax,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rbx,8)
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
add    $0x4,%rbx
cmp    %ebx,%esi
jne    1630 <dradbg+0x510>
jmp    1490 <dradbg+0x370>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
jne    155e <dradbg+0x43e>
jmp    1582 <dradbg+0x462>
mov    0x38(%rsp),%r10
mov    %r10d,%ecx
mov    0x8(%rsp),%rax
imul   %eax,%ecx
mov    %rcx,0x40(%rsp)
sarl   0x50(%rsp)
add    %eax,%eax
mov    %rax,0x18(%rsp)
cmpl   $0x3,0x48(%rsp)
jl     1854 <dradbg+0x734>
movslq 0x8(%rsp),%rcx
movslq 0x18(%rsp),%r12
movslq 0x54(%rsp),%rdx
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%esi
mov    0x40(%rsp),%rbp
imul   %ebp,%esi
mov    0x50(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r11d
cmovge %eax,%r11d
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %eax,0x88(%rsp)
mov    %rcx,0x68(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    0x20(%rsp),%rbx
lea    (%rbx,%r12,8),%rcx
lea    (%rdx,%rdx,1),%rdi
add    %r12,%rdx
lea    (%rbx,%rdx,8),%rdx
mov    $0x1,%r8d
xor    %r9d,%r9d
mov    %r12,%r14
mov    %ebp,%r13d
mov    %r12,0x78(%rsp)
mov    %r11d,0x28(%rsp)
jmp    176f <dradbg+0x64f>
mov    %rbp,%r11
mov    0x20(%rsp),%rbp
movsd  -0x8(%rbp,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r15,%r11,8)
mov    0x28(%rsp),%r11d
movsd  0x0(%rbp,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
mov    0x30(%rsp),%rbx
movsd  %xmm1,(%r15,%rbx,8)
add    %r12,%r14
add    $0x1,%r8d
mov    0x40(%rsp),%rbp
add    %ebp,%r13d
sub    %ebp,%esi
add    %r12,%r9
cmp    %r11d,%r8d
je     1854 <dradbg+0x734>
test   %r10d,%r10d
jle    1752 <dradbg+0x632>
movslq %esi,%rbx
movslq %r13d,%rbp
cmp    $0x1,%r10d
mov    %rbx,0x30(%rsp)
jne    1790 <dradbg+0x670>
mov    %r14,%rbx
test   $0x1,%r10b
je     1752 <dradbg+0x632>
jmp    1720 <dradbg+0x600>
mov    %esi,0x60(%rsp)
mov    %rbp,%rsi
mov    0x68(%rsp),%rbp
lea    (%rbx,%rbp,1),%r10
lea    (%rsi,%rbp,1),%r11
lea    (%r15,%rbx,8),%rbp
lea    (%r15,%r10,8),%r10
mov    %r15,%rbx
mov    %rsi,0x10(%rsp)
lea    (%r15,%rsi,8),%r15
lea    (%rbx,%r11,8),%r12
mov    0x88(%rsp),%esi
mov    %r9,%rbx
xor    %r11d,%r11d
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r15,%r11,8)
movsd  (%rcx,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x0(%rbp,%r11,8)
movsd  -0x8(%rdx,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r12,%r11,8)
movsd  (%rdx,%rbx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%r11,8)
add    %rax,%r11
add    %rdi,%rbx
add    $0xfffffffe,%esi
jne    17d0 <dradbg+0x6b0>
add    %r11,0x30(%rsp)
mov    0x78(%rsp),%r12
add    %r12,%rbx
mov    0x10(%rsp),%rbp
add    %r11,%rbp
mov    0x38(%rsp),%r10
mov    0x1b8(%rsp),%r15
mov    0x60(%rsp),%esi
mov    0x28(%rsp),%r11d
test   $0x1,%r10b
je     1752 <dradbg+0x632>
jmp    1720 <dradbg+0x600>
mov    0xb0(%rsp),%rax
sar    %eax
mov    %rax,0xb0(%rsp)
cmpl   $0x1,0x8(%rsp)
jne    2114 <dradbg+0xff4>
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x74(%rsp)
cmp    $0x3,%eax
mov    0x8(%rsp),%rcx
mov    0x1b0(%rsp),%r10
jl     2797 <dradbg+0x1677>
mov    0x74(%rsp),%edx
mov    0x58(%rsp),%r8d
imul   %r8d,%edx
movapd 0x2767(%rip),%xmm10
xorpd  %xmm0,%xmm10
movslq %edx,%r9
movslq %r8d,%rdi
mov    0x48(%rsp),%rax
add    $0xfffffffe,%eax
imul   %r8d,%eax
mov    %eax,0xec(%rsp)
mov    0x50(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%ecx
cmovge %eax,%ecx
mov    %ecx,0x30(%rsp)
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %ecx,0xd8(%rsp)
mov    %edi,%ebx
lea    -0x1(%rdi),%ebp
lea    (%rdi,%rbx,1),%rax
mov    0x1c0(%rsp),%r15
lea    (%r15,%rax,8),%rax
mov    %rax,0x168(%rsp)
lea    (%r9,%rbx,1),%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0x160(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm9
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rax
mov    %rax,0x150(%rsp)
mov    %rax,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x148(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x140(%rsp)
movabs $0x1fffffffc,%rax
or     $0x2,%rax
lea    0x1(%rbp),%rsi
mov    %rsi,0xd0(%rsp)
and    %rsi,%rax
mov    %rax,0xc8(%rsp)
movsd  0x2686(%rip),%xmm3
movapd 0x2685(%rip),%xmm8
lea    (%rdi,%rdi,1),%eax
mov    %eax,0xe8(%rsp)
lea    0x8(%r10,%rbp,8),%rax
mov    %rax,0x170(%rsp)
mov    %rbp,0x60(%rsp)
lea    0x8(%r15,%rbp,8),%rax
mov    %rax,0xa8(%rsp)
lea    (%r10,%rbx,8),%rax
mov    %rax,0x158(%rsp)
mov    %rbx,0xa0(%rsp)
lea    (%r15,%rbx,8),%rax
mov    %rax,0x120(%rsp)
lea    (%r15,%rdi,8),%rax
mov    %rax,0x118(%rsp)
lea    (%r15,%r9,8),%rax
mov    %rax,0x110(%rsp)
mov    %rdi,0x90(%rsp)
lea    (%rcx,%rdi,1),%rax
mov    %rax,0x130(%rsp)
mov    %r9,0x98(%rsp)
mov    %rcx,0x108(%rsp)
lea    (%rcx,%r9,1),%rax
mov    %rax,0x128(%rsp)
lea    0x10(%r10),%rax
mov    %rax,0x138(%rsp)
mov    $0x1,%eax
mov    %r8d,%ecx
jmp    1a68 <dradbg+0x948>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xf0(%rsp),%eax
add    $0x1,%eax
mov    0x54(%rsp),%edx
sub    %r8d,%edx
mov    0xe0(%rsp),%ecx
add    %r8d,%ecx
cmp    0xd8(%rsp),%eax
je     228f <dradbg+0x116f>
mov    %eax,0xf0(%rsp)
mov    %edx,0x54(%rsp)
movslq %edx,%rax
mov    %rax,0x10(%rsp)
lea    (%r10,%rax,8),%r12
mov    %ecx,0xe0(%rsp)
movslq %ecx,%rax
mov    %rax,0x18(%rsp)
lea    (%r10,%rax,8),%r11
movapd %xmm3,%xmm2
unpckhpd %xmm9,%xmm2
movapd %xmm10,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm11,%xmm3
addpd  %xmm4,%xmm3
movapd %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
test   %r8d,%r8d
jle    1e1a <dradbg+0xcfa>
cmp    $0x1,%r8d
jne    1af0 <dradbg+0x9d0>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rbp
jmp    1dc0 <dradbg+0xca0>
nopl   0x0(%rax)
mov    0x158(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,8),%rsi
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,8),%rbp
cmp    %rbp,%r11
setb   0x28(%rsp)
cmp    %rsi,%r12
setb   %r13b
mov    0x120(%rsp),%rdi
cmp    %rdi,%r11
setb   %r9b
cmp    %r15,%rsi
seta   0x20(%rsp)
mov    0x168(%rsp),%rax
cmp    %rax,%r11
setb   %r8b
mov    0x118(%rsp),%rdx
cmp    %rsi,%rdx
setb   0x68(%rsp)
mov    0x160(%rsp),%rbx
cmp    %rbx,%r11
setb   %r14b
mov    0x110(%rsp),%rcx
cmp    %rsi,%rcx
setb   0x78(%rsp)
cmp    %rdi,%r12
setb   %sil
cmp    %r15,%rbp
seta   %r15b
cmp    %rax,%r12
setb   %dil
cmp    %rbp,%rdx
setb   %dl
cmp    %rbx,%r12
setb   %r10b
cmp    %rbp,%rcx
setb   %al
test   %r13b,0x28(%rsp)
jne    1d67 <dradbg+0xc47>
and    0x20(%rsp),%r9b
jne    1d67 <dradbg+0xc47>
and    0x68(%rsp),%r8b
jne    1d67 <dradbg+0xc47>
and    0x78(%rsp),%r14b
jne    1d67 <dradbg+0xc47>
and    %r15b,%sil
jne    1d67 <dradbg+0xc47>
and    %dl,%dil
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
jne    1d92 <dradbg+0xc72>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    $0x0,%esi
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rbp
and    %al,%r10b
mov    0x1b0(%rsp),%r10
jne    1dc0 <dradbg+0xca0>
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
cmpq   $0x0,0x150(%rsp)
mov    0x118(%rsp),%rax
je     1d55 <dradbg+0xc35>
mov    0x138(%rsp),%rcx
mov    0x18(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
mov    0x10(%rsp),%rsi
lea    (%rcx,%rsi,8),%rsi
mov    0x140(%rsp),%rdi
xor    %ecx,%ecx
mov    0x110(%rsp),%rbp
nopl   0x0(%rax)
movupd (%r15,%rcx,8),%xmm2
movupd (%rax,%rcx,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm6,-0x10(%rdx,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm2
mulpd  %xmm4,%xmm2
movupd %xmm2,-0x10(%rsi,%rcx,8)
movupd 0x10(%r15,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm6,(%rdx,%rcx,8)
movupd 0x10(%rbp,%rcx,8),%xmm2
mulpd  %xmm4,%xmm2
movupd %xmm2,(%rsi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1c60 <dradbg+0xb40>
testb  $0x1,0x148(%rsp)
01
je     1d13 <dradbg+0xbf3>
mov    0x18(%rsp),%rax
add    %rcx,%rax
mov    0x10(%rsp),%rdx
add    %rcx,%rdx
mov    0x90(%rsp),%rsi
add    %rcx,%rsi
movupd (%r15,%rcx,8),%xmm2
add    0x98(%rsp),%rcx
movupd (%r15,%rsi,8),%xmm6
mulpd  %xmm6,%xmm5
addpd  %xmm2,%xmm5
movupd %xmm5,(%r10,%rax,8)
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm4,%xmm2
movupd %xmm2,(%r10,%rdx,8)
mov    0x108(%rsp),%rax
cmp    0xa0(%rsp),%rax
je     1e1a <dradbg+0xcfa>
mov    0x108(%rsp),%rsi
mov    0x18(%rsp),%rax
lea    (%rsi,%rax,1),%rcx
mov    0x10(%rsp),%rax
lea    (%rsi,%rax,1),%rdx
mov    0x130(%rsp),%rdi
mov    0x128(%rsp),%rbp
jmp    1dc0 <dradbg+0xca0>
xor    %ecx,%ecx
testb  $0x1,0x148(%rsp)
01
jne    1cc6 <dradbg+0xba6>
jmp    1d13 <dradbg+0xbf3>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rbp
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
jmp    1dae <dradbg+0xc8e>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rbp
mov    0x1b0(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
lea    (%r10,%rcx,8),%rcx
lea    (%r10,%rdx,8),%rax
lea    (%r15,%rsi,8),%rdx
mov    0xa0(%rsp),%rbx
sub    %rsi,%rbx
lea    (%r15,%rdi,8),%rsi
lea    (%r15,%rbp,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm2
mulsd  %xmm3,%xmm2
addsd  (%rdx,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1df0 <dradbg+0xcd0>
cmpl   $0x5,0x48(%rsp)
jb     1a40 <dradbg+0x920>
mov    0x170(%rsp),%rax
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,8),%rsi
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
xorpd  %xmm8,%xmm4
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
mov    %rax,0x78(%rsp)
cmp    %rax,%r11
setb   %al
mov    %rsi,0x68(%rsp)
cmp    %rsi,%r12
setb   %bl
and    %al,%bl
mov    %bl,0x88(%rsp)
mov    0xc8(%rsp),%rax
add    %rax,%rdx
mov    %rdx,0xc0(%rsp)
add    %rcx,%rax
mov    %rax,0xb8(%rsp)
mov    $0x2,%r13d
mov    0xe8(%rsp),%r14d
mov    0xec(%rsp),%ecx
movapd %xmm3,%xmm2
jmp    1ec5 <dradbg+0xda5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13d
sub    %r8d,%ecx
add    %r8d,%r14d
cmp    0x30(%rsp),%r13d
je     1a40 <dradbg+0x920>
movapd %xmm2,%xmm6
unpckhpd %xmm3,%xmm6
movapd %xmm4,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
mulpd  %xmm5,%xmm2
addpd  %xmm7,%xmm2
test   %r8d,%r8d
jle    1eb0 <dradbg+0xd90>
movslq %ecx,%rbp
movslq %r14d,%rdi
xor    %r9d,%r9d
movapd %xmm2,%xmm7
unpckhpd %xmm2,%xmm7
cmpl   $0x0,0x60(%rsp)
je     2040 <dradbg+0xf20>
lea    (%r15,%rbp,8),%rbx
lea    (%r15,%rdi,8),%rsi
mov    0xa8(%rsp),%rax
mov    %rdi,0x20(%rsp)
lea    (%rax,%rdi,8),%rdx
mov    %rbp,0x28(%rsp)
lea    (%rax,%rbp,8),%rdi
cmp    %rdx,%r11
setb   %al
mov    0x68(%rsp),%rbp
cmp    %rbp,%rsi
setb   %r10b
and    %al,%r10b
or     0x88(%rsp),%r10b
cmp    %rdi,%r11
setb   %al
cmp    %rbp,%rbx
setb   %r9b
cmp    %rdx,%r12
setb   %dl
mov    0x78(%rsp),%rbp
cmp    %rbp,%rsi
setb   %r15b
cmp    %rdi,%r12
setb   %dil
cmp    %rbp,%rbx
setb   %r8b
test   %r10b,%r10b
jne    2094 <dradbg+0xf74>
and    %r9b,%al
mov    0x1b0(%rsp),%r10
jne    207b <dradbg+0xf5b>
and    %r15b,%dl
mov    0x28(%rsp),%rbp
mov    $0x0,%r9d
jne    205d <dradbg+0xf3d>
and    %r8b,%dil
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
jne    204c <dradbg+0xf2c>
mov    0xc8(%rsp),%rdx
mov    0x20(%rsp),%rdi
add    %rdx,%rdi
add    %rdx,%rbp
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
xor    %eax,%eax
nop
movupd (%rsi,%rax,8),%xmm0
mulpd  %xmm6,%xmm0
movupd (%r11,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r11,%rax,8)
movupd (%rbx,%rax,8),%xmm0
movupd (%r12,%rax,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1fd0 <dradbg+0xeb0>
mov    0xc0(%rsp),%rsi
mov    0xb8(%rsp),%rbx
mov    %edx,%r9d
cmp    %rdx,0xd0(%rsp)
je     1eb0 <dradbg+0xd90>
jmp    20c0 <dradbg+0xfa0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbx
jmp    20c0 <dradbg+0xfa0>
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    0x20(%rsp),%rdi
jmp    20c0 <dradbg+0xfa0>
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
mov    0x20(%rsp),%rdi
jmp    20c0 <dradbg+0xfa0>
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
jmp    20b3 <dradbg+0xf93>
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    0x58(%rsp),%r8d
mov    0x1c0(%rsp),%r15
mov    0x1b0(%rsp),%r10
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%rdi
xor    %r9d,%r9d
lea    (%r10,%rsi,8),%rsi
lea    (%r10,%rbx,8),%rbx
lea    (%r15,%rdi,8),%rdi
lea    (%r15,%rbp,8),%rbp
mov    %r8d,%eax
sub    %r9d,%eax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%eax
jne    20e0 <dradbg+0xfc0>
jmp    1eb0 <dradbg+0xd90>
mov    0xb0(%rsp),%rax
cmp    0x38(%rsp),%eax
jge    24e0 <dradbg+0x13c0>
cmpl   $0x3,0x48(%rsp)
mov    0x80(%rsp),%r13
jl     29e0 <dradbg+0x18c0>
mov    0x18(%rsp),%rax
lea    -0x2(%rax),%ecx
mov    %ecx,0x28(%rsp)
movslq 0x54(%rsp),%rdx
add    $0x2,%eax
mov    %eax,0x60(%rsp)
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    0x40(%rsp),%rax
imul   %eax,%ecx
add    $0x2,%ecx
mov    %ecx,0x10(%rsp)
movslq 0x8(%rsp),%rdi
mov    0x50(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%esi
cmovge %ecx,%esi
mov    %esi,0x78(%rsp)
add    $0x2,%eax
mov    %eax,0x68(%rsp)
shl    $0x3,%rdi
shl    $0x3,%rdx
mov    $0x1,%ecx
mov    0x38(%rsp),%rbx
jmp    21cb <dradbg+0x10ab>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%ecx
add    $0x1,%ecx
mov    0x18(%rsp),%rax
add    %eax,0x28(%rsp)
add    %eax,0x60(%rsp)
mov    0x40(%rsp),%rax
sub    %eax,0x10(%rsp)
add    %eax,0x68(%rsp)
cmp    0x78(%rsp),%ecx
je     1871 <dradbg+0x751>
mov    %ecx,0x30(%rsp)
cmpl   $0x3,0x8(%rsp)
jl     21a0 <dradbg+0x1080>
mov    $0x2,%ebp
mov    0x68(%rsp),%r12d
mov    0x10(%rsp),%r13d
mov    0x60(%rsp),%r15d
mov    0x28(%rsp),%esi
jmp    2208 <dradbg+0x10e8>
add    $0x2,%ebp
add    $0xfffffffe,%esi
add    $0x2,%r15d
add    $0x2,%r13d
add    $0x2,%r12d
cmp    0x8(%rsp),%ebp
jge    21a0 <dradbg+0x1080>
cmpl   $0x0,0x38(%rsp)
jle    21f0 <dradbg+0x10d0>
movslq %r12d,%rcx
movslq %r13d,%rax
movslq %r15d,%r8
movslq %esi,%r9
mov    %ebx,%r10d
mov    0x20(%rsp),%r11
mov    0x1b8(%rsp),%r14
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r11,%r8,8),%xmm1
addsd  -0x8(%r11,%r9,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rcx,8)
movsd  -0x8(%r11,%r8,8),%xmm1
subsd  -0x8(%r11,%r9,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rax,8)
movsd  (%r11,%r8,8),%xmm1
subsd  (%r11,%r9,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  (%r11,%r8,8),%xmm1
addsd  (%r11,%r9,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    %rdi,%r14
add    %rdx,%r11
add    $0xffffffff,%r10d
jne    2230 <dradbg+0x1110>
jmp    21f0 <dradbg+0x10d0>
cmpl   $0x3,0x48(%rsp)
mov    0x8(%rsp),%rcx
jl     2797 <dradbg+0x1677>
mov    0x50(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%r12d
cmovge %ecx,%r12d
mov    0xa0(%rsp),%r15
mov    %r15d,%r14d
and    $0xfffffffc,%r14d
lea    -0x4(%r14),%r10
mov    %r10,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
neg    %r15
mov    0x1c0(%rsp),%rax
lea    0x30(%rax),%r9
lea    0x8(%rax),%r13
mov    $0x1,%esi
mov    0x58(%rsp),%edx
mov    %edx,%ecx
jmp    2312 <dradbg+0x11f2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%esi
mov    0x58(%rsp),%edx
add    %edx,%ecx
cmp    %r12d,%esi
je     261d <dradbg+0x14fd>
test   %edx,%edx
jle    2300 <dradbg+0x11e0>
movslq %ecx,%rdx
cmpl   $0x4,0x58(%rsp)
jb     2342 <dradbg+0x1222>
mov    0x120(%rsp),%rbx
lea    (%rbx,%rdx,8),%rdi
mov    0x1c0(%rsp),%rax
cmp    %rax,%rdi
jbe    235a <dradbg+0x123a>
lea    (%rax,%rdx,8),%rdi
cmp    %rbx,%rdi
jae    235a <dradbg+0x123a>
xor    %edi,%edi
testb  $0x1,0xa0(%rsp)
01
jne    2440 <dradbg+0x1320>
mov    %rdi,%rbx
jmp    2462 <dradbg+0x1342>
test   %r10,%r10
je     24cf <dradbg+0x13af>
lea    (%r9,%rdx,8),%rbp
mov    %r8,%rdi
xor    %ebx,%ebx
mov    0x1c0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rbp,%rbx,8),%xmm0
movupd -0x20(%rbp,%rbx,8),%xmm1
movupd (%rax,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rax,%rbx,8),%xmm1
movupd 0x30(%rax,%rbx,8),%xmm3
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
movupd -0x10(%rbp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rbx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rax,%rbx,8)
movupd %xmm1,0x30(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    2380 <dradbg+0x1260>
test   $0x1,%r11b
je     241b <dradbg+0x12fb>
lea    (%rbx,%rdx,1),%rdi
mov    0x1c0(%rsp),%rax
movupd (%rax,%rdi,8),%xmm0
movupd 0x10(%rax,%rdi,8),%xmm1
movupd (%rax,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
cmp    0xa0(%rsp),%r14
je     2300 <dradbg+0x11e0>
add    %r14,%rdx
mov    %r14,%rdi
testb  $0x1,0xa0(%rsp)
01
je     2352 <dradbg+0x1232>
nopl   (%rax)
mov    0x1c0(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
add    $0x1,%rdx
addsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
mov    %rdi,%rbx
or     $0x1,%rbx
not    %rdi
cmp    %r15,%rdi
je     2300 <dradbg+0x11e0>
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
mov    0xa0(%rsp),%rdi
sub    %rbx,%rdi
lea    0x0(,%rbx,8),%rbx
add    %r13,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbp,8),%xmm0
addsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
addsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    24a0 <dradbg+0x1380>
jmp    2300 <dradbg+0x11e0>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    23e6 <dradbg+0x12c6>
jmp    241b <dradbg+0x12fb>
cmpl   $0x3,0x48(%rsp)
mov    0x80(%rsp),%r13
jl     29e0 <dradbg+0x18c0>
movslq 0x54(%rsp),%r12
mov    0x48(%rsp),%rax
lea    -0x1(%rax),%r10d
mov    0x40(%rsp),%rcx
imul   %ecx,%r10d
movslq 0x8(%rsp),%r13
mov    0x50(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
mov    0x1b8(%rsp),%rax
lea    0x10(%rax),%r9
shl    $0x3,%r13
shl    $0x3,%r12
mov    $0x1,%r15d
mov    %ecx,%r11d
mov    0x18(%rsp),%rax
mov    %eax,%r14d
jmp    256d <dradbg+0x144d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15d
add    0x18(%rsp),%r14d
mov    0x40(%rsp),%rax
sub    %eax,%r10d
add    %eax,%r11d
cmp    %r8d,%r15d
je     1871 <dradbg+0x751>
cmpl   $0x0,0x38(%rsp)
mov    0x8(%rsp),%rdx
jle    2550 <dradbg+0x1430>
movslq %r11d,%rax
lea    (%r9,%rax,8),%rbp
movslq %r10d,%rax
lea    (%r9,%rax,8),%rbx
movslq %r14d,%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %ecx,%ecx
jmp    25b2 <dradbg+0x1492>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
add    %r13,%rbp
add    %r13,%rbx
add    %r12,%rdi
cmp    0x38(%rsp),%ecx
je     2550 <dradbg+0x1430>
cmp    $0x3,%edx
jl     25a0 <dradbg+0x1480>
mov    $0xfffffffffffffffe,%rsi
xor    %eax,%eax
movsd  0x8(%rdi,%rax,8),%xmm1
addsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm1
subsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm1
subsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x10(%rdi,%rax,8),%xmm1
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x2,%rax
add    $0xfffffffffffffffe,%rsi
lea    0x2(%rax),%edx
cmp    0x8(%rsp),%edx
mov    0x8(%rsp),%rdx
jl     25c0 <dradbg+0x14a0>
jmp    25a0 <dradbg+0x1480>
cmpl   $0x3,0x48(%rsp)
mov    0x8(%rsp),%rcx
jl     2797 <dradbg+0x1677>
mov    0x40(%rsp),%rdx
mov    %edx,%r15d
imul   0x74(%rsp),%r15d
mov    0x50(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
movslq %ecx,%rdi
mov    0x38(%rsp),%rax
and    $0xfffffffe,%eax
mov    %eax,0x60(%rsp)
mov    %rdi,0x20(%rsp)
add    %rdi,%rdi
mov    $0x1,%r13d
mov    %edx,%r12d
mov    %esi,0x28(%rsp)
jmp    2688 <dradbg+0x1568>
add    $0x1,%r13d
mov    0x40(%rsp),%rax
add    %eax,%r12d
sub    %eax,%r15d
cmp    %esi,%r13d
je     2797 <dradbg+0x1677>
cmpl   $0x0,0x38(%rsp)
jle    2670 <dradbg+0x1550>
movslq %r15d,%rbp
movslq %r12d,%r14
cmpl   $0x1,0x38(%rsp)
je     2756 <dradbg+0x1636>
mov    0x20(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
lea    (%rcx,%r14,1),%r8
mov    0x80(%rsp),%r10
lea    (%r10,%rbp,8),%rcx
mov    0x1b8(%rsp),%r9
mov    %rbp,0x30(%rsp)
lea    (%r9,%rbp,8),%rbp
lea    (%r9,%rax,8),%rbx
lea    (%r10,%rax,8),%rax
lea    (%r10,%r14,8),%rdx
lea    (%r9,%r14,8),%rsi
lea    (%r9,%r8,8),%r9
lea    (%r10,%r8,8),%r10
mov    0x60(%rsp),%r11d
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%r8,8),%xmm0
subsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movsd  (%rdx,%r8,8),%xmm0
addsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r8,8)
movsd  (%r10,%r8,8),%xmm0
subsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,(%r9,%r8,8)
movsd  (%r10,%r8,8),%xmm0
addsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,(%rbx,%r8,8)
add    %rdi,%r8
add    $0xfffffffe,%r11d
jne    26f0 <dradbg+0x15d0>
mov    0x30(%rsp),%rbp
add    %r8,%rbp
add    %r8,%r14
mov    0x8(%rsp),%rcx
mov    0x28(%rsp),%esi
testb  $0x1,0x38(%rsp)
je     2670 <dradbg+0x1550>
mov    0x80(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
subsd  (%rax,%rbp,8),%xmm0
mov    0x1b8(%rsp),%rdx
movsd  %xmm0,(%rdx,%r14,8)
movsd  (%rax,%r14,8),%xmm0
addsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
jmp    2670 <dradbg+0x1550>
cmp    $0x1,%ecx
mov    0x80(%rsp),%r13
je     317b <dradbg+0x205b>
mov    0x38(%rsp),%r12
cmp    %r12d,0xb0(%rsp)
jge    28d0 <dradbg+0x17b0>
cmpl   $0x3,0x48(%rsp)
jl     29e0 <dradbg+0x18c0>
mov    0x40(%rsp),%rcx
mov    0x74(%rsp),%r8d
imul   %ecx,%r8d
add    $0x2,%r8d
movslq 0x8(%rsp),%rax
lea    0x2(%rcx),%r9d
mov    0x50(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %edx,0x30(%rsp)
shl    $0x3,%rax
mov    $0x1,%r10d
jmp    281a <dradbg+0x16fa>
add    $0x1,%r10d
mov    0x40(%rsp),%rcx
sub    %ecx,%r8d
add    %ecx,%r9d
cmp    0x30(%rsp),%r10d
je     29e0 <dradbg+0x18c0>
cmpl   $0x3,0x8(%rsp)
jl     2800 <dradbg+0x16e0>
mov    $0x2,%r15d
mov    %r9d,%r11d
mov    %r8d,%r14d
jmp    2843 <dradbg+0x1723>
nop
add    $0x2,%r15d
add    $0x2,%r14d
add    $0x2,%r11d
cmp    0x8(%rsp),%r15d
jge    2800 <dradbg+0x16e0>
test   %r12d,%r12d
jle    2830 <dradbg+0x1710>
movslq %r11d,%rcx
lea    0x0(,%rcx,8),%rdx
add    %r13,%rdx
mov    0x1b8(%rsp),%rdi
lea    (%rdi,%rcx,8),%rbp
movslq %r14d,%rcx
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
lea    (%rdi,%rcx,8),%rcx
mov    %r12d,%ebx
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rdx,%rdi,1),%xmm0
subsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdi,1)
movsd  -0x8(%rdx,%rdi,1),%xmm0
addsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdi,1)
movsd  (%rdx,%rdi,1),%xmm0
addsd  -0x8(%rsi,%rdi,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,1)
movsd  (%rdx,%rdi,1),%xmm0
subsd  -0x8(%rsi,%rdi,1),%xmm0
movsd  %xmm0,(%rcx,%rdi,1)
add    %rax,%rdi
add    $0xffffffff,%ebx
jne    2880 <dradbg+0x1760>
jmp    2830 <dradbg+0x1710>
cmpl   $0x3,0x48(%rsp)
jl     29e0 <dradbg+0x18c0>
mov    0x40(%rsp),%rcx
mov    0x74(%rsp),%eax
imul   %ecx,%eax
mov    %eax,0x74(%rsp)
movslq 0x8(%rsp),%r15
mov    0x50(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %edx,0x30(%rsp)
lea    0x10(%r13),%r9
shl    $0x3,%r15
mov    0x1b8(%rsp),%rax
lea    0x10(%rax),%r10
mov    $0x1,%r14d
mov    %ecx,%r11d
mov    0x8(%rsp),%r8
jmp    294b <dradbg+0x182b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
mov    0x40(%rsp),%rax
sub    %eax,0x74(%rsp)
add    %eax,%r11d
cmp    0x30(%rsp),%r14d
je     29e0 <dradbg+0x18c0>
test   %r12d,%r12d
jle    2930 <dradbg+0x1810>
movslq %r11d,%rcx
lea    (%r9,%rcx,8),%rbx
lea    (%r10,%rcx,8),%rcx
movslq 0x74(%rsp),%rsi
lea    (%r10,%rsi,8),%rdx
lea    (%r9,%rsi,8),%rsi
xor    %ebp,%ebp
jmp    2984 <dradbg+0x1864>
nopl   0x0(%rax)
add    $0x1,%ebp
add    %r15,%rbx
add    %r15,%rcx
add    %r15,%rdx
add    %r15,%rsi
cmp    %r12d,%ebp
je     2930 <dradbg+0x1810>
cmp    $0x3,%r8d
jl     2970 <dradbg+0x1850>
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdi,8),%xmm0
subsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdi,8)
movsd  -0x8(%rbx,%rdi,8),%xmm0
addsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rdi,8)
movsd  (%rbx,%rdi,8),%xmm0
addsd  -0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
movsd  (%rbx,%rdi,8),%xmm0
subsd  -0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
add    $0x2,%rdi
lea    0x2(%rdi),%eax
cmp    %r8d,%eax
jl     2990 <dradbg+0x1870>
jmp    2970 <dradbg+0x1850>
mov    0x58(%rsp),%ecx
test   %ecx,%ecx
mov    0x1b8(%rsp),%r10
mov    0x1c0(%rsp),%rbx
mov    0x1b0(%rsp),%rax
jle    2b88 <dradbg+0x1a68>
mov    %ecx,%r9d
cmp    $0x4,%ecx
jb     2a22 <dradbg+0x1902>
lea    (%rbx,%r9,8),%rcx
cmp    %rax,%rcx
jbe    2a9c <dradbg+0x197c>
lea    (%rax,%r9,8),%rcx
cmp    %rbx,%rcx
jbe    2a9c <dradbg+0x197c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     2a54 <dradbg+0x1934>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2a40 <dradbg+0x1920>
cmp    $0x3,%rdx
jb     2b88 <dradbg+0x1a68>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    2a60 <dradbg+0x1940>
jmp    2b88 <dradbg+0x1a68>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    2ac0 <dradbg+0x19a0>
xor    %edi,%edi
jmp    2b3c <dradbg+0x1a1c>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movups %xmm0,0x20(%rax,%rdi,8)
movups %xmm1,0x30(%rax,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm0
movups 0x50(%rbx,%rdi,8),%xmm1
movups %xmm0,0x40(%rax,%rdi,8)
movups %xmm1,0x50(%rax,%rdi,8)
movupd 0x60(%rbx,%rdi,8),%xmm0
movupd 0x70(%rbx,%rdi,8),%xmm1
movupd %xmm0,0x60(%rax,%rdi,8)
movupd %xmm1,0x70(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2ae0 <dradbg+0x19c0>
test   %rdx,%rdx
je     2b7f <dradbg+0x1a5f>
lea    (%rax,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    2b60 <dradbg+0x1a40>
cmp    %r9,%rcx
jne    2a24 <dradbg+0x1904>
cmpl   $0x2,0x48(%rsp)
mov    0x8(%rsp),%rcx
jl     317b <dradbg+0x205b>
mov    0x1c8(%rsp),%rax
movslq %ecx,%rdx
mov    0x38(%rsp),%rcx
lea    -0x1(%rcx),%esi
mov    %esi,0x20(%rsp)
mov    %ecx,%esi
and    $0x3,%esi
mov    %esi,0x28(%rsp)
and    $0xfffffffc,%ecx
mov    %ecx,0x60(%rsp)
lea    0x0(,%rdx,8),%r12
lea    (%r12,%r12,2),%r14
lea    (%r14,%r13,1),%rcx
mov    %rcx,0x10(%rsp)
add    %r10,%r14
mov    %rdx,%r8
shl    $0x4,%r8
mov    %r13,%rcx
add    %r8,%r13
add    %r10,%r8
lea    (%rcx,%rdx,8),%r11
lea    (%r10,%rdx,8),%rsi
mov    $0x1,%ebp
mov    0x40(%rsp),%rcx
mov    %ecx,%edi
jmp    2c11 <dradbg+0x1af1>
nopl   (%rax)
add    $0x1,%ebp
add    0x40(%rsp),%edi
cmp    0x48(%rsp),%ebp
je     2cd9 <dradbg+0x1bb9>
cmpl   $0x0,0x38(%rsp)
jle    2c00 <dradbg+0x1ae0>
mov    %edi,0x30(%rsp)
movslq %edi,%r9
cmpl   $0x3,0x20(%rsp)
jae    2c40 <dradbg+0x1b20>
mov    %r9,%rbx
mov    0x80(%rsp),%r10
mov    0x1b8(%rsp),%r15
jmp    2ca6 <dradbg+0x1b86>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%ecx
mov    0x80(%rsp),%r10
mov    0x1b8(%rsp),%r15
mov    0x10(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%r15,%r9,8),%xmm0
movsd  %xmm0,(%r10,%r9,8)
lea    (%r9,%rdx,1),%rbx
movsd  (%rsi,%r9,8),%xmm0
movsd  %xmm0,(%r11,%r9,8)
add    %rdx,%rbx
movsd  (%r8,%r9,8),%xmm0
movsd  %xmm0,0x0(%r13,%r9,8)
add    %rdx,%rbx
movsd  (%r14,%r9,8),%xmm0
movsd  %xmm0,(%rdi,%r9,8)
add    %rdx,%rbx
mov    %rbx,%r9
add    $0xfffffffc,%ecx
jne    2c60 <dradbg+0x1b40>
cmpl   $0x0,0x28(%rsp)
mov    0x30(%rsp),%edi
je     2c00 <dradbg+0x1ae0>
shl    $0x3,%rbx
mov    0x28(%rsp),%ecx
nopl   (%rax)
movsd  (%r15,%rbx,1),%xmm0
movsd  %xmm0,(%r10,%rbx,1)
add    %r12,%rbx
add    $0xffffffff,%ecx
jne    2cc0 <dradbg+0x1ba0>
jmp    2c00 <dradbg+0x1ae0>
mov    0xb0(%rsp),%rcx
cmp    0x38(%rsp),%ecx
jle    3092 <dradbg+0x1f72>
cmpl   $0x2,0x48(%rsp)
mov    0x80(%rsp),%rsi
mov    0x8(%rsp),%rcx
mov    0x1b8(%rsp),%rdi
jl     317b <dradbg+0x205b>
add    $0xfffffffd,%ecx
mov    %ecx,%ebp
and    $0xfffffffe,%ebp
lea    0x8(%rax),%rbx
mov    %rbx,0xa0(%rsp)
lea    (%rax,%rbp,8),%rbx
add    $0x18,%rbx
mov    %rbx,0xd8(%rsp)
add    $0x3,%rbp
mov    %rbp,0xe0(%rsp)
mov    %ecx,0x28(%rsp)
shr    %ecx
lea    0x1(%rcx),%ebp
mov    %rbp,0xd0(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0x88(%rsp)
add    %rbp,%rbp
mov    %rbp,0xa8(%rsp)
add    %ecx,%ecx
add    $0x2,%ecx
or     $0x2,%ecx
mov    %ecx,0x54(%rsp)
lea    0x10(%rdi),%rcx
mov    %rcx,0x20(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0x60(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x10(%rsp)
mov    $0x1,%esi
movl   $0xffffffff,0xc0(%rsp)
ff ff ff ff
mov    0x40(%rsp),%rcx
mov    %ecx,0xb8(%rsp)
jmp    2de8 <dradbg+0x1cc8>
nopw   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%esi
add    $0x1,%esi
mov    0xc0(%rsp),%ecx
add    0x8(%rsp),%ecx
mov    %ecx,0xc0(%rsp)
mov    0xb8(%rsp),%ecx
add    0x40(%rsp),%ecx
mov    %ecx,0xb8(%rsp)
cmp    0x48(%rsp),%esi
je     317b <dradbg+0x205b>
mov    %esi,0xf0(%rsp)
cmpl   $0x0,0x38(%rsp)
jle    2db0 <dradbg+0x1c90>
movslq 0xb8(%rsp),%r13
lea    0x1(%r13),%rcx
mov    %rcx,0x18(%rsp)
mov    0xe0(%rsp),%rcx
add    %r13,%rcx
mov    %rcx,0x58(%rsp)
movslq 0xc0(%rsp),%rsi
lea    (%rax,%rsi,8),%r11
mov    0x80(%rsp),%rcx
lea    (%rcx,%r13,8),%r14
mov    0x1b8(%rsp),%rcx
lea    (%rcx,%r13,8),%r10
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x68(%rsp)
mov    0xd8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x78(%rsp)
mov    0xa8(%rsp),%rcx
mov    %rsi,0x30(%rsp)
add    %rsi,%rcx
mov    %rcx,0xc8(%rsp)
xor    %edi,%edi
jmp    2e97 <dradbg+0x1d77>
nopl   0x0(%rax)
add    %rdx,%r13
add    $0x1,%rdi
add    %r12,%r14
add    %r12,%r10
cmp    0x38(%rsp),%edi
je     2db0 <dradbg+0x1c90>
cmpl   $0x3,0x8(%rsp)
jl     2e80 <dradbg+0x1d60>
mov    $0x2,%ecx
cmpl   $0x2,0x28(%rsp)
jae    2f40 <dradbg+0x1e20>
mov    %r13,%r8
mov    0x30(%rsp),%r9
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%rsi
lea    (%rsi,%r8,8),%rbp
mov    0x60(%rsp),%rsi
lea    (%rsi,%r8,8),%rbx
mov    0x10(%rsp),%rsi
lea    (%rsi,%r9,8),%r8
mov    %ecx,%esi
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r9,8),%xmm0
mulsd  (%r8,%r9,8),%xmm0
movsd  -0x8(%r8,%r9,8),%xmm1
mulsd  -0x8(%rbp,%r9,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rbx,%r9,8)
movsd  (%r8,%r9,8),%xmm0
mulsd  -0x8(%rbp,%r9,8),%xmm0
movsd  -0x8(%r8,%r9,8),%xmm1
mulsd  0x0(%rbp,%r9,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r9,8)
add    $0x2,%r9
lea    (%r9,%rsi,1),%ecx
cmp    %r15d,%ecx
jl     2ee0 <dradbg+0x1dc0>
jmp    2e80 <dradbg+0x1d60>
nopl   (%rax)
mov    %rdi,%rcx
imul   %rdx,%rcx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,1),%rbp
add    0x58(%rsp),%rcx
mov    0x80(%rsp),%rsi
lea    (%rsi,%rbp,8),%rbx
lea    (%rsi,%rcx,8),%r15
mov    0x1b8(%rsp),%rsi
lea    (%rsi,%rbp,8),%rbp
lea    (%rsi,%rcx,8),%rcx
cmp    0x78(%rsp),%rbx
setb   %r8b
cmp    %r15,0x68(%rsp)
setb   %r9b
cmp    %rcx,%rbx
setb   %bl
cmp    %r15,%rbp
setb   %sil
test   %r9b,%r8b
jne    307b <dradbg+0x1f5b>
mov    %r13,%r8
mov    0x30(%rsp),%r9
and    %sil,%bl
mov    0x8(%rsp),%r15
mov    $0x2,%ecx
jne    2ebb <dradbg+0x1d9b>
mov    0xa8(%rsp),%rcx
lea    (%rcx,%r13,1),%r8
mov    $0x8,%esi
mov    0x88(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%r11,%rsi,1),%xmm0
movupd 0x10(%r11,%rsi,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd (%r10,%rsi,1),%xmm1
movupd 0x10(%r10,%rsi,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(%r14,%rsi,1)
movupd %xmm0,(%r14,%rsi,1)
add    $0x20,%rsi
add    $0xfffffffffffffffe,%rbp
jne    2fe0 <dradbg+0x1ec0>
mov    0xc8(%rsp),%r9
mov    0x54(%rsp),%ecx
mov    0x88(%rsp),%rsi
cmp    0xd0(%rsp),%rsi
mov    0x8(%rsp),%r15
je     2e80 <dradbg+0x1d60>
jmp    2ebb <dradbg+0x1d9b>
mov    %r13,%r8
mov    0x30(%rsp),%r9
mov    0x8(%rsp),%r15
mov    $0x2,%ecx
jmp    2ebb <dradbg+0x1d9b>
cmpl   $0x2,0x48(%rsp)
mov    0x80(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0x1b8(%rsp),%rbp
jl     317b <dradbg+0x205b>
mov    0x40(%rsp),%rsi
lea    0x2(%rsi),%r8d
mov    $0x1,%r10d
mov    $0xffffffff,%r9d
jmp    30ec <dradbg+0x1fcc>
nopl   0x0(%rax)
add    $0x1,%r10d
add    0x40(%rsp),%r8d
mov    0x8(%rsp),%rcx
add    %ecx,%r9d
cmp    0x48(%rsp),%r10d
je     317b <dradbg+0x205b>
cmp    $0x3,%ecx
jl     30d0 <dradbg+0x1fb0>
movslq %r9d,%rdi
mov    $0x2,%r14d
mov    %r8d,%r11d
jmp    3112 <dradbg+0x1ff2>
nop
add    $0x2,%r14d
add    $0x2,%r11d
mov    %rbx,%rdi
cmp    0x8(%rsp),%r14d
jge    30d0 <dradbg+0x1fb0>
lea    0x2(%rdi),%rbx
cmpl   $0x0,0x38(%rsp)
jle    3100 <dradbg+0x1fe0>
movslq %r11d,%rsi
shl    $0x3,%rsi
mov    0x38(%rsp),%rcx
nopl   0x0(%rax)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  0x0(%rbp,%rsi,1),%xmm1
mulsd  (%rax,%rbx,8),%xmm1
mulsd  -0x8(%rbp,%rsi,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rdx,%rsi,1)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  (%rax,%rbx,8),%xmm1
mulsd  -0x8(%rbp,%rsi,1),%xmm1
mulsd  0x0(%rbp,%rsi,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rsi,1)
add    %r12,%rsi
add    $0xffffffff,%ecx
jne    3130 <dradbg+0x2010>
jmp    3100 <dradbg+0x1fe0>
add    $0x178,%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(i32 %0, i32 %1, i32 %2, i32 %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9) {
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca i32
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca i32
store i32 %0, i32* %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store i32 %3, i32* %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 i32, i32* %12
%56 = load i32, i32* %11
%57 = mul nsw i32 %55, %56
store i32 %57, i32* %39
%58 = load i32, i32* %13
%59 = load i32, i32* %11
%60 = mul nsw i32 %58, %59
store i32 %60, i32* %29
%61 = load double, double* @dradbg.tpi
%62 = load i32, i32* %12
%63 = sitofp i32 %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 i32, i32* %11
%70 = sub nsw i32 %69, 1
%71 = ashr i32 %70, 1
store i32 %71, i32* %48
%72 = load i32, i32* %12
store i32 %72, i32* %54
%73 = load i32, i32* %12
%74 = add nsw i32 %73, 1
%75 = ashr i32 %74, 1
store i32 %75, i32* %22
%76 = load i32, i32* %11
%77 = load i32, i32* %13
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %80
79: ; preds = %10
br label %120
80: ; preds = %10
store i32 0, i32* %30
store i32 0, i32* %31
store i32 0, i32* %25
br label %81
81: ; preds = %116, %80
%82 = load i32, i32* %25
%83 = load i32, i32* %13
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %119
85: ; preds = %81
%86 = load i32, i32* %30
store i32 %86, i32* %32
%87 = load i32, i32* %31
store i32 %87, i32* %33
store i32 0, i32* %23
br label %88
88: ; preds = %106, %85
%89 = load i32, i32* %23
%90 = load i32, i32* %11
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %109
92: ; preds = %88
%93 = load double*, double** %15
%94 = load i32, i32* %33
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = load double*, double** %18
%99 = load i32, i32* %32
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
store double %97, double* %101
%102 = load i32, i32* %32
%103 = add nsw i32 %102, 1
store i32 %103, i32* %32
%104 = load i32, i32* %33
%105 = add nsw i32 %104, 1
store i32 %105, i32* %33
br label %106
106: ; preds = %92
%107 = load i32, i32* %23
%108 = add nsw i32 %107, 1
store i32 %108, i32* %23
br label %88
109: ; preds = %88
%110 = load i32, i32* %11
%111 = load i32, i32* %30
%112 = add nsw i32 %111, %110
store i32 %112, i32* %30
%113 = load i32, i32* %39
%114 = load i32, i32* %31
%115 = add nsw i32 %114, %113
store i32 %115, i32* %31
br label %116
116: ; preds = %109
%117 = load i32, i32* %25
%118 = add nsw i32 %117, 1
store i32 %118, i32* %25
br label %81
119: ; preds = %81
br label %158
120: ; preds = %79
store i32 0, i32* %30
store i32 0, i32* %23
br label %121
121: ; preds = %154, %120
%122 = load i32, i32* %23
%123 = load i32, i32* %11
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %157
125: ; preds = %121
%126 = load i32, i32* %30
store i32 %126, i32* %31
%127 = load i32, i32* %30
store i32 %127, i32* %32
store i32 0, i32* %25
br label %128
128: ; preds = %148, %125
%129 = load i32, i32* %25
%130 = load i32, i32* %13
%131 = icmp slt i32 %129, %130
br i1 %131, label %132, label %151
132: ; preds = %128
%133 = load double*, double** %15
%134 = load i32, i32* %32
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
%137 = load double, double* %136
%138 = load double*, double** %18
%139 = load i32, i32* %31
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %138, i64 %140
store double %137, double* %141
%142 = load i32, i32* %11
%143 = load i32, i32* %31
%144 = add nsw i32 %143, %142
store i32 %144, i32* %31
%145 = load i32, i32* %39
%146 = load i32, i32* %32
%147 = add nsw i32 %146, %145
store i32 %147, i32* %32
br label %148
148: ; preds = %132
%149 = load i32, i32* %25
%150 = add nsw i32 %149, 1
store i32 %150, i32* %25
br label %128
151: ; preds = %128
%152 = load i32, i32* %30
%153 = add nsw i32 %152, 1
store i32 %153, i32* %30
br label %154
154: ; preds = %151
%155 = load i32, i32* %23
%156 = add nsw i32 %155, 1
store i32 %156, i32* %23
br label %121
157: ; preds = %121
br label %158
158: ; preds = %157, %119
store i32 0, i32* %30
%159 = load i32, i32* %54
%160 = load i32, i32* %29
%161 = mul nsw i32 %159, %160
store i32 %161, i32* %31
%162 = load i32, i32* %11
%163 = shl i32 %162, 1
store i32 %163, i32* %34
store i32 %163, i32* %36
store i32 1, i32* %24
br label %164
164: ; preds = %231, %158
%165 = load i32, i32* %24
%166 = load i32, i32* %22
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %234
168: ; preds = %164
%169 = load i32, i32* %29
%170 = load i32, i32* %30
%171 = add nsw i32 %170, %169
store i32 %171, i32* %30
%172 = load i32, i32* %29
%173 = load i32, i32* %31
%174 = sub nsw i32 %173, %172
store i32 %174, i32* %31
%175 = load i32, i32* %30
store i32 %175, i32* %32
%176 = load i32, i32* %31
store i32 %176, i32* %33
%177 = load i32, i32* %34
store i32 %177, i32* %35
store i32 0, i32* %25
br label %178
178: ; preds = %224, %168
%179 = load i32, i32* %25
%180 = load i32, i32* %13
%181 = icmp slt i32 %179, %180
br i1 %181, label %182, label %227
182: ; preds = %178
%183 = load double*, double** %15
%184 = load i32, i32* %35
%185 = sub nsw i32 %184, 1
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %183, i64 %186
%188 = load double, double* %187
%189 = load double*, double** %15
%190 = load i32, i32* %35
%191 = sub nsw i32 %190, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %189, i64 %192
%194 = load double, double* %193
%195 = fadd double %188, %194
%196 = load double*, double** %18
%197 = load i32, i32* %32
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %196, i64 %198
store double %195, double* %199
%200 = load double*, double** %15
%201 = load i32, i32* %35
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
%204 = load double, double* %203
%205 = load double*, double** %15
%206 = load i32, i32* %35
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %205, i64 %207
%209 = load double, double* %208
%210 = fadd double %204, %209
%211 = load double*, double** %18
%212 = load i32, i32* %33
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
store double %210, double* %214
%215 = load i32, i32* %11
%216 = load i32, i32* %32
%217 = add nsw i32 %216, %215
store i32 %217, i32* %32
%218 = load i32, i32* %11
%219 = load i32, i32* %33
%220 = add nsw i32 %219, %218
store i32 %220, i32* %33
%221 = load i32, i32* %39
%222 = load i32, i32* %35
%223 = add nsw i32 %222, %221
store i32 %223, i32* %35
br label %224
224: ; preds = %182
%225 = load i32, i32* %25
%226 = add nsw i32 %225, 1
store i32 %226, i32* %25
br label %178
227: ; preds = %178
%228 = load i32, i32* %36
%229 = load i32, i32* %34
%230 = add nsw i32 %229, %228
store i32 %230, i32* %34
br label %231
231: ; preds = %227
%232 = load i32, i32* %24
%233 = add nsw i32 %232, 1
store i32 %233, i32* %24
br label %164
234: ; preds = %164
%235 = load i32, i32* %11
%236 = icmp eq i32 %235, 1
br i1 %236, label %237, label %238
237: ; preds = %234
br label %509
238: ; preds = %234
%239 = load i32, i32* %48
%240 = load i32, i32* %13
%241 = icmp slt i32 %239, %240
br i1 %241, label %242, label %243
242: ; preds = %238
br label %374
243: ; preds = %238
store i32 0, i32* %30
%244 = load i32, i32* %54
%245 = load i32, i32* %29
%246 = mul nsw i32 %244, %245
store i32 %246, i32* %31
store i32 0, i32* %36
store i32 1, i32* %24
br label %247
247: ; preds = %370, %243
%248 = load i32, i32* %24
%249 = load i32, i32* %22
%250 = icmp slt i32 %248, %249
br i1 %250, label %251, label %373
251: ; preds = %247
%252 = load i32, i32* %29
%253 = load i32, i32* %30
%254 = add nsw i32 %253, %252
store i32 %254, i32* %30
%255 = load i32, i32* %29
%256 = load i32, i32* %31
%257 = sub nsw i32 %256, %255
store i32 %257, i32* %31
%258 = load i32, i32* %30
store i32 %258, i32* %32
%259 = load i32, i32* %31
store i32 %259, i32* %33
%260 = load i32, i32* %11
%261 = shl i32 %260, 1
%262 = load i32, i32* %36
%263 = add nsw i32 %262, %261
store i32 %263, i32* %36
%264 = load i32, i32* %36
store i32 %264, i32* %37
store i32 0, i32* %25
br label %265
265: ; preds = %366, %251
%266 = load i32, i32* %25
%267 = load i32, i32* %13
%268 = icmp slt i32 %266, %267
br i1 %268, label %269, label %369
269: ; preds = %265
%270 = load i32, i32* %32
store i32 %270, i32* %34
%271 = load i32, i32* %33
store i32 %271, i32* %35
%272 = load i32, i32* %37
store i32 %272, i32* %38
%273 = load i32, i32* %37
store i32 %273, i32* %40
store i32 2, i32* %23
br label %274
274: ; preds = %353, %269
%275 = load i32, i32* %23
%276 = load i32, i32* %11
%277 = icmp slt i32 %275, %276
br i1 %277, label %278, label %356
278: ; preds = %274
%279 = load i32, i32* %34
%280 = add nsw i32 %279, 2
store i32 %280, i32* %34
%281 = load i32, i32* %35
%282 = add nsw i32 %281, 2
store i32 %282, i32* %35
%283 = load i32, i32* %38
%284 = add nsw i32 %283, 2
store i32 %284, i32* %38
%285 = load i32, i32* %40
%286 = sub nsw i32 %285, 2
store i32 %286, i32* %40
%287 = load double*, double** %15
%288 = load i32, i32* %38
%289 = sub nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %287, i64 %290
%292 = load double, double* %291
%293 = load double*, double** %15
%294 = load i32, i32* %40
%295 = sub nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %293, i64 %296
%298 = load double, double* %297
%299 = fadd double %292, %298
%300 = load double*, double** %18
%301 = load i32, i32* %34
%302 = sub nsw i32 %301, 1
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %300, i64 %303
store double %299, double* %304
%305 = load double*, double** %15
%306 = load i32, i32* %38
%307 = sub nsw i32 %306, 1
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %305, i64 %308
%310 = load double, double* %309
%311 = load double*, double** %15
%312 = load i32, i32* %40
%313 = sub nsw i32 %312, 1
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %311, i64 %314
%316 = load double, double* %315
%317 = fsub double %310, %316
%318 = load double*, double** %18
%319 = load i32, i32* %35
%320 = sub nsw i32 %319, 1
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %318, i64 %321
store double %317, double* %322
%323 = load double*, double** %15
%324 = load i32, i32* %38
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %323, i64 %325
%327 = load double, double* %326
%328 = load double*, double** %15
%329 = load i32, i32* %40
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = fsub double %327, %332
%334 = load double*, double** %18
%335 = load i32, i32* %34
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %334, i64 %336
store double %333, double* %337
%338 = load double*, double** %15
%339 = load i32, i32* %38
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %338, i64 %340
%342 = load double, double* %341
%343 = load double*, double** %15
%344 = load i32, i32* %40
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
%347 = load double, double* %346
%348 = fadd double %342, %347
%349 = load double*, double** %18
%350 = load i32, i32* %35
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %349, i64 %351
store double %348, double* %352
br label %353
353: ; preds = %278
%354 = load i32, i32* %23
%355 = add nsw i32 %354, 2
store i32 %355, i32* %23
br label %274
356: ; preds = %274
%357 = load i32, i32* %11
%358 = load i32, i32* %32
%359 = add nsw i32 %358, %357
store i32 %359, i32* %32
%360 = load i32, i32* %11
%361 = load i32, i32* %33
%362 = add nsw i32 %361, %360
store i32 %362, i32* %33
%363 = load i32, i32* %39
%364 = load i32, i32* %37
%365 = add nsw i32 %364, %363
store i32 %365, i32* %37
br label %366
366: ; preds = %356
%367 = load i32, i32* %25
%368 = add nsw i32 %367, 1
store i32 %368, i32* %25
br label %265
369: ; preds = %265
br label %370
370: ; preds = %369
%371 = load i32, i32* %24
%372 = add nsw i32 %371, 1
store i32 %372, i32* %24
br label %247
373: ; preds = %247
br label %509
374: ; preds = %242
store i32 0, i32* %30
%375 = load i32, i32* %54
%376 = load i32, i32* %29
%377 = mul nsw i32 %375, %376
store i32 %377, i32* %31
store i32 0, i32* %36
store i32 1, i32* %24
br label %378
378: ; preds = %505, %374
%379 = load i32, i32* %24
%380 = load i32, i32* %22
%381 = icmp slt i32 %379, %380
br i1 %381, label %382, label %508
382: ; preds = %378
%383 = load i32, i32* %29
%384 = load i32, i32* %30
%385 = add nsw i32 %384, %383
store i32 %385, i32* %30
%386 = load i32, i32* %29
%387 = load i32, i32* %31
%388 = sub nsw i32 %387, %386
store i32 %388, i32* %31
%389 = load i32, i32* %30
store i32 %389, i32* %32
%390 = load i32, i32* %31
store i32 %390, i32* %33
%391 = load i32, i32* %11
%392 = shl i32 %391, 1
%393 = load i32, i32* %36
%394 = add nsw i32 %393, %392
store i32 %394, i32* %36
%395 = load i32, i32* %36
store i32 %395, i32* %37
%396 = load i32, i32* %36
store i32 %396, i32* %38
store i32 2, i32* %23
br label %397
397: ; preds = %501, %382
%398 = load i32, i32* %23
%399 = load i32, i32* %11
%400 = icmp slt i32 %398, %399
br i1 %400, label %401, label %504
401: ; preds = %397
%402 = load i32, i32* %32
%403 = add nsw i32 %402, 2
store i32 %403, i32* %32
%404 = load i32, i32* %33
%405 = add nsw i32 %404, 2
store i32 %405, i32* %33
%406 = load i32, i32* %37
%407 = add nsw i32 %406, 2
store i32 %407, i32* %37
%408 = load i32, i32* %38
%409 = sub nsw i32 %408, 2
store i32 %409, i32* %38
%410 = load i32, i32* %32
store i32 %410, i32* %34
%411 = load i32, i32* %33
store i32 %411, i32* %35
%412 = load i32, i32* %37
store i32 %412, i32* %40
%413 = load i32, i32* %38
store i32 %413, i32* %41
store i32 0, i32* %25
br label %414
414: ; preds = %497, %401
%415 = load i32, i32* %25
%416 = load i32, i32* %13
%417 = icmp slt i32 %415, %416
br i1 %417, label %418, label %500
418: ; preds = %414
%419 = load double*, double** %15
%420 = load i32, i32* %40
%421 = sub nsw i32 %420, 1
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %419, i64 %422
%424 = load double, double* %423
%425 = load double*, double** %15
%426 = load i32, i32* %41
%427 = sub nsw i32 %426, 1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %425, i64 %428
%430 = load double, double* %429
%431 = fadd double %424, %430
%432 = load double*, double** %18
%433 = load i32, i32* %34
%434 = sub nsw i32 %433, 1
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %432, i64 %435
store double %431, double* %436
%437 = load double*, double** %15
%438 = load i32, i32* %40
%439 = sub nsw i32 %438, 1
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %437, i64 %440
%442 = load double, double* %441
%443 = load double*, double** %15
%444 = load i32, i32* %41
%445 = sub nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %443, i64 %446
%448 = load double, double* %447
%449 = fsub double %442, %448
%450 = load double*, double** %18
%451 = load i32, i32* %35
%452 = sub nsw i32 %451, 1
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %450, i64 %453
store double %449, double* %454
%455 = load double*, double** %15
%456 = load i32, i32* %40
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds double, double* %455, i64 %457
%459 = load double, double* %458
%460 = load double*, double** %15
%461 = load i32, i32* %41
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %460, i64 %462
%464 = load double, double* %463
%465 = fsub double %459, %464
%466 = load double*, double** %18
%467 = load i32, i32* %34
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %466, i64 %468
store double %465, double* %469
%470 = load double*, double** %15
%471 = load i32, i32* %40
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %470, i64 %472
%474 = load double, double* %473
%475 = load double*, double** %15
%476 = load i32, i32* %41
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %475, i64 %477
%479 = load double, double* %478
%480 = fadd double %474, %479
%481 = load double*, double** %18
%482 = load i32, i32* %35
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
store double %480, double* %484
%485 = load i32, i32* %11
%486 = load i32, i32* %34
%487 = add nsw i32 %486, %485
store i32 %487, i32* %34
%488 = load i32, i32* %11
%489 = load i32, i32* %35
%490 = add nsw i32 %489, %488
store i32 %490, i32* %35
%491 = load i32, i32* %39
%492 = load i32, i32* %40
%493 = add nsw i32 %492, %491
store i32 %493, i32* %40
%494 = load i32, i32* %39
%495 = load i32, i32* %41
%496 = add nsw i32 %495, %494
store i32 %496, i32* %41
br label %497
497: ; preds = %418
%498 = load i32, i32* %25
%499 = add nsw i32 %498, 1
store i32 %499, i32* %25
br label %414
500: ; preds = %414
br label %501
501: ; preds = %500
%502 = load i32, i32* %23
%503 = add nsw i32 %502, 2
store i32 %503, i32* %23
br label %397
504: ; preds = %397
br label %505
505: ; preds = %504
%506 = load i32, i32* %24
%507 = add nsw i32 %506, 1
store i32 %507, i32* %24
br label %378
508: ; preds = %378
br label %509
509: ; preds = %508, %373, %237
store double 1.000000e+00, double* %45
store double 0.000000e+00, double* %43
store i32 0, i32* %30
%510 = load i32, i32* %54
%511 = load i32, i32* %14
%512 = mul nsw i32 %510, %511
store i32 %512, i32* %31
store i32 %512, i32* %38
%513 = load i32, i32* %12
%514 = sub nsw i32 %513, 1
%515 = load i32, i32* %14
%516 = mul nsw i32 %514, %515
store i32 %516, i32* %32
store i32 1, i32* %26
br label %517
517: ; preds = %665, %509
%518 = load i32, i32* %26
%519 = load i32, i32* %22
%520 = icmp slt i32 %518, %519
br i1 %520, label %521, label %668
521: ; preds = %517
%522 = load i32, i32* %14
%523 = load i32, i32* %30
%524 = add nsw i32 %523, %522
store i32 %524, i32* %30
%525 = load i32, i32* %14
%526 = load i32, i32* %31
%527 = sub nsw i32 %526, %525
store i32 %527, i32* %31
%528 = load double, double* %49
%529 = load double, double* %45
%530 = load double, double* %51
%531 = load double, double* %43
%532 = fmul double %530, %531
%533 = fneg double %532
%534 = call double @llvm.fmuladd.f64(double %528, double %529, double %533)
store double %534, double* %52
%535 = load double, double* %49
%536 = load double, double* %43
%537 = load double, double* %51
%538 = load double, double* %45
%539 = fmul double %537, %538
%540 = call double @llvm.fmuladd.f64(double %535, double %536, double %539)
store double %540, double* %43
%541 = load double, double* %52
store double %541, double* %45
%542 = load i32, i32* %30
store i32 %542, i32* %33
%543 = load i32, i32* %31
store i32 %543, i32* %34
store i32 0, i32* %35
%544 = load i32, i32* %14
store i32 %544, i32* %36
%545 = load i32, i32* %32
store i32 %545, i32* %37
store i32 0, i32* %27
br label %546
546: ; preds = %583, %521
%547 = load i32, i32* %27
%548 = load i32, i32* %14
%549 = icmp slt i32 %547, %548
br i1 %549, label %550, label %586
550: ; preds = %546
%551 = load double*, double** %19
%552 = load i32, i32* %35
%553 = add nsw i32 %552, 1
store i32 %553, i32* %35
%554 = sext i32 %552 to i64
%555 = getelementptr inbounds double, double* %551, i64 %554
%556 = load double, double* %555
%557 = load double, double* %45
%558 = load double*, double** %19
%559 = load i32, i32* %36
%560 = add nsw i32 %559, 1
store i32 %560, i32* %36
%561 = sext i32 %559 to i64
%562 = getelementptr inbounds double, double* %558, i64 %561
%563 = load double, double* %562
%564 = call double @llvm.fmuladd.f64(double %557, double %563, double %556)
%565 = load double*, double** %17
%566 = load i32, i32* %33
%567 = add nsw i32 %566, 1
store i32 %567, i32* %33
%568 = sext i32 %566 to i64
%569 = getelementptr inbounds double, double* %565, i64 %568
store double %564, double* %569
%570 = load double, double* %43
%571 = load double*, double** %19
%572 = load i32, i32* %37
%573 = add nsw i32 %572, 1
store i32 %573, i32* %37
%574 = sext i32 %572 to i64
%575 = getelementptr inbounds double, double* %571, i64 %574
%576 = load double, double* %575
%577 = fmul double %570, %576
%578 = load double*, double** %17
%579 = load i32, i32* %34
%580 = add nsw i32 %579, 1
store i32 %580, i32* %34
%581 = sext i32 %579 to i64
%582 = getelementptr inbounds double, double* %578, i64 %581
store double %577, double* %582
br label %583
583: ; preds = %550
%584 = load i32, i32* %27
%585 = add nsw i32 %584, 1
store i32 %585, i32* %27
br label %546
586: ; preds = %546
%587 = load double, double* %45
store double %587, double* %42
%588 = load double, double* %43
store double %588, double* %47
%589 = load double, double* %45
store double %589, double* %46
%590 = load double, double* %43
store double %590, double* %44
%591 = load i32, i32* %14
store i32 %591, i32* %35
%592 = load i32, i32* %38
%593 = load i32, i32* %14
%594 = sub nsw i32 %592, %593
store i32 %594, i32* %36
store i32 2, i32* %24
br label %595
595: ; preds = %661, %586
%596 = load i32, i32* %24
%597 = load i32, i32* %22
%598 = icmp slt i32 %596, %597
br i1 %598, label %599, label %664
599: ; preds = %595
%600 = load i32, i32* %14
%601 = load i32, i32* %35
%602 = add nsw i32 %601, %600
store i32 %602, i32* %35
%603 = load i32, i32* %14
%604 = load i32, i32* %36
%605 = sub nsw i32 %604, %603
store i32 %605, i32* %36
%606 = load double, double* %42
%607 = load double, double* %46
%608 = load double, double* %47
%609 = load double, double* %44
%610 = fmul double %608, %609
%611 = fneg double %610
%612 = call double @llvm.fmuladd.f64(double %606, double %607, double %611)
store double %612, double* %53
%613 = load double, double* %42
%614 = load double, double* %44
%615 = load double, double* %47
%616 = load double, double* %46
%617 = fmul double %615, %616
%618 = call double @llvm.fmuladd.f64(double %613, double %614, double %617)
store double %618, double* %44
%619 = load double, double* %53
store double %619, double* %46
%620 = load i32, i32* %30
store i32 %620, i32* %33
%621 = load i32, i32* %31
store i32 %621, i32* %34
%622 = load i32, i32* %35
store i32 %622, i32* %40
%623 = load i32, i32* %36
store i32 %623, i32* %41
store i32 0, i32* %27
br label %624
624: ; preds = %657, %599
%625 = load i32, i32* %27
%626 = load i32, i32* %14
%627 = icmp slt i32 %625, %626
br i1 %627, label %628, label %660
628: ; preds = %624
%629 = load double, double* %46
%630 = load double*, double** %19
%631 = load i32, i32* %40
%632 = add nsw i32 %631, 1
store i32 %632, i32* %40
%633 = sext i32 %631 to i64
%634 = getelementptr inbounds double, double* %630, i64 %633
%635 = load double, double* %634
%636 = load double*, double** %17
%637 = load i32, i32* %33
%638 = add nsw i32 %637, 1
store i32 %638, i32* %33
%639 = sext i32 %637 to i64
%640 = getelementptr inbounds double, double* %636, i64 %639
%641 = load double, double* %640
%642 = call double @llvm.fmuladd.f64(double %629, double %635, double %641)
store double %642, double* %640
%643 = load double, double* %44
%644 = load double*, double** %19
%645 = load i32, i32* %41
%646 = add nsw i32 %645, 1
store i32 %646, i32* %41
%647 = sext i32 %645 to i64
%648 = getelementptr inbounds double, double* %644, i64 %647
%649 = load double, double* %648
%650 = load double*, double** %17
%651 = load i32, i32* %34
%652 = add nsw i32 %651, 1
store i32 %652, i32* %34
%653 = sext i32 %651 to i64
%654 = getelementptr inbounds double, double* %650, i64 %653
%655 = load double, double* %654
%656 = call double @llvm.fmuladd.f64(double %643, double %649, double %655)
store double %656, double* %654
br label %657
657: ; preds = %628
%658 = load i32, i32* %27
%659 = add nsw i32 %658, 1
store i32 %659, i32* %27
br label %624
660: ; preds = %624
br label %661
661: ; preds = %660
%662 = load i32, i32* %24
%663 = add nsw i32 %662, 1
store i32 %663, i32* %24
br label %595
664: ; preds = %595
br label %665
665: ; preds = %664
%666 = load i32, i32* %26
%667 = add nsw i32 %666, 1
store i32 %667, i32* %26
br label %517
668: ; preds = %517
store i32 0, i32* %30
store i32 1, i32* %24
br label %669
669: ; preds = %699, %668
%670 = load i32, i32* %24
%671 = load i32, i32* %22
%672 = icmp slt i32 %670, %671
br i1 %672, label %673, label %702
673: ; preds = %669
%674 = load i32, i32* %14
%675 = load i32, i32* %30
%676 = add nsw i32 %675, %674
store i32 %676, i32* %30
%677 = load i32, i32* %30
store i32 %677, i32* %31
store i32 0, i32* %27
br label %678
678: ; preds = %695, %673
%679 = load i32, i32* %27
%680 = load i32, i32* %14
%681 = icmp slt i32 %679, %680
br i1 %681, label %682, label %698
682: ; preds = %678
%683 = load double*, double** %19
%684 = load i32, i32* %31
%685 = add nsw i32 %684, 1
store i32 %685, i32* %31
%686 = sext i32 %684 to i64
%687 = getelementptr inbounds double, double* %683, i64 %686
%688 = load double, double* %687
%689 = load double*, double** %19
%690 = load i32, i32* %27
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds double, double* %689, i64 %691
%693 = load double, double* %692
%694 = fadd double %693, %688
store double %694, double* %692
br label %695
695: ; preds = %682
%696 = load i32, i32* %27
%697 = add nsw i32 %696, 1
store i32 %697, i32* %27
br label %678
698: ; preds = %678
br label %699
699: ; preds = %698
%700 = load i32, i32* %24
%701 = add nsw i32 %700, 1
store i32 %701, i32* %24
br label %669
702: ; preds = %669
store i32 0, i32* %30
%703 = load i32, i32* %54
%704 = load i32, i32* %29
%705 = mul nsw i32 %703, %704
store i32 %705, i32* %31
store i32 1, i32* %24
br label %706
706: ; preds = %764, %702
%707 = load i32, i32* %24
%708 = load i32, i32* %22
%709 = icmp slt i32 %707, %708
br i1 %709, label %710, label %767
710: ; preds = %706
%711 = load i32, i32* %29
%712 = load i32, i32* %30
%713 = add nsw i32 %712, %711
store i32 %713, i32* %30
%714 = load i32, i32* %29
%715 = load i32, i32* %31
%716 = sub nsw i32 %715, %714
store i32 %716, i32* %31
%717 = load i32, i32* %30
store i32 %717, i32* %32
%718 = load i32, i32* %31
store i32 %718, i32* %33
store i32 0, i32* %25
br label %719
719: ; preds = %760, %710
%720 = load i32, i32* %25
%721 = load i32, i32* %13
%722 = icmp slt i32 %720, %721
br i1 %722, label %723, label %763
723: ; preds = %719
%724 = load double*, double** %16
%725 = load i32, i32* %32
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %724, i64 %726
%728 = load double, double* %727
%729 = load double*, double** %16
%730 = load i32, i32* %33
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %729, i64 %731
%733 = load double, double* %732
%734 = fsub double %728, %733
%735 = load double*, double** %18
%736 = load i32, i32* %32
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
store double %734, double* %738
%739 = load double*, double** %16
%740 = load i32, i32* %32
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds double, double* %739, i64 %741
%743 = load double, double* %742
%744 = load double*, double** %16
%745 = load i32, i32* %33
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %744, i64 %746
%748 = load double, double* %747
%749 = fadd double %743, %748
%750 = load double*, double** %18
%751 = load i32, i32* %33
%752 = sext i32 %751 to i64
%753 = getelementptr inbounds double, double* %750, i64 %752
store double %749, double* %753
%754 = load i32, i32* %11
%755 = load i32, i32* %32
%756 = add nsw i32 %755, %754
store i32 %756, i32* %32
%757 = load i32, i32* %11
%758 = load i32, i32* %33
%759 = add nsw i32 %758, %757
store i32 %759, i32* %33
br label %760
760: ; preds = %723
%761 = load i32, i32* %25
%762 = add nsw i32 %761, 1
store i32 %762, i32* %25
br label %719
763: ; preds = %719
br label %764
764: ; preds = %763
%765 = load i32, i32* %24
%766 = add nsw i32 %765, 1
store i32 %766, i32* %24
br label %706
767: ; preds = %706
%768 = load i32, i32* %11
%769 = icmp eq i32 %768, 1
br i1 %769, label %770, label %771
770: ; preds = %767
br label %1010
771: ; preds = %767
%772 = load i32, i32* %48
%773 = load i32, i32* %13
%774 = icmp slt i32 %772, %773
br i1 %774, label %775, label %776
775: ; preds = %771
br label %893
776: ; preds = %771
store i32 0, i32* %30
%777 = load i32, i32* %54
%778 = load i32, i32* %29
%779 = mul nsw i32 %777, %778
store i32 %779, i32* %31
store i32 1, i32* %24
br label %780
780: ; preds = %889, %776
%781 = load i32, i32* %24
%782 = load i32, i32* %22
%783 = icmp slt i32 %781, %782
br i1 %783, label %784, label %892
784: ; preds = %780
%785 = load i32, i32* %29
%786 = load i32, i32* %30
%787 = add nsw i32 %786, %785
store i32 %787, i32* %30
%788 = load i32, i32* %29
%789 = load i32, i32* %31
%790 = sub nsw i32 %789, %788
store i32 %790, i32* %31
%791 = load i32, i32* %30
store i32 %791, i32* %32
%792 = load i32, i32* %31
store i32 %792, i32* %33
store i32 0, i32* %25
br label %793
793: ; preds = %885, %784
%794 = load i32, i32* %25
%795 = load i32, i32* %13
%796 = icmp slt i32 %794, %795
br i1 %796, label %797, label %888
797: ; preds = %793
%798 = load i32, i32* %32
store i32 %798, i32* %34
%799 = load i32, i32* %33
store i32 %799, i32* %35
store i32 2, i32* %23
br label %800
800: ; preds = %875, %797
%801 = load i32, i32* %23
%802 = load i32, i32* %11
%803 = icmp slt i32 %801, %802
br i1 %803, label %804, label %878
804: ; preds = %800
%805 = load i32, i32* %34
%806 = add nsw i32 %805, 2
store i32 %806, i32* %34
%807 = load i32, i32* %35
%808 = add nsw i32 %807, 2
store i32 %808, i32* %35
%809 = load double*, double** %16
%810 = load i32, i32* %34
%811 = sub nsw i32 %810, 1
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double, double* %809, i64 %812
%814 = load double, double* %813
%815 = load double*, double** %16
%816 = load i32, i32* %35
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds double, double* %815, i64 %817
%819 = load double, double* %818
%820 = fsub double %814, %819
%821 = load double*, double** %18
%822 = load i32, i32* %34
%823 = sub nsw i32 %822, 1
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds double, double* %821, i64 %824
store double %820, double* %825
%826 = load double*, double** %16
%827 = load i32, i32* %34
%828 = sub nsw i32 %827, 1
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds double, double* %826, i64 %829
%831 = load double, double* %830
%832 = load double*, double** %16
%833 = load i32, i32* %35
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds double, double* %832, i64 %834
%836 = load double, double* %835
%837 = fadd double %831, %836
%838 = load double*, double** %18
%839 = load i32, i32* %35
%840 = sub nsw i32 %839, 1
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds double, double* %838, i64 %841
store double %837, double* %842
%843 = load double*, double** %16
%844 = load i32, i32* %34
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double, double* %843, i64 %845
%847 = load double, double* %846
%848 = load double*, double** %16
%849 = load i32, i32* %35
%850 = sub nsw i32 %849, 1
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds double, double* %848, i64 %851
%853 = load double, double* %852
%854 = fadd double %847, %853
%855 = load double*, double** %18
%856 = load i32, i32* %34
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %855, i64 %857
store double %854, double* %858
%859 = load double*, double** %16
%860 = load i32, i32* %34
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds double, double* %859, i64 %861
%863 = load double, double* %862
%864 = load double*, double** %16
%865 = load i32, i32* %35
%866 = sub nsw i32 %865, 1
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds double, double* %864, i64 %867
%869 = load double, double* %868
%870 = fsub double %863, %869
%871 = load double*, double** %18
%872 = load i32, i32* %35
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds double, double* %871, i64 %873
store double %870, double* %874
br label %875
875: ; preds = %804
%876 = load i32, i32* %23
%877 = add nsw i32 %876, 2
store i32 %877, i32* %23
br label %800
878: ; preds = %800
%879 = load i32, i32* %11
%880 = load i32, i32* %32
%881 = add nsw i32 %880, %879
store i32 %881, i32* %32
%882 = load i32, i32* %11
%883 = load i32, i32* %33
%884 = add nsw i32 %883, %882
store i32 %884, i32* %33
br label %885
885: ; preds = %878
%886 = load i32, i32* %25
%887 = add nsw i32 %886, 1
store i32 %887, i32* %25
br label %793
888: ; preds = %793
br label %889
889: ; preds = %888
%890 = load i32, i32* %24
%891 = add nsw i32 %890, 1
store i32 %891, i32* %24
br label %780
892: ; preds = %780
br label %1010
893: ; preds = %775
store i32 0, i32* %30
%894 = load i32, i32* %54
%895 = load i32, i32* %29
%896 = mul nsw i32 %894, %895
store i32 %896, i32* %31
store i32 1, i32* %24
br label %897
897: ; preds = %1006, %893
%898 = load i32, i32* %24
%899 = load i32, i32* %22
%900 = icmp slt i32 %898, %899
br i1 %900, label %901, label %1009
901: ; preds = %897
%902 = load i32, i32* %29
%903 = load i32, i32* %30
%904 = add nsw i32 %903, %902
store i32 %904, i32* %30
%905 = load i32, i32* %29
%906 = load i32, i32* %31
%907 = sub nsw i32 %906, %905
store i32 %907, i32* %31
%908 = load i32, i32* %30
store i32 %908, i32* %32
%909 = load i32, i32* %31
store i32 %909, i32* %33
store i32 2, i32* %23
br label %910
910: ; preds = %1002, %901
%911 = load i32, i32* %23
%912 = load i32, i32* %11
%913 = icmp slt i32 %911, %912
br i1 %913, label %914, label %1005
914: ; preds = %910
%915 = load i32, i32* %32
%916 = add nsw i32 %915, 2
store i32 %916, i32* %32
%917 = load i32, i32* %33
%918 = add nsw i32 %917, 2
store i32 %918, i32* %33
%919 = load i32, i32* %32
store i32 %919, i32* %34
%920 = load i32, i32* %33
store i32 %920, i32* %35
store i32 0, i32* %25
br label %921
921: ; preds = %998, %914
%922 = load i32, i32* %25
%923 = load i32, i32* %13
%924 = icmp slt i32 %922, %923
br i1 %924, label %925, label %1001
925: ; preds = %921
%926 = load double*, double** %16
%927 = load i32, i32* %34
%928 = sub nsw i32 %927, 1
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds double, double* %926, i64 %929
%931 = load double, double* %930
%932 = load double*, double** %16
%933 = load i32, i32* %35
%934 = sext i32 %933 to i64
%935 = getelementptr inbounds double, double* %932, i64 %934
%936 = load double, double* %935
%937 = fsub double %931, %936
%938 = load double*, double** %18
%939 = load i32, i32* %34
%940 = sub nsw i32 %939, 1
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds double, double* %938, i64 %941
store double %937, double* %942
%943 = load double*, double** %16
%944 = load i32, i32* %34
%945 = sub nsw i32 %944, 1
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds double, double* %943, i64 %946
%948 = load double, double* %947
%949 = load double*, double** %16
%950 = load i32, i32* %35
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds double, double* %949, i64 %951
%953 = load double, double* %952
%954 = fadd double %948, %953
%955 = load double*, double** %18
%956 = load i32, i32* %35
%957 = sub nsw i32 %956, 1
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds double, double* %955, i64 %958
store double %954, double* %959
%960 = load double*, double** %16
%961 = load i32, i32* %34
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds double, double* %960, i64 %962
%964 = load double, double* %963
%965 = load double*, double** %16
%966 = load i32, i32* %35
%967 = sub nsw i32 %966, 1
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds double, double* %965, i64 %968
%970 = load double, double* %969
%971 = fadd double %964, %970
%972 = load double*, double** %18
%973 = load i32, i32* %34
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds double, double* %972, i64 %974
store double %971, double* %975
%976 = load double*, double** %16
%977 = load i32, i32* %34
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds double, double* %976, i64 %978
%980 = load double, double* %979
%981 = load double*, double** %16
%982 = load i32, i32* %35
%983 = sub nsw i32 %982, 1
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds double, double* %981, i64 %984
%986 = load double, double* %985
%987 = fsub double %980, %986
%988 = load double*, double** %18
%989 = load i32, i32* %35
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds double, double* %988, i64 %990
store double %987, double* %991
%992 = load i32, i32* %11
%993 = load i32, i32* %34
%994 = add nsw i32 %993, %992
store i32 %994, i32* %34
%995 = load i32, i32* %11
%996 = load i32, i32* %35
%997 = add nsw i32 %996, %995
store i32 %997, i32* %35
br label %998
998: ; preds = %925
%999 = load i32, i32* %25
%1000 = add nsw i32 %999, 1
store i32 %1000, i32* %25
br label %921
1001: ; preds = %921
br label %1002
1002: ; preds = %1001
%1003 = load i32, i32* %23
%1004 = add nsw i32 %1003, 2
store i32 %1004, i32* %23
br label %910
1005: ; preds = %910
br label %1006
1006: ; preds = %1005
%1007 = load i32, i32* %24
%1008 = add nsw i32 %1007, 1
store i32 %1008, i32* %24
br label %897
1009: ; preds = %897
br label %1010
1010: ; preds = %1009, %892, %770
%1011 = load i32, i32* %11
%1012 = icmp eq i32 %1011, 1
br i1 %1012, label %1013, label %1014
1013: ; preds = %1010
br label %1279
1014: ; preds = %1010
store i32 0, i32* %27
br label %1015
1015: ; preds = %1029, %1014
%1016 = load i32, i32* %27
%1017 = load i32, i32* %14
%1018 = icmp slt i32 %1016, %1017
br i1 %1018, label %1019, label %1032
1019: ; preds = %1015
%1020 = load double*, double** %19
%1021 = load i32, i32* %27
%1022 = sext i32 %1021 to i64
%1023 = getelementptr inbounds double, double* %1020, i64 %1022
%1024 = load double, double* %1023
%1025 = load double*, double** %17
%1026 = load i32, i32* %27
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds double, double* %1025, i64 %1027
store double %1024, double* %1028
br label %1029
1029: ; preds = %1019
%1030 = load i32, i32* %27
%1031 = add nsw i32 %1030, 1
store i32 %1031, i32* %27
br label %1015
1032: ; preds = %1015
store i32 0, i32* %30
store i32 1, i32* %24
br label %1033
1033: ; preds = %1062, %1032
%1034 = load i32, i32* %24
%1035 = load i32, i32* %12
%1036 = icmp slt i32 %1034, %1035
br i1 %1036, label %1037, label %1065
1037: ; preds = %1033
%1038 = load i32, i32* %29
%1039 = load i32, i32* %30
%1040 = add nsw i32 %1039, %1038
store i32 %1040, i32* %30
store i32 %1040, i32* %31
store i32 0, i32* %25
br label %1041
1041: ; preds = %1058, %1037
%1042 = load i32, i32* %25
%1043 = load i32, i32* %13
%1044 = icmp slt i32 %1042, %1043
br i1 %1044, label %1045, label %1061
1045: ; preds = %1041
%1046 = load double*, double** %18
%1047 = load i32, i32* %31
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1046, i64 %1048
%1050 = load double, double* %1049
%1051 = load double*, double** %16
%1052 = load i32, i32* %31
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds double, double* %1051, i64 %1053
store double %1050, double* %1054
%1055 = load i32, i32* %11
%1056 = load i32, i32* %31
%1057 = add nsw i32 %1056, %1055
store i32 %1057, i32* %31
br label %1058
1058: ; preds = %1045
%1059 = load i32, i32* %25
%1060 = add nsw i32 %1059, 1
store i32 %1060, i32* %25
br label %1041
1061: ; preds = %1041
br label %1062
1062: ; preds = %1061
%1063 = load i32, i32* %24
%1064 = add nsw i32 %1063, 1
store i32 %1064, i32* %24
br label %1033
1065: ; preds = %1033
%1066 = load i32, i32* %48
%1067 = load i32, i32* %13
%1068 = icmp sgt i32 %1066, %1067
br i1 %1068, label %1069, label %1070
1069: ; preds = %1065
br label %1175
1070: ; preds = %1065
%1071 = load i32, i32* %11
%1072 = sub nsw i32 0, %1071
%1073 = sub nsw i32 %1072, 1
store i32 %1073, i32* %28
store i32 0, i32* %30
store i32 1, i32* %24
br label %1074
1074: ; preds = %1171, %1070
%1075 = load i32, i32* %24
%1076 = load i32, i32* %12
%1077 = icmp slt i32 %1075, %1076
br i1 %1077, label %1078, label %1174
1078: ; preds = %1074
%1079 = load i32, i32* %11
%1080 = load i32, i32* %28
%1081 = add nsw i32 %1080, %1079
store i32 %1081, i32* %28
%1082 = load i32, i32* %29
%1083 = load i32, i32* %30
%1084 = add nsw i32 %1083, %1082
store i32 %1084, i32* %30
%1085 = load i32, i32* %28
store i32 %1085, i32* %21
%1086 = load i32, i32* %30
store i32 %1086, i32* %31
store i32 2, i32* %23
br label %1087
1087: ; preds = %1167, %1078
%1088 = load i32, i32* %23
%1089 = load i32, i32* %11
%1090 = icmp slt i32 %1088, %1089
br i1 %1090, label %1091, label %1170
1091: ; preds = %1087
%1092 = load i32, i32* %31
%1093 = add nsw i32 %1092, 2
store i32 %1093, i32* %31
%1094 = load i32, i32* %21
%1095 = add nsw i32 %1094, 2
store i32 %1095, i32* %21
%1096 = load i32, i32* %31
store i32 %1096, i32* %32
store i32 0, i32* %25
br label %1097
1097: ; preds = %1163, %1091
%1098 = load i32, i32* %25
%1099 = load i32, i32* %13
%1100 = icmp slt i32 %1098, %1099
br i1 %1100, label %1101, label %1166
1101: ; preds = %1097
%1102 = load double*, double** %20
%1103 = load i32, i32* %21
%1104 = sub nsw i32 %1103, 1
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds double, double* %1102, i64 %1105
%1107 = load double, double* %1106
%1108 = load double*, double** %18
%1109 = load i32, i32* %32
%1110 = sub nsw i32 %1109, 1
%1111 = sext i32 %1110 to i64
%1112 = getelementptr inbounds double, double* %1108, i64 %1111
%1113 = load double, double* %1112
%1114 = load double*, double** %20
%1115 = load i32, i32* %21
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds double, double* %1114, i64 %1116
%1118 = load double, double* %1117
%1119 = load double*, double** %18
%1120 = load i32, i32* %32
%1121 = sext i32 %1120 to i64
%1122 = getelementptr inbounds double, double* %1119, i64 %1121
%1123 = load double, double* %1122
%1124 = fmul double %1118, %1123
%1125 = fneg double %1124
%1126 = call double @llvm.fmuladd.f64(double %1107, double %1113, double %1125)
%1127 = load double*, double** %16
%1128 = load i32, i32* %32
%1129 = sub nsw i32 %1128, 1
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds double, double* %1127, i64 %1130
store double %1126, double* %1131
%1132 = load double*, double** %20
%1133 = load i32, i32* %21
%1134 = sub nsw i32 %1133, 1
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds double, double* %1132, i64 %1135
%1137 = load double, double* %1136
%1138 = load double*, double** %18
%1139 = load i32, i32* %32
%1140 = sext i32 %1139 to i64
%1141 = getelementptr inbounds double, double* %1138, i64 %1140
%1142 = load double, double* %1141
%1143 = load double*, double** %20
%1144 = load i32, i32* %21
%1145 = sext i32 %1144 to i64
%1146 = getelementptr inbounds double, double* %1143, i64 %1145
%1147 = load double, double* %1146
%1148 = load double*, double** %18
%1149 = load i32, i32* %32
%1150 = sub nsw i32 %1149, 1
%1151 = sext i32 %1150 to i64
%1152 = getelementptr inbounds double, double* %1148, i64 %1151
%1153 = load double, double* %1152
%1154 = fmul double %1147, %1153
%1155 = call double @llvm.fmuladd.f64(double %1137, double %1142, double %1154)
%1156 = load double*, double** %16
%1157 = load i32, i32* %32
%1158 = sext i32 %1157 to i64
%1159 = getelementptr inbounds double, double* %1156, i64 %1158
store double %1155, double* %1159
%1160 = load i32, i32* %11
%1161 = load i32, i32* %32
%1162 = add nsw i32 %1161, %1160
store i32 %1162, i32* %32
br label %1163
1163: ; preds = %1101
%1164 = load i32, i32* %25
%1165 = add nsw i32 %1164, 1
store i32 %1165, i32* %25
br label %1097
1166: ; preds = %1097
br label %1167
1167: ; preds = %1166
%1168 = load i32, i32* %23
%1169 = add nsw i32 %1168, 2
store i32 %1169, i32* %23
br label %1087
1170: ; preds = %1087
br label %1171
1171: ; preds = %1170
%1172 = load i32, i32* %24
%1173 = add nsw i32 %1172, 1
store i32 %1173, i32* %24
br label %1074
1174: ; preds = %1074
br label %1279
1175: ; preds = %1069
%1176 = load i32, i32* %11
%1177 = sub nsw i32 0, %1176
%1178 = sub nsw i32 %1177, 1
store i32 %1178, i32* %28
store i32 0, i32* %30
store i32 1, i32* %24
br label %1179
1179: ; preds = %1276, %1175
%1180 = load i32, i32* %24
%1181 = load i32, i32* %12
%1182 = icmp slt i32 %1180, %1181
br i1 %1182, label %1183, label %1279
1183: ; preds = %1179
%1184 = load i32, i32* %11
%1185 = load i32, i32* %28
%1186 = add nsw i32 %1185, %1184
store i32 %1186, i32* %28
%1187 = load i32, i32* %29
%1188 = load i32, i32* %30
%1189 = add nsw i32 %1188, %1187
store i32 %1189, i32* %30
%1190 = load i32, i32* %30
store i32 %1190, i32* %31
store i32 0, i32* %25
br label %1191
1191: ; preds = %1272, %1183
%1192 = load i32, i32* %25
%1193 = load i32, i32* %13
%1194 = icmp slt i32 %1192, %1193
br i1 %1194, label %1195, label %1275
1195: ; preds = %1191
%1196 = load i32, i32* %28
store i32 %1196, i32* %21
%1197 = load i32, i32* %31
store i32 %1197, i32* %32
store i32 2, i32* %23
br label %1198
1198: ; preds = %1265, %1195
%1199 = load i32, i32* %23
%1200 = load i32, i32* %11
%1201 = icmp slt i32 %1199, %1200
br i1 %1201, label %1202, label %1268
1202: ; preds = %1198
%1203 = load i32, i32* %21
%1204 = add nsw i32 %1203, 2
store i32 %1204, i32* %21
%1205 = load i32, i32* %32
%1206 = add nsw i32 %1205, 2
store i32 %1206, i32* %32
%1207 = load double*, double** %20
%1208 = load i32, i32* %21
%1209 = sub nsw i32 %1208, 1
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds double, double* %1207, i64 %1210
%1212 = load double, double* %1211
%1213 = load double*, double** %18
%1214 = load i32, i32* %32
%1215 = sub nsw i32 %1214, 1
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds double, double* %1213, i64 %1216
%1218 = load double, double* %1217
%1219 = load double*, double** %20
%1220 = load i32, i32* %21
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds double, double* %1219, i64 %1221
%1223 = load double, double* %1222
%1224 = load double*, double** %18
%1225 = load i32, i32* %32
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds double, double* %1224, i64 %1226
%1228 = load double, double* %1227
%1229 = fmul double %1223, %1228
%1230 = fneg double %1229
%1231 = call double @llvm.fmuladd.f64(double %1212, double %1218, double %1230)
%1232 = load double*, double** %16
%1233 = load i32, i32* %32
%1234 = sub nsw i32 %1233, 1
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds double, double* %1232, i64 %1235
store double %1231, double* %1236
%1237 = load double*, double** %20
%1238 = load i32, i32* %21
%1239 = sub nsw i32 %1238, 1
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds double, double* %1237, i64 %1240
%1242 = load double, double* %1241
%1243 = load double*, double** %18
%1244 = load i32, i32* %32
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds double, double* %1243, i64 %1245
%1247 = load double, double* %1246
%1248 = load double*, double** %20
%1249 = load i32, i32* %21
%1250 = sext i32 %1249 to i64
%1251 = getelementptr inbounds double, double* %1248, i64 %1250
%1252 = load double, double* %1251
%1253 = load double*, double** %18
%1254 = load i32, i32* %32
%1255 = sub nsw i32 %1254, 1
%1256 = sext i32 %1255 to i64
%1257 = getelementptr inbounds double, double* %1253, i64 %1256
%1258 = load double, double* %1257
%1259 = fmul double %1252, %1258
%1260 = call double @llvm.fmuladd.f64(double %1242, double %1247, double %1259)
%1261 = load double*, double** %16
%1262 = load i32, i32* %32
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds double, double* %1261, i64 %1263
store double %1260, double* %1264
br label %1265
1265: ; preds = %1202
%1266 = load i32, i32* %23
%1267 = add nsw i32 %1266, 2
store i32 %1267, i32* %23
br label %1198
1268: ; preds = %1198
%1269 = load i32, i32* %11
%1270 = load i32, i32* %31
%1271 = add nsw i32 %1270, %1269
store i32 %1271, i32* %31
br label %1272
1272: ; preds = %1268
%1273 = load i32, i32* %25
%1274 = add nsw i32 %1273, 1
store i32 %1274, i32* %25
br label %1191
1275: ; preds = %1191
br label %1276
1276: ; preds = %1275
%1277 = load i32, i32* %24
%1278 = add nsw i32 %1277, 1
store i32 %1278, i32* %24
br label %1179
1279: ; preds = %1013, %1174, %1179
ret void
}

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