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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
double sin(double);
void dradfg(long ido, long ip, long l1, long idl1, double *cc, double *c1,
            double *c2, double *ch, double *ch2, const double *wa) {
  static double tpi = 6.28318530717958647692528676655900577;
  long idij, ipph, i, j, k, l, ic, ik, is;
  long t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
  double dc2, ai1, ai2, ar1, ar2, ds2;
  long nbd;
  double dcp, arg, dsp, ar1h, ar2h;
  long idp2, ipp2;
  arg = tpi / (double)ip;
  dcp = cos(arg);
  dsp = sin(arg);
  ipph = (ip + 1) >> 1;
  ipp2 = ip;
  idp2 = ido;
  nbd = (ido - 1) >> 1;
  t0 = l1 * ido;
  t10 = ip * ido;
  if (ido == 1)
    goto L119;
  for (ik = 0; ik < idl1; ik++)
    ch2[ik] = c2[ik];
  t1 = 0;
  for (j = 1; j < ip; j++) {
    t1 += t0;
    t2 = t1;
    for (k = 0; k < l1; k++) {
      ch[t2] = c1[t2];
      t2 += ido;
    }
  }
  is = -ido;
  t1 = 0;
  if (nbd > l1) {
    for (j = 1; j < ip; j++) {
      t1 += t0;
      is += ido;
      t2 = -ido + t1;
      for (k = 0; k < l1; k++) {
        idij = is - 1;
        t2 += ido;
        t3 = t2;
        for (i = 2; i < ido; i += 2) {
          idij += 2;
          t3 += 2;
          ch[t3 - 1] = wa[idij - 1] * c1[t3 - 1] + wa[idij] * c1[t3];
          ch[t3] = wa[idij - 1] * c1[t3] - wa[idij] * c1[t3 - 1];
        }
      }
    }
  } else {
    for (j = 1; j < ip; j++) {
      is += ido;
      idij = is - 1;
      t1 += t0;
      t2 = t1;
      for (i = 2; i < ido; i += 2) {
        idij += 2;
        t2 += 2;
        t3 = t2;
        for (k = 0; k < l1; k++) {
          ch[t3 - 1] = wa[idij - 1] * c1[t3 - 1] + wa[idij] * c1[t3];
          ch[t3] = wa[idij - 1] * c1[t3] - wa[idij] * c1[t3 - 1];
          t3 += ido;
        }
      }
    }
  }
  t1 = 0;
  t2 = ipp2 * t0;
  if (nbd < l1) {
    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 - ido;
        t6 = t4 - ido;
        for (k = 0; k < l1; k++) {
          t5 += ido;
          t6 += ido;
          c1[t5 - 1] = ch[t5 - 1] + ch[t6 - 1];
          c1[t6 - 1] = ch[t5] - ch[t6];
          c1[t5] = ch[t5] + ch[t6];
          c1[t6] = ch[t6 - 1] - ch[t5 - 1];
        }
      }
    }
  } else {
    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;
          c1[t5 - 1] = ch[t5 - 1] + ch[t6 - 1];
          c1[t6 - 1] = ch[t5] - ch[t6];
          c1[t5] = ch[t5] + ch[t6];
          c1[t6] = ch[t6 - 1] - ch[t5 - 1];
        }
        t3 += ido;
        t4 += ido;
      }
    }
  }
L119:
  for (ik = 0; ik < idl1; ik++)
    c2[ik] = ch2[ik];
  t1 = 0;
  t2 = ipp2 * idl1;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1 - ido;
    t4 = t2 - ido;
    for (k = 0; k < l1; k++) {
      t3 += ido;
      t4 += ido;
      c1[t3] = ch[t3] + ch[t4];
      c1[t4] = ch[t4] - ch[t3];
    }
  }
  ar1 = 1.;
  ai1 = 0.;
  t1 = 0;
  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 = t3;
    t7 = idl1;
    for (ik = 0; ik < idl1; ik++) {
      ch2[t4++] = c2[ik] + ar1 * c2[t7++];
      ch2[t5++] = ai1 * c2[t6++];
    }
    dc2 = ar1;
    ds2 = ai1;
    ar2 = ar1;
    ai2 = ai1;
    t4 = idl1;
    t5 = (ipp2 - 1) * idl1;
    for (j = 2; j < ipph; j++) {
      t4 += idl1;
      t5 -= idl1;
      ar2h = dc2 * ar2 - ds2 * ai2;
      ai2 = dc2 * ai2 + ds2 * ar2;
      ar2 = ar2h;
      t6 = t1;
      t7 = t2;
      t8 = t4;
      t9 = t5;
      for (ik = 0; ik < idl1; ik++) {
        ch2[t6++] += ar2 * c2[t8++];
        ch2[t7++] += ai2 * c2[t9++];
      }
    }
  }
  t1 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += idl1;
    t2 = t1;
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += c2[t2++];
  }
  if (ido < l1)
    goto L132;
  t1 = 0;
  t2 = 0;
  for (k = 0; k < l1; k++) {
    t3 = t1;
    t4 = t2;
    for (i = 0; i < ido; i++)
      cc[t4++] = ch[t3++];
    t1 += ido;
    t2 += t10;
  }
  goto L135;
L132:
  for (i = 0; i < ido; i++) {
    t1 = i;
    t2 = i;
    for (k = 0; k < l1; k++) {
      cc[t2] = ch[t1];
      t1 += ido;
      t2 += t10;
    }
  }
L135:
  t1 = 0;
  t2 = ido << 1;
  t3 = 0;
  t4 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t0;
    t4 -= t0;
    t5 = t1;
    t6 = t3;
    t7 = t4;
    for (k = 0; k < l1; k++) {
      cc[t5 - 1] = ch[t6];
      cc[t5] = ch[t7];
      t5 += t10;
      t6 += ido;
      t7 += ido;
    }
  }
  if (ido == 1)
    return;
  if (nbd < l1)
    goto L141;
  t1 = -ido;
  t3 = 0;
  t4 = 0;
  t5 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t2;
    t4 += t0;
    t5 -= t0;
    t6 = t1;
    t7 = t3;
    t8 = t4;
    t9 = t5;
    for (k = 0; k < l1; k++) {
      for (i = 2; i < ido; i += 2) {
        ic = idp2 - i;
        cc[i + t7 - 1] = ch[i + t8 - 1] + ch[i + t9 - 1];
        cc[ic + t6 - 1] = ch[i + t8 - 1] - ch[i + t9 - 1];
        cc[i + t7] = ch[i + t8] + ch[i + t9];
        cc[ic + t6] = ch[i + t9] - ch[i + t8];
      }
      t6 += t10;
      t7 += t10;
      t8 += ido;
      t9 += ido;
    }
  }
  return;
L141:
  t1 = -ido;
  t3 = 0;
  t4 = 0;
  t5 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t2;
    t4 += t0;
    t5 -= t0;
    for (i = 2; i < ido; i += 2) {
      t6 = idp2 + t1 - i;
      t7 = i + t3;
      t8 = i + t4;
      t9 = i + t5;
      for (k = 0; k < l1; k++) {
        cc[t7 - 1] = ch[t8 - 1] + ch[t9 - 1];
        cc[t6 - 1] = ch[t8 - 1] - ch[t9 - 1];
        cc[t7] = ch[t8] + ch[t9];
        cc[t6] = ch[t9] - ch[t8];
        t6 += t10;
        t7 += t10;
        t8 += ido;
        t9 += ido;
      }
    }
  }
}


x86 assembly (clang, -O0):
<dradfg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  0x3ed5(%rip),%xmm0
cvtsi2sdq -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
call   1040 <cos@plt>
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10(%rbp),%rax
add    $0x1,%rax
sar    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x8(%rbp),%rax
sub    $0x1,%rax
sar    $0x1,%rax
mov    %rax,-0x108(%rbp)
mov    -0x18(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%rax
imul   -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
cmpq   $0x1,-0x8(%rbp)
jne    11fd <dradfg+0xdd>
jmp    1ae9 <dradfg+0x9c9>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    123e <dradfg+0x11e>
mov    0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1205 <dradfg+0xe5>
movq   $0x0,-0x88(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12ee <dradfg+0x1ce>
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    12d8 <dradfg+0x1b8>
mov    -0x30(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1287 <dradfg+0x167>
jmp    12dd <dradfg+0x1bd>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1251 <dradfg+0x131>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x88(%rbp)
mov    -0x108(%rbp),%rax
cmp    -0x18(%rbp),%rax
jle    14e3 <dradfg+0x3c3>
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    14de <dradfg+0x3be>
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
xor    %eax,%eax
sub    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    14c8 <dradfg+0x3a8>
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    14b2 <dradfg+0x392>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x98(%rbp)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%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    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    13a6 <dradfg+0x286>
jmp    14b7 <dradfg+0x397>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1364 <dradfg+0x244>
jmp    14cd <dradfg+0x3ad>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    131c <dradfg+0x1fc>
jmp    16ac <dradfg+0x58c>
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    16a7 <dradfg+0x587>
mov    -0x8(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1691 <dradfg+0x571>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    167b <dradfg+0x55b>
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%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    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    157b <dradfg+0x45b>
jmp    1680 <dradfg+0x560>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    1539 <dradfg+0x419>
jmp    1696 <dradfg+0x576>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14eb <dradfg+0x3cb>
jmp    16ac <dradfg+0x58c>
movq   $0x0,-0x88(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x108(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    18e6 <dradfg+0x7c6>
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    18e1 <dradfg+0x7c1>
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x90(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    18cb <dradfg+0x7ab>
mov    -0x98(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x98(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    18b5 <dradfg+0x795>
mov    -0x8(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    179a <dradfg+0x67a>
jmp    18ba <dradfg+0x79a>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    173c <dradfg+0x61c>
jmp    18d0 <dradfg+0x7b0>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    16e3 <dradfg+0x5c3>
jmp    1ae4 <dradfg+0x9c4>
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1adf <dradfg+0x9bf>
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x90(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1ac9 <dradfg+0x9a9>
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1a94 <dradfg+0x974>
mov    -0xa8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xb0(%rbp)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    1979 <dradfg+0x859>
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1947 <dradfg+0x827>
jmp    1ace <dradfg+0x9ae>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    18ee <dradfg+0x7ce>
jmp    1ae4 <dradfg+0x9c4>
jmp    1ae9 <dradfg+0x9c9>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1b2a <dradfg+0xa0a>
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1af1 <dradfg+0x9d1>
movq   $0x0,-0x88(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1c6a <dradfg+0xb4a>
mov    -0x80(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x90(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
sub    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1c54 <dradfg+0xb34>
mov    -0x8(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1bb1 <dradfg+0xa91>
jmp    1c59 <dradfg+0xb39>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1b50 <dradfg+0xa30>
movsd  0x138e(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movq   $0x0,-0x88(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    20c7 <dradfg+0xfa7>
mov    -0x20(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x90(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x90(%rbp)
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x88(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xb8(%rbp)
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1e74 <dradfg+0xd54>
mov    0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb8(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa0(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0xa8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa8(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1db8 <dradfg+0xc98>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x140(%rbp),%rax
sub    $0x1,%rax
imul   -0x20(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x2,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    20b1 <dradfg+0xf91>
mov    -0x20(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0xa8(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x88(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    209b <dradfg+0xf7b>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xc0(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xc8(%rbp)
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb8(%rbp)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1fda <dradfg+0xeba>
jmp    20a0 <dradfg+0xf80>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1ede <dradfg+0xdbe>
jmp    20b6 <dradfg+0xf96>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1cbf <dradfg+0xb9f>
movq   $0x0,-0x88(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    2175 <dradfg+0x1055>
mov    -0x20(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    215f <dradfg+0x103f>
mov    0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x90(%rbp)
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    2110 <dradfg+0xff0>
jmp    2164 <dradfg+0x1044>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    20da <dradfg+0xfba>
mov    -0x8(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    2188 <dradfg+0x1068>
jmp    2270 <dradfg+0x1150>
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    226b <dradfg+0x114b>
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    2233 <dradfg+0x1113>
mov    0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0xa0(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    21d8 <dradfg+0x10b8>
mov    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xd0(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    21a6 <dradfg+0x1086>
jmp    2325 <dradfg+0x1205>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    2320 <dradfg+0x1200>
mov    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    230a <dradfg+0x11ea>
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xd0(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    22a4 <dradfg+0x1184>
jmp    230f <dradfg+0x11ef>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    2278 <dradfg+0x1158>
jmp    2325 <dradfg+0x1205>
movq   $0x0,-0x88(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x98(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    2493 <dradfg+0x1373>
mov    -0x90(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0xa0(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    247d <dradfg+0x135d>
mov    0x18(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    23e1 <dradfg+0x12c1>
jmp    2482 <dradfg+0x1362>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    2365 <dradfg+0x1245>
cmpq   $0x1,-0x8(%rbp)
jne    24a3 <dradfg+0x1383>
jmp    29d7 <dradfg+0x18b7>
mov    -0x108(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    24b9 <dradfg+0x1399>
jmp    275c <dradfg+0x163c>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x98(%rbp)
movq   $0x0,-0xa0(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    2757 <dradfg+0x1637>
mov    -0x90(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0xa8(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    2741 <dradfg+0x1621>
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    26e2 <dradfg+0x15c2>
mov    -0x138(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xb8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0xc0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
add    -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    25ac <dradfg+0x148c>
mov    -0xd0(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x8(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2596 <dradfg+0x1476>
jmp    2746 <dradfg+0x1626>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    24f7 <dradfg+0x13d7>
jmp    29d7 <dradfg+0x18b7>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x98(%rbp)
movq   $0x0,-0xa0(%rbp)
mov    -0x140(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    29d7 <dradfg+0x18b7>
mov    -0x90(%rbp),%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0xa8(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    29c1 <dradfg+0x18a1>
mov    -0x138(%rbp),%rax
add    -0x88(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x48(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x48(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x48(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    29ab <dradfg+0x188b>
mov    0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xb8(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd0(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x8(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2866 <dradfg+0x1746>
jmp    29b0 <dradfg+0x1890>
mov    -0x48(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
jmp    2801 <dradfg+0x16e1>
jmp    29c6 <dradfg+0x18a6>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    279a <dradfg+0x167a>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradfg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,(%rsp)
mov    %r8,0xe8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%rbp
cvtsi2sd %rsi,%xmm1
movsd  0x2ea8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x130(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mov    %rbx,0x38(%rsp)
lea    0x1(%rbx),%rax
sar    %rax
mov    %rax,0xb0(%rsp)
lea    -0x1(%rbp),%rax
sar    %rax
mov    %rax,0x118(%rsp)
mov    %r14,%rax
mov    %r14,0x18(%rsp)
imul   %rbp,%r14
mov    %r14,0xa0(%rsp)
mov    %rbp,%rax
mov    %rbp,0x8(%rsp)
cmp    $0x1,%rbp
jne    127c <dradfg+0x15c>
mov    0x30(%rsp),%rbp
test   %rbp,%rbp
mov    0x1b0(%rsp),%rbx
mov    0x1a0(%rsp),%rcx
movapd 0x130(%rsp),%xmm11
jle    1468 <dradfg+0x348>
cmp    $0x4,%rbp
jb     120c <dradfg+0xec>
lea    (%rbx,%rbp,8),%rax
cmp    %rcx,%rax
jbe    134c <dradfg+0x22c>
lea    (%rcx,%rbp,8),%rax
cmp    %rbx,%rax
jbe    134c <dradfg+0x22c>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdx
and    $0x3,%rdx
je     1234 <dradfg+0x114>
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1220 <dradfg+0x100>
cmp    $0x3,%rsi
jb     1468 <dradfg+0x348>
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1240 <dradfg+0x120>
jmp    1468 <dradfg+0x348>
mov    0x30(%rsp),%rbp
test   %rbp,%rbp
mov    0x18(%rsp),%r13
mov    0x8(%rsp),%r8
mov    0x1a8(%rsp),%r9
mov    0x1b0(%rsp),%rbx
mov    0x1a0(%rsp),%rcx
mov    (%rsp),%r12
jle    2f98 <dradfg+0x1e78>
cmp    $0x4,%rbp
jb     12d0 <dradfg+0x1b0>
lea    (%rcx,%rbp,8),%rax
cmp    %rbx,%rax
jbe    1376 <dradfg+0x256>
lea    (%rbx,%rbp,8),%rax
cmp    %rcx,%rax
jbe    1376 <dradfg+0x256>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdx
and    $0x3,%rdx
je     1304 <dradfg+0x1e4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12f0 <dradfg+0x1d0>
cmp    $0x3,%rsi
jb     2f98 <dradfg+0x1e78>
xchg   %ax,%ax
movsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  0x10(%rcx,%rax,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rax,8)
movsd  0x18(%rcx,%rax,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1310 <dradfg+0x1f0>
jmp    2f98 <dradfg+0x1e78>
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0xc,%rsi
jae    13a4 <dradfg+0x284>
xor    %esi,%esi
jmp    141c <dradfg+0x2fc>
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0xc,%rsi
jae    2ed6 <dradfg+0x1db6>
xor    %esi,%esi
jmp    2f4c <dradfg+0x1e2c>
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rsi,8),%xmm1
movups 0x10(%rbx,%rsi,8),%xmm2
movups %xmm1,(%rcx,%rsi,8)
movups %xmm2,0x10(%rcx,%rsi,8)
movups 0x20(%rbx,%rsi,8),%xmm1
movups 0x30(%rbx,%rsi,8),%xmm2
movups %xmm1,0x20(%rcx,%rsi,8)
movups %xmm2,0x30(%rcx,%rsi,8)
movups 0x40(%rbx,%rsi,8),%xmm1
movups 0x50(%rbx,%rsi,8),%xmm2
movups %xmm1,0x40(%rcx,%rsi,8)
movups %xmm2,0x50(%rcx,%rsi,8)
movupd 0x60(%rbx,%rsi,8),%xmm1
movupd 0x70(%rbx,%rsi,8),%xmm2
movupd %xmm1,0x60(%rcx,%rsi,8)
movupd %xmm2,0x70(%rcx,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    13c0 <dradfg+0x2a0>
test   %r8,%r8
je     145f <dradfg+0x33f>
lea    (%rcx,%rsi,8),%rdx
add    $0x10,%rdx
lea    (%rbx,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rdi,1),%xmm1
movupd (%rsi,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rdi,1)
movupd %xmm2,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1440 <dradfg+0x320>
cmp    %rbp,%rax
jne    120e <dradfg+0xee>
cmpq   $0x3,0x38(%rsp)
jl     2537 <dradfg+0x1417>
mov    0x30(%rsp),%r8
imul   0x38(%rsp),%r8
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%eax
mov    $0x2,%edx
cmovge %rcx,%rdx
mov    %rdx,0xe0(%rsp)
mov    0x18(%rsp),%r15
lea    -0x2(%r15),%rcx
mov    %rcx,0x128(%rsp)
mov    %rcx,%rsi
shr    %rsi
add    $0x1,%rsi
cmp    $0x1,%r15
setne  %cl
mov    0x8(%rsp),%r13
cmp    $0x1,%r13
sete   %bl
and    %cl,%bl
mov    %bl,0x98(%rsp)
mov    %r15,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xf0(%rsp)
imul   %r13,%rcx
mov    %rcx,0x108(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x110(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x100(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x50(%rsp)
lea    0x2(%r15),%rcx
imul   %r13,%rcx
mov    (%rsp),%r12
lea    (%r12,%rcx,8),%r9
mov    0xa0(%rsp),%r14
lea    0x0(,%r14,8),%rbp
mov    %r13,%rsi
shl    $0x5,%rsi
mov    %rsi,0x120(%rsp)
mov    0x1a8(%rsp),%rdx
lea    (%rdx,%rcx,8),%r11
sub    %r15,%rax
imul   %r13,%rax
add    %r8,%rax
mov    %rbp,0xd8(%rsp)
neg    %rbp
mov    %rbp,0xd0(%rsp)
lea    (%r12,%rax,8),%rsi
mov    %rdx,%rcx
lea    (%rdx,%rax,8),%rdi
mov    %r8,%rax
sub    %r14,%rax
lea    (%r12,%rax,8),%rbp
lea    (%rdx,%rax,8),%rbx
mov    %r13,%r10
shl    $0x4,%r10
lea    (%r15,%r15,1),%rdx
mov    %rdx,0xa8(%rsp)
lea    (%r12,%r14,8),%rdx
lea    (%rcx,%r14,8),%r13
lea    (%r12,%r10,1),%rax
mov    %rax,0xb8(%rsp)
mov    %r10,0x78(%rsp)
lea    (%rcx,%r10,1),%rax
mov    %rax,0xf8(%rsp)
mov    $0x1,%ecx
xor    %eax,%eax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    %r8,%rax
mov    %r8,0x20(%rsp)
mov    %r8,0x88(%rsp)
jmp    1656 <dradfg+0x536>
nopl   0x0(%rax)
mov    0x70(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0x80(%rsp)
mov    0xd8(%rsp),%rax
add    %rax,%r9
mov    0x10(%rsp),%r11
add    %rax,%r11
mov    0xd0(%rsp),%rdx
mov    0x28(%rsp),%rsi
add    %rdx,%rsi
mov    0x40(%rsp),%rdi
add    %rdx,%rdi
mov    0x58(%rsp),%rbp
add    %rdx,%rbp
mov    0x60(%rsp),%rbx
add    %rdx,%rbx
mov    0x68(%rsp),%rdx
add    %rax,%rdx
add    %rax,%r13
cmp    0xe0(%rsp),%rcx
je     1a4c <dradfg+0x92c>
mov    %rcx,0x70(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r11,0x10(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rsi,0x28(%rsp)
mov    0xa0(%rsp),%rax
add    %rax,0x90(%rsp)
sub    %rax,0x88(%rsp)
cmpq   $0x0,0x18(%rsp)
mov    0x78(%rsp),%rbp
jle    15f0 <dradfg+0x4d0>
mov    0x88(%rsp),%r15
mov    0x8(%rsp),%rax
sub    %rax,%r15
mov    0x90(%rsp),%r12
sub    %rax,%r12
cmpb   $0x0,0x98(%rsp)
mov    %r9,0x48(%rsp)
je     17d0 <dradfg+0x6b0>
mov    %r15,0xc8(%rsp)
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rax
imul   %rax,%rdx
lea    (%rdx,%rax,1),%rsi
mov    0xa8(%rsp),%rax
lea    (%rax,%rdx,1),%r8
mov    0x20(%rsp),%rax
mov    %rax,%rbx
sub    %rsi,%rbx
sub    %rdx,%rax
mov    (%rsp),%rdi
lea    (%rdi,%rsi,8),%rdx
lea    (%rdi,%r8,8),%rcx
lea    (%rdi,%rbx,8),%r14
lea    (%rdi,%rax,8),%r15
mov    0x1a8(%rsp),%r10
lea    (%r10,%rsi,8),%rsi
lea    (%r10,%r8,8),%rdi
lea    (%r10,%rax,8),%r11
cmp    %r15,%rdx
setb   %r9b
cmp    %rcx,%r14
setb   %r8b
cmp    %rdi,%rdx
setb   %al
cmp    %rcx,%rsi
setb   0xc0(%rsp)
cmp    %r11,%rdx
lea    (%r10,%rbx,8),%rdx
setb   %bl
cmp    %rcx,%rdx
setb   %r10b
cmp    %rdi,%r14
setb   %cl
cmp    %r15,%rsi
setb   %sil
cmp    %r11,%r14
setb   %dil
cmp    %r15,%rdx
setb   %r14b
test   %r8b,%r9b
jne    1a2d <dradfg+0x90d>
and    0xc0(%rsp),%al
mov    0xc8(%rsp),%r15
jne    1a16 <dradfg+0x8f6>
and    %r10b,%bl
jne    1a16 <dradfg+0x8f6>
and    %sil,%cl
jne    1a16 <dradfg+0x8f6>
and    %r14b,%dil
mov    0x48(%rsp),%r9
jne    17d0 <dradfg+0x6b0>
cmpq   $0x2,0x128(%rsp)
jae    17e5 <dradfg+0x6c5>
xor    %ebx,%ebx
jmp    1877 <dradfg+0x757>
cs nopw 0x0(%rax,%rax,1)
xor    %ebx,%ebx
testb  $0x1,0x18(%rsp)
jne    1910 <dradfg+0x7f0>
mov    %rbx,%rdx
jmp    1957 <dradfg+0x837>
mov    0x100(%rsp),%rdi
xor    %esi,%esi
xor    %ebx,%ebx
mov    0x120(%rsp),%r8
mov    0x28(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x58(%rsp),%rcx
mov    0x10(%rsp),%rax
mov    0x60(%rsp),%rdx
mov    0x68(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rsi,1),%xmm1
movupd (%rdx,%rsi,1),%xmm2
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rsi,1)
movupd 0x0(%r13,%rsi,1),%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rsi,1)
movupd (%rax,%rsi,1),%xmm1
movupd (%r11,%rsi,1),%xmm2
addpd  %xmm2,%xmm1
movupd %xmm1,(%r9,%rsi,1)
movupd (%rax,%rsi,1),%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,(%r10,%rsi,1)
add    $0x4,%rbx
add    %r8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1820 <dradfg+0x700>
testb  $0x1,0x110(%rsp)
01
je     18cc <dradfg+0x7ac>
imul   0x8(%rsp),%rbx
mov    0x90(%rsp),%rax
add    %rbx,%rax
add    0x88(%rsp),%rbx
mov    0x1a8(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movupd (%rcx,%rbx,8),%xmm2
addpd  %xmm2,%xmm1
mov    (%rsp),%rdx
movupd %xmm1,(%rdx,%rax,8)
movupd (%rcx,%rax,8),%xmm1
mov    0x48(%rsp),%r9
subpd  %xmm1,%xmm2
movupd %xmm2,(%rdx,%rbx,8)
mov    0xf0(%rsp),%rax
cmp    0x18(%rsp),%rax
mov    0x78(%rsp),%rbp
je     15f0 <dradfg+0x4d0>
mov    0x108(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
mov    0xf0(%rsp),%rbx
testb  $0x1,0x18(%rsp)
je     17dd <dradfg+0x6bd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
mov    0x1a8(%rsp),%rax
movsd  (%rax,%r12,8),%xmm1
addsd  (%rax,%r15,8),%xmm1
mov    (%rsp),%rcx
movsd  %xmm1,(%rcx,%r12,8)
movsd  (%rax,%r15,8),%xmm1
subsd  (%rax,%r12,8),%xmm1
movsd  %xmm1,(%rcx,%r15,8)
mov    0x48(%rsp),%r9
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
cmp    0x50(%rsp),%rbx
je     15f0 <dradfg+0x4d0>
mov    0x18(%rsp),%rbx
sub    %rdx,%rbx
mov    0xb8(%rsp),%r9
lea    (%r9,%r12,8),%rdi
mov    0xf8(%rsp),%rdx
lea    (%rdx,%r12,8),%r8
mov    0x8(%rsp),%rax
add    %rax,%r12
mov    (%rsp),%r10
lea    (%r10,%r12,8),%r14
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%r12,8),%rsi
lea    (%r9,%r15,8),%r12
lea    (%rdx,%r15,8),%rdx
add    %rax,%r15
lea    (%r10,%r15,8),%r10
lea    (%rcx,%r15,8),%r11
mov    0x48(%rsp),%r9
xor    %r15d,%r15d
nopl   0x0(%rax)
movsd  (%rsi,%r15,1),%xmm1
addsd  (%r11,%r15,1),%xmm1
movsd  %xmm1,(%r14,%r15,1)
movsd  (%r11,%r15,1),%xmm1
subsd  (%rsi,%r15,1),%xmm1
movsd  %xmm1,(%r10,%r15,1)
movsd  (%r8,%r15,1),%xmm1
addsd  (%rdx,%r15,1),%xmm1
movsd  %xmm1,(%rdi,%r15,1)
movsd  (%rdx,%r15,1),%xmm1
subsd  (%r8,%r15,1),%xmm1
movsd  %xmm1,(%r12,%r15,1)
add    %rbp,%r15
add    $0xfffffffffffffffe,%rbx
jne    19c0 <dradfg+0x8a0>
jmp    15f0 <dradfg+0x4d0>
xor    %ebx,%ebx
mov    0x48(%rsp),%r9
testb  $0x1,0x18(%rsp)
jne    1910 <dradfg+0x7f0>
jmp    17dd <dradfg+0x6bd>
xor    %ebx,%ebx
mov    0x48(%rsp),%r9
mov    0xc8(%rsp),%r15
testb  $0x1,0x18(%rsp)
je     17dd <dradfg+0x6bd>
jmp    1910 <dradfg+0x7f0>
cmpq   $0x3,0x38(%rsp)
jl     2537 <dradfg+0x1417>
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%rdx
mov    0x30(%rsp),%r15
imul   %r15,%rdx
movapd 0x259d(%rip),%xmm10
xorpd  %xmm0,%xmm10
mov    0xb0(%rsp),%rcx
cmp    $0x4,%rcx
mov    $0x3,%esi
cmovge %rcx,%rsi
mov    %rsi,0x58(%rsp)
cmp    $0x3,%rcx
mov    $0x2,%esi
cmovge %rcx,%rsi
mov    %rsi,0x128(%rsp)
lea    (%r15,%r15,1),%rcx
mov    %rcx,0x80(%rsp)
lea    (%r15,%r15,2),%rcx
mov    %rcx,0xe0(%rsp)
lea    -0x2(%rax),%rsi
imul   %r15,%rsi
lea    -0x8(,%rax,8),%rax
ff
imul   %r15,%rax
mov    %rax,0xd0(%rsp)
mov    0x1a0(%rsp),%rcx
lea    (%rcx,%r15,8),%rax
mov    %rax,0x108(%rsp)
mov    %r15,%rax
shl    $0x4,%rax
add    %rcx,%rax
mov    %rax,0x110(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm9
lea    -0x2(%r15),%rax
mov    %rax,0x160(%rsp)
mov    %rax,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %r15,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %rdi,%rax
mov    %rdi,0x158(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x150(%rsp)
lea    0x0(,%r15,8),%rax
mov    %rax,0x28(%rsp)
neg    %rax
mov    %rax,0x40(%rsp)
movsd  0x24ac(%rip),%xmm5
movapd 0x24ab(%rip),%xmm8
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x100(%rsp)
mov    0x20(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x120(%rsp)
lea    0x0(%rbp,%r15,1),%rax
mov    %rax,0x148(%rsp)
mov    %rbp,0x98(%rsp)
lea    (%rdx,%rbp,1),%rax
mov    %rax,0x140(%rsp)
mov    0x1b0(%rsp),%rax
lea    0x10(%rax,%r15,8),%rdi
lea    0x10(%rax,%rdx,8),%rbp
lea    (%rax,%r15,8),%r9
mov    %rdx,0x50(%rsp)
lea    (%rax,%rdx,8),%r8
mov    %rsi,0xd8(%rsp)
lea    (%rcx,%rsi,8),%rax
mov    %rax,0x130(%rsp)
mov    $0x1,%edx
xor    %esi,%esi
xor    %eax,%eax
mov    %rax,0x10(%rsp)
jmp    1c3c <dradfg+0xb1c>
cs nopw 0x0(%rax,%rax,1)
mov    0xf8(%rsp),%rdx
add    $0x1,%rdx
mov    0xf0(%rsp),%rsi
add    $0x1,%rsi
mov    0x28(%rsp),%rax
mov    0xa8(%rsp),%rdi
add    %rax,%rdi
mov    0x40(%rsp),%rcx
mov    0xb8(%rsp),%rbp
add    %rcx,%rbp
add    %rax,%r9
add    %rcx,%r8
cmp    0x128(%rsp),%rdx
je     22cf <dradfg+0x11af>
mov    %rdx,0xf8(%rsp)
mov    %rbp,0xb8(%rsp)
mov    %rdi,0xa8(%rsp)
mov    0x80(%rsp),%rax
mov    0x10(%rsp),%rbp
add    %rbp,%rax
add    %r15,%rbp
mov    %rsi,0xf0(%rsp)
mov    %rsi,%rcx
imul   %r15,%rcx
mov    0x50(%rsp),%rdx
sub    %rcx,%rdx
mov    0x1b0(%rsp),%r11
mov    0x20(%rsp),%rcx
lea    (%r11,%rcx,8),%rsi
mov    %rsi,0x70(%rsp)
sub    %r15,%rcx
mov    %rcx,0x20(%rsp)
mov    %rbp,0x10(%rsp)
lea    (%r11,%rbp,8),%rcx
mov    %rcx,0x90(%rsp)
lea    (%r11,%rax,8),%rax
mov    %rax,0x88(%rsp)
lea    (%r11,%rdx,8),%rax
mov    %rax,0x48(%rsp)
movapd %xmm5,%xmm2
unpckhpd %xmm9,%xmm2
movapd %xmm10,%xmm3
unpcklpd %xmm5,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm11,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm5,%xmm4
unpckhpd %xmm5,%xmm4
test   %r15,%r15
mov    0x1a0(%rsp),%rbx
jle    1d5b <dradfg+0xc3b>
cmp    $0x1,%r15
jne    2050 <dradfg+0xf30>
xor    %eax,%eax
mov    0x10(%rsp),%r10
mov    %r15,%rsi
mov    0x50(%rsp),%r14
mov    0x20(%rsp),%rdx
mov    %r15,%rcx
sub    %rax,%rcx
lea    (%rbx,%rax,8),%rax
lea    (%r11,%r10,8),%rbp
lea    (%rbx,%rsi,8),%rsi
lea    (%rbx,%r14,8),%rbx
lea    (%r11,%rdx,8),%rdx
xor    %edi,%edi
movsd  (%rsi,%rdi,8),%xmm2
mulsd  %xmm5,%xmm2
addsd  (%rax,%rdi,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rdi,8)
movsd  (%rbx,%rdi,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,(%rdx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1d30 <dradfg+0xc10>
cmpq   $0x5,0x38(%rsp)
jb     1bf0 <dradfg+0xad0>
xorpd  %xmm8,%xmm4
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
mov    0x90(%rsp),%rax
cmp    0x70(%rsp),%rax
setb   %al
mov    0x48(%rsp),%rcx
cmp    0x88(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0x78(%rsp)
mov    0x20(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xc8(%rsp)
mov    0x10(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xc0(%rsp)
mov    $0x2,%r14d
mov    0x130(%rsp),%r11
mov    0x110(%rsp),%rax
xor    %r10d,%r10d
mov    %r15,%r12
mov    0x50(%rsp),%rcx
mov    %rcx,(%rsp)
movapd %xmm5,%xmm2
jmp    1e12 <dradfg+0xcf2>
nopl   (%rax)
add    $0x1,%r14
add    $0x1,%r10
add    0x28(%rsp),%rax
add    0x40(%rsp),%r11
cmp    0x58(%rsp),%r14
mov    0x30(%rsp),%r15
je     1bf0 <dradfg+0xad0>
add    %r15,%r12
sub    %r15,(%rsp)
movapd %xmm2,%xmm6
unpckhpd %xmm5,%xmm6
movapd %xmm4,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm6,%xmm7
mulpd  %xmm3,%xmm2
addpd  %xmm7,%xmm2
test   %r15,%r15
jle    1df0 <dradfg+0xcd0>
movapd %xmm2,%xmm7
unpckhpd %xmm2,%xmm7
mov    0x30(%rsp),%rdx
cmp    $0x1,%rdx
jne    1ed0 <dradfg+0xdb0>
xor    %r13d,%r13d
mov    (%rsp),%rsi
mov    %r12,%rbx
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r15
mov    0x30(%rsp),%rbp
sub    %r13,%rbp
mov    0x1a0(%rsp),%rdx
lea    (%rdx,%rsi,8),%rsi
lea    (%rdx,%rbx,8),%rbx
mov    0x1b0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rdx,%r15,8),%rdx
xor    %edi,%edi
nop
movsd  (%rbx,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
movsd  (%rsi,%rdi,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1e90 <dradfg+0xd70>
jmp    1df0 <dradfg+0xcd0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,0x60(%rsp)
mov    %r10,%rcx
imul   %rdx,%rcx
mov    0x80(%rsp),%rdx
add    %rcx,%rdx
mov    0xe0(%rsp),%rsi
lea    (%rsi,%rcx,1),%rbx
mov    0xd8(%rsp),%rdi
sub    %rcx,%rdi
shl    $0x3,%rcx
mov    0x1a0(%rsp),%rsi
mov    %rsi,%rbp
sub    %rcx,%rbp
add    0xd0(%rsp),%rbp
lea    (%rsi,%rdx,8),%rdx
lea    (%rsi,%rbx,8),%r12
lea    (%rsi,%rdi,8),%rdi
mov    0x90(%rsp),%rsi
cmp    %r12,%rsi
setb   %r15b
mov    0x88(%rsp),%rbx
cmp    %rbx,%rdx
setb   %cl
and    %r15b,%cl
or     0x78(%rsp),%cl
cmp    %rsi,%rbp
seta   %r13b
cmp    %rbx,%rdi
setb   %sil
mov    0x48(%rsp),%r15
cmp    %r12,%r15
setb   %bl
mov    0x70(%rsp),%r12
cmp    %r12,%rdx
setb   0x68(%rsp)
cmp    %r15,%rbp
seta   %dl
cmp    %r12,%rdi
setb   %dil
test   %cl,%cl
jne    203f <dradfg+0xf1f>
and    %sil,%r13b
mov    0x60(%rsp),%r12
jne    1e51 <dradfg+0xd31>
and    0x68(%rsp),%bl
jne    1e51 <dradfg+0xd31>
mov    $0x0,%r13d
mov    (%rsp),%rsi
mov    %r12,%rbx
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r15
and    %dil,%dl
jne    1e65 <dradfg+0xd45>
mov    0x98(%rsp),%rdx
mov    (%rsp),%rcx
lea    (%rcx,%rdx,1),%rsi
lea    (%r12,%rdx,1),%rbx
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%rax,%rcx,8),%xmm0
mulpd  %xmm6,%xmm0
movupd (%r9,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r9,%rcx,8)
movupd (%r11,%rcx,8),%xmm0
movupd (%r8,%rcx,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1fe0 <dradfg+0xec0>
mov    %rdx,%r13
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%r15
cmp    0x30(%rsp),%rdx
je     1df0 <dradfg+0xcd0>
jmp    1e65 <dradfg+0xd45>
xor    %r13d,%r13d
mov    (%rsp),%rsi
mov    0x60(%rsp),%r12
jmp    1e58 <dradfg+0xd38>
mov    0x70(%rsp),%r15
mov    0x90(%rsp),%rcx
cmp    %r15,%rcx
setb   (%rsp)
mov    0x88(%rsp),%rsi
mov    0x48(%rsp),%rax
cmp    %rsi,%rax
setb   %r14b
mov    0x108(%rsp),%rbp
cmp    %rbp,%rcx
setb   %r10b
cmp    %rbx,%rsi
seta   0x60(%rsp)
mov    0x110(%rsp),%rdi
cmp    %rdi,%rcx
setb   %r13b
cmp    %rsi,%rbp
setb   0x68(%rsp)
mov    0x120(%rsp),%rdx
cmp    %rdx,%rcx
setb   %cl
mov    0x100(%rsp),%r12
cmp    %rsi,%r12
setb   0x78(%rsp)
cmp    %rbp,%rax
setb   %sil
cmp    %rbx,%r15
seta   %bl
cmp    %rdi,%rax
setb   %dil
cmp    %r15,%rbp
setb   %bpl
cmp    %rdx,%rax
setb   %r11b
cmp    %r15,%r12
setb   %r12b
test   %r14b,(%rsp)
jne    22a1 <dradfg+0x1181>
and    0x60(%rsp),%r10b
jne    22a1 <dradfg+0x1181>
and    0x68(%rsp),%r13b
jne    22a1 <dradfg+0x1181>
and    0x78(%rsp),%cl
jne    22a1 <dradfg+0x1181>
and    %bl,%sil
mov    0x30(%rsp),%r15
jne    2298 <dradfg+0x1178>
and    %bpl,%dil
jne    2298 <dradfg+0x1178>
mov    $0x0,%eax
mov    0x10(%rsp),%r10
mov    %r15,%rsi
mov    0x50(%rsp),%r14
mov    0x20(%rsp),%rdx
and    %r12b,%r11b
mov    0x1b0(%rsp),%r11
mov    0x1a0(%rsp),%rbx
jne    1d14 <dradfg+0xbf4>
movapd %xmm5,%xmm2
unpcklpd %xmm5,%xmm2
cmpq   $0x2,0x160(%rsp)
mov    0xa8(%rsp),%rbp
mov    0xb8(%rsp),%rdi
jae    2188 <dradfg+0x1068>
xor    %eax,%eax
jmp    220a <dradfg+0x10ea>
mov    0x150(%rsp),%rsi
xor    %eax,%eax
mov    0x108(%rsp),%rcx
mov    0x100(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm3
movupd (%rcx,%rax,8),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%rbp,%rax,8)
movupd (%rdx,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rdi,%rax,8)
movupd 0x10(%rbx,%rax,8),%xmm3
movupd 0x10(%rcx,%rax,8),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,0x0(%rbp,%rax,8)
movupd 0x10(%rdx,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%rdi,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rsi
jne    21b0 <dradfg+0x1090>
testb  $0x1,0x158(%rsp)
01
je     2258 <dradfg+0x1138>
mov    0x10(%rsp),%rcx
add    %rax,%rcx
lea    (%rax,%r15,1),%rdx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rax,1),%rsi
mov    0x20(%rsp),%rbp
add    %rax,%rbp
movupd (%rbx,%rax,8),%xmm3
movupd (%rbx,%rdx,8),%xmm6
mulpd  %xmm6,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%r11,%rcx,8)
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm4,%xmm2
movupd %xmm2,(%r11,%rbp,8)
cmp    %r15,0x98(%rsp)
je     1d5b <dradfg+0xc3b>
mov    0x98(%rsp),%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rcx,1),%r10
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
mov    %rcx,%rax
mov    0x148(%rsp),%rsi
mov    0x140(%rsp),%r14
jmp    1d14 <dradfg+0xbf4>
xor    %eax,%eax
mov    0x10(%rsp),%r10
jmp    22ad <dradfg+0x118d>
xor    %eax,%eax
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%r15
mov    %r15,%rsi
mov    0x50(%rsp),%r14
mov    0x20(%rsp),%rdx
mov    0x1b0(%rsp),%r11
mov    0x1a0(%rsp),%rbx
jmp    1d14 <dradfg+0xbf4>
cmpq   $0x3,0x38(%rsp)
jl     2537 <dradfg+0x1417>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%eax
cmovge %rcx,%rax
mov    0x30(%rsp),%rcx
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%rcx,8),%r10
lea    -0x4(%rcx),%r9
mov    %r9,%r15
shr    $0x2,%r15
add    $0x1,%r15
mov    %rcx,%r12
and    $0xfffffffffffffffc,%r12
mov    %r15,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,(%rsp)
mov    %rcx,%r13
neg    %r13
mov    0x1a0(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdx
add    $0x30,%rdx
lea    0x8(%rsi),%r11
lea    0x8(%rdi),%r14
mov    $0x1,%ecx
xor    %esi,%esi
jmp    2362 <dradfg+0x1242>
nopl   0x0(%rax)
add    $0x1,%rcx
add    0x28(%rsp),%rdx
cmp    %rax,%rcx
je     2537 <dradfg+0x1417>
mov    %rsi,%rdi
mov    0x30(%rsp),%rbp
add    %rbp,%rsi
test   %rbp,%rbp
jle    2350 <dradfg+0x1230>
cmpq   $0x4,0x30(%rsp)
jb     23af <dradfg+0x128f>
add    0x80(%rsp),%rdi
mov    0x1a0(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
cmp    0x1b0(%rsp),%rdi
jbe    23c7 <dradfg+0x12a7>
lea    0x0(,%rsi,8),%rdi
add    %rbp,%rdi
cmp    %r10,%rdi
jae    23c7 <dradfg+0x12a7>
xor    %edi,%edi
mov    %rsi,%rbx
testb  $0x1,0x30(%rsp)
jne    24b0 <dradfg+0x1390>
mov    %rdi,%rbp
jmp    24dd <dradfg+0x13bd>
cmp    $0x4,%r9
jae    23d1 <dradfg+0x12b1>
xor    %ebx,%ebx
jmp    2441 <dradfg+0x1321>
mov    (%rsp),%rdi
xor    %ebx,%ebx
mov    0x1b0(%rsp),%rbp
nop
movupd -0x30(%rdx,%rbx,8),%xmm0
movupd -0x20(%rdx,%rbx,8),%xmm1
movupd 0x0(%rbp,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rbp,%rbx,8),%xmm1
movupd 0x30(%rbp,%rbx,8),%xmm3
movupd %xmm2,0x0(%rbp,%rbx,8)
movupd %xmm0,0x10(%rbp,%rbx,8)
movupd -0x10(%rdx,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%rbx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rbp,%rbx,8)
movupd %xmm1,0x30(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    23e0 <dradfg+0x12c0>
test   $0x1,%r15b
je     2485 <dradfg+0x1365>
lea    (%rsi,%rbx,1),%rdi
mov    0x1a0(%rsp),%rbp
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x10(%rbp,%rdi,8),%xmm1
mov    0x1b0(%rsp),%rdi
movupd (%rdi,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm0,0x10(%rdi,%rbx,8)
cmp    0x30(%rsp),%r12
je     2350 <dradfg+0x1230>
lea    (%rsi,%r12,1),%rbx
mov    %r12,%rdi
testb  $0x1,0x30(%rsp)
je     23bf <dradfg+0x129f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x1a0(%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
add    $0x1,%rbx
mov    0x1b0(%rsp),%rbp
addsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
mov    %rdi,%rbp
or     $0x1,%rbp
not    %rdi
cmp    %r13,%rdi
je     2350 <dradfg+0x1230>
mov    0x30(%rsp),%rdi
sub    %rbp,%rdi
lea    (%r11,%rbp,8),%rbp
lea    (%r14,%rbx,8),%rbx
xor    %r8d,%r8d
nopl   0x0(%rax)
movsd  -0x8(%rbx,%r8,8),%xmm0
addsd  -0x8(%rbp,%r8,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%r8,8)
movsd  (%rbx,%r8,8),%xmm0
addsd  0x0(%rbp,%r8,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r8,8)
add    $0x2,%r8
cmp    %r8,%rdi
jne    2500 <dradfg+0x13e0>
jmp    2350 <dradfg+0x1230>
mov    0x38(%rsp),%rax
mov    0x8(%rsp),%r14
imul   %r14,%rax
mov    %rax,0x30(%rsp)
mov    0x18(%rsp),%rax
cmp    %rax,%r14
mov    0xe8(%rsp),%r10
jge    2789 <dradfg+0x1669>
test   %r14,%r14
mov    0x1a8(%rsp),%r12
jle    29d8 <dradfg+0x18b8>
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x20(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x58(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
mov    %r14,%r15
shl    $0x5,%r15
lea    (%r14,%r14,2),%rax
lea    (%r12,%rax,8),%rax
mov    %rax,0x70(%rsp)
mov    %r14,%rax
shl    $0x4,%rax
add    %r12,%rax
mov    %rax,0x90(%rsp)
lea    (%r12,%r14,8),%rax
mov    %rax,0x88(%rsp)
mov    0x30(%rsp),%rcx
mov    %rcx,%r11
shl    $0x5,%r11
lea    (%rcx,%rcx,2),%rax
lea    (%r10,%rax,8),%rax
mov    %rax,0x48(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
add    %r10,%rax
mov    %rax,0x80(%rsp)
lea    (%r10,%rcx,8),%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%r14,8),%rbp
lea    0x0(,%rcx,8),%rbx
xor    %r8d,%r8d
xor    %edi,%edi
mov    %rbp,0x10(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r11,(%rsp)
mov    %r15,0x28(%rsp)
jmp    2641 <dradfg+0x1521>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
add    $0x8,%r8
cmp    %r14,%rdi
je     29d8 <dradfg+0x18b8>
cmpq   $0x0,0x18(%rsp)
jle    2630 <dradfg+0x1510>
mov    %rdi,%r9
mov    %rdi,0x40(%rsp)
mov    %rdi,%r10
cmpq   $0x3,0x20(%rsp)
mov    %r14,%rsi
mov    0x30(%rsp),%rdi
jb     272d <dradfg+0x160d>
mov    0x68(%rsp),%r11
mov    0x78(%rsp),%r15
mov    0x80(%rsp),%r13
mov    0x48(%rsp),%rax
mov    0xe8(%rsp),%rcx
mov    0x88(%rsp),%r14
mov    0x90(%rsp),%rbp
mov    0x70(%rsp),%rdx
mov    0x1a8(%rsp),%rbx
mov    0x40(%rsp),%r10
mov    %r10,%r9
nopl   0x0(%rax)
movsd  (%rbx,%r8,1),%xmm0
movsd  %xmm0,(%rcx,%r8,1)
add    %rsi,%r9
add    %rdi,%r10
movsd  (%r14,%r8,1),%xmm0
movsd  %xmm0,(%r15,%r8,1)
add    %rsi,%r9
add    %rdi,%r10
movsd  0x0(%rbp,%r8,1),%xmm0
movsd  %xmm0,0x0(%r13,%r8,1)
add    %rsi,%r9
add    %rdi,%r10
movsd  (%rdx,%r8,1),%xmm0
movsd  %xmm0,(%rax,%r8,1)
add    %rsi,%r9
add    %rdi,%r10
mov    %rdi,%r12
mov    %rsi,%rdi
mov    0x28(%rsp),%rsi
add    %rsi,%rbx
add    %rsi,%rdx
add    %rsi,%rbp
add    %rsi,%r14
mov    %rdi,%rsi
mov    %r12,%rdi
mov    (%rsp),%r12
add    %r12,%rcx
add    %r12,%rax
add    %r12,%r13
add    %r12,%r15
add    $0xfffffffffffffffc,%r11
jne    26b0 <dradfg+0x1590>
cmpq   $0x0,0x58(%rsp)
mov    %rsi,%r14
mov    0x1a8(%rsp),%r12
mov    0xe8(%rsp),%rcx
mov    0x10(%rsp),%rbp
mov    0x60(%rsp),%rbx
mov    0x40(%rsp),%rdi
je     2630 <dradfg+0x1510>
lea    (%r12,%r9,8),%rax
lea    (%rcx,%r10,8),%rcx
mov    0x58(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rcx)
add    %rbp,%rax
add    %rbx,%rcx
add    $0xffffffffffffffff,%rdx
jne    2770 <dradfg+0x1650>
jmp    2630 <dradfg+0x1510>
test   %rax,%rax
mov    0x1a8(%rsp),%r12
jle    29d8 <dradfg+0x18b8>
lea    -0x4(%r14),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r14,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
mov    %rcx,%rax
mov    %rcx,0x68(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
mov    %r14d,%ebp
and    $0x3,%ebp
lea    0x30(%r12),%rdi
lea    0x0(,%r14,8),%r13
lea    0x30(%r10),%rcx
mov    0x30(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x28(%rsp)
mov    %rbp,0x40(%rsp)
neg    %rbp
lea    0x18(%r12),%rax
mov    %rax,0x58(%rsp)
lea    0x18(%r10),%rax
mov    %rax,0x20(%rsp)
xor    %r15d,%r15d
xor    %eax,%eax
mov    %rax,(%rsp)
xor    %r8d,%r8d
jmp    283c <dradfg+0x171c>
nopl   (%rax)
add    0x30(%rsp),%r8
add    $0x1,%r15
add    %r13,%rdi
add    0x28(%rsp),%rcx
cmp    0x18(%rsp),%r15
je     29d8 <dradfg+0x18b8>
mov    (%rsp),%r9
lea    (%r9,%r14,1),%rax
mov    %rax,(%rsp)
test   %r14,%r14
jle    2820 <dradfg+0x1700>
cmp    $0x4,%r14
jb     287d <dradfg+0x175d>
lea    (%r10,%r8,8),%rax
mov    (%rsp),%rdx
lea    (%r12,%rdx,8),%rdx
cmp    %rdx,%rax
jae    294c <dradfg+0x182c>
lea    (%r8,%r14,1),%rax
lea    (%r10,%rax,8),%rax
lea    (%r12,%r9,8),%rdx
cmp    %rax,%rdx
jae    294c <dradfg+0x182c>
xor    %r11d,%r11d
mov    %r8,%rsi
mov    %r11,%rbx
not    %rbx
add    %r14,%rbx
cmpq   $0x0,0x40(%rsp)
je     28e5 <dradfg+0x17c5>
mov    %r13,%rax
lea    (%r12,%r9,8),%r14
lea    (%r10,%rsi,8),%r13
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14),%xmm0
movsd  %xmm0,0x0(%r13)
add    $0xffffffffffffffff,%r10
add    $0x8,%r14
add    $0x8,%r13
cmp    %r10,%rbp
jne    28b0 <dradfg+0x1790>
sub    %r10,%r11
sub    %r10,%r9
sub    %r10,%rsi
mov    0x8(%rsp),%r14
mov    0xe8(%rsp),%r10
mov    %rax,%r13
cmp    $0x3,%rbx
jb     2820 <dradfg+0x1700>
mov    %r14,%rbx
sub    %r11,%rbx
mov    0x58(%rsp),%rax
lea    (%rax,%r9,8),%rdx
mov    0x20(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movsd  -0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rsi,%rax,8)
movsd  -0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    2910 <dradfg+0x17f0>
jmp    2820 <dradfg+0x1700>
cmpq   $0x4,0x60(%rsp)
jae    2958 <dradfg+0x1838>
xor    %esi,%esi
jmp    2994 <dradfg+0x1874>
mov    0x70(%rsp),%rbx
xor    %esi,%esi
nop
movups -0x30(%rdi,%rsi,8),%xmm0
movups -0x20(%rdi,%rsi,8),%xmm1
movups %xmm0,-0x30(%rcx,%rsi,8)
movups %xmm1,-0x20(%rcx,%rsi,8)
movupd -0x10(%rdi,%rsi,8),%xmm0
movupd (%rdi,%rsi,8),%xmm1
movupd %xmm0,-0x10(%rcx,%rsi,8)
movupd %xmm1,(%rcx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbx
jne    2960 <dradfg+0x1840>
testb  $0x1,0x68(%rsp)
je     29bc <dradfg+0x189c>
lea    (%r9,%rsi,1),%rax
add    %r8,%rsi
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
movupd %xmm0,(%r10,%rsi,8)
movupd %xmm1,0x10(%r10,%rsi,8)
cmp    %r14,0x10(%rsp)
je     2820 <dradfg+0x1700>
mov    0x10(%rsp),%r11
add    %r11,%r9
lea    (%r8,%r11,1),%rsi
jmp    2883 <dradfg+0x1763>
lea    (%r14,%r14,1),%rax
cmpq   $0x3,0x38(%rsp)
mov    0xa0(%rsp),%r15
jl     2bf9 <dradfg+0x1ad9>
mov    %r15,%rcx
mov    0x38(%rsp),%r11
imul   %r11,%rcx
mov    %rcx,(%rsp)
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%r12d
cmovge %rcx,%r12
mov    0x18(%rsp),%rsi
mov    %rsi,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
lea    -0x1(%r11),%rcx
mov    %r15,%rbx
imul   %rcx,%rbx
mov    0x1a8(%rsp),%rbp
lea    0x0(,%rbx,8),%rdi
add    %rbp,%rdi
lea    0x0(,%r15,8),%rdx
mov    %rdx,0x20(%rsp)
neg    %rdx
mov    %rdx,0x10(%rsp)
neg    %rbx
mov    %rbx,0x58(%rsp)
imul   %rsi,%rcx
add    $0x1,%rcx
mov    0x8(%rsp),%r8
imul   %r8,%rcx
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
lea    0x0(,%r15,8),%rcx
add    %rbp,%rcx
mov    %r15,%r13
neg    %r13
add    $0x1,%rsi
imul   %r8,%rsi
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
mov    0xe8(%rsp),%r10
lea    (%r10,%rax,8),%rbp
mov    %r8,%rbx
shl    $0x4,%rbx
mov    %rbx,0x60(%rsp)
mov    %rax,%r9
neg    %r9
lea    0x2(%r11),%rbx
imul   %r8,%rbx
lea    (%r10,%rbx,8),%r10
mov    0x30(%rsp),%rbx
lea    (%rbx,%rbx,1),%r11
mov    $0x1,%r8d
xor    %ebx,%ebx
mov    %rbx,0x28(%rsp)
xor    %ebx,%ebx
mov    %rbx,0x40(%rsp)
mov    %r12,0x68(%rsp)
jmp    2b31 <dradfg+0x1a11>
add    $0x1,%r8
mov    0x10(%rsp),%rbx
add    %rbx,%rdi
mov    0xa0(%rsp),%r15
add    %r15,0x58(%rsp)
add    %rbx,%rdx
mov    0x20(%rsp),%rbx
add    %rbx,%rcx
sub    %r15,%r13
add    %rbx,%rsi
mov    0x60(%rsp),%rbx
add    %rbx,%rbp
sub    %rax,%r9
add    %rbx,%r10
cmp    %r12,%r8
je     2bf9 <dradfg+0x1ad9>
add    %rax,0x28(%rsp)
add    %r15,0x40(%rsp)
sub    %r15,(%rsp)
cmpq   $0x0,0x18(%rsp)
jle    2af0 <dradfg+0x19d0>
mov    (%rsp),%r15
mov    0x40(%rsp),%r14
mov    0x28(%rsp),%rbx
cmpq   $0x1,0x18(%rsp)
je     2bbb <dradfg+0x1a9b>
mov    0x70(%rsp),%r15
xor    %ebx,%ebx
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%r14,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rbx,8)
movsd  (%rdi,%r14,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rsi,%r14,8),%xmm0
movsd  %xmm0,-0x8(%r10,%rbx,8)
movsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,(%r10,%rbx,8)
add    %rax,%r14
add    %r11,%rbx
add    $0xfffffffffffffffe,%r15
jne    2b70 <dradfg+0x1a50>
mov    %r14,%r15
sub    0x58(%rsp),%r15
sub    %r13,%r14
sub    %r9,%rbx
testb  $0x1,0x18(%rsp)
je     2af0 <dradfg+0x19d0>
mov    0x1a8(%rsp),%r12
movsd  (%r12,%r14,8),%xmm0
mov    0xe8(%rsp),%r14
movsd  %xmm0,-0x8(%r14,%rbx,8)
movsd  (%r12,%r15,8),%xmm0
mov    0x68(%rsp),%r12
movsd  %xmm0,(%r14,%rbx,8)
jmp    2af0 <dradfg+0x19d0>
cmpq   $0x1,0x8(%rsp)
mov    0xe8(%rsp),%rdx
mov    0x1a8(%rsp),%rsi
jne    2c23 <dradfg+0x1b03>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x118(%rsp),%rcx
cmp    0x18(%rsp),%rcx
jge    2d9f <dradfg+0x1c7f>
cmpq   $0x3,0x38(%rsp)
jl     2c11 <dradfg+0x1af1>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%edi
cmovge %rcx,%rdi
mov    %rdi,(%rsp)
mov    0x38(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
imul   %r15,%rcx
lea    (%rsi,%rcx,8),%r8
lea    0x0(,%r15,8),%rcx
mov    %rcx,0x28(%rsp)
neg    %rcx
mov    %rcx,0x40(%rsp)
mov    0x8(%rsp),%rcx
lea    0x0(,%rcx,8),%rbp
lea    (%rsi,%r15,8),%r15
lea    (%rdx,%rax,8),%r13
add    $0x10,%r13
shl    $0x4,%rcx
mov    %rcx,0x58(%rsp)
shlq   $0x3,0x30(%rsp)
lea    (%rdx,%rax,8),%r12
add    $0xfffffffffffffff0,%r12
mov    $0x1,%edi
mov    0x30(%rsp),%rdx
jmp    2ce3 <dradfg+0x1bc3>
nopl   0x0(%rax)
add    $0x1,%rdi
add    0x40(%rsp),%r8
add    0x28(%rsp),%r15
mov    0x58(%rsp),%rax
add    %rax,%r13
add    %rax,%r12
cmp    (%rsp),%rdi
je     2c11 <dradfg+0x1af1>
cmpq   $0x3,0x8(%rsp)
jl     2cc0 <dradfg+0x1ba0>
mov    $0x2,%ebx
mov    %r12,%rax
mov    %r13,%rsi
mov    %r15,%rcx
mov    %r8,%r14
jmp    2d1b <dradfg+0x1bfb>
xchg   %ax,%ax
add    $0x2,%rbx
add    $0x10,%r14
add    $0x10,%rcx
add    $0x10,%rsi
add    $0xfffffffffffffff0,%rax
cmp    0x8(%rsp),%rbx
jge    2cc0 <dradfg+0x1ba0>
cmpq   $0x0,0x18(%rsp)
jle    2d00 <dradfg+0x1be0>
mov    $0x10,%r9d
xor    %r10d,%r10d
mov    0x18(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%r9,1),%xmm0
addsd  -0x8(%r14,%r9,1),%xmm0
movsd  %xmm0,-0x8(%rsi,%r10,1)
movsd  -0x8(%rcx,%r9,1),%xmm0
subsd  -0x8(%r14,%r9,1),%xmm0
movsd  %xmm0,-0x8(%rax,%r10,1)
movsd  (%rcx,%r9,1),%xmm0
addsd  (%r14,%r9,1),%xmm0
movsd  %xmm0,(%rsi,%r10,1)
movsd  (%r14,%r9,1),%xmm0
subsd  (%rcx,%r9,1),%xmm0
movsd  %xmm0,(%rax,%r10,1)
add    %rbp,%r9
add    %rdx,%r10
add    $0xffffffffffffffff,%r11
jne    2d40 <dradfg+0x1c20>
jmp    2d00 <dradfg+0x1be0>
cmpq   $0x3,0x38(%rsp)
jl     2c11 <dradfg+0x1af1>
mov    0xb0(%rsp),%rcx
cmp    $0x3,%rcx
mov    $0x2,%edi
cmovge %rcx,%rdi
mov    %rdi,(%rsp)
lea    (%rdx,%rax,8),%r14
mov    0x8(%rsp),%rax
mov    %rax,%r9
shl    $0x4,%r9
shlq   $0x3,0x30(%rsp)
mov    0x38(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
imul   %r15,%rcx
mov    %r15,%rdx
lea    (%rsi,%rcx,8),%r15
lea    0x0(,%rdx,8),%r10
mov    %r10,%r11
neg    %r11
lea    0x0(,%rax,8),%rcx
lea    (%rsi,%rdx,8),%r13
mov    $0x1,%r12d
mov    0x8(%rsp),%rbp
jmp    2e37 <dradfg+0x1d17>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
add    %r9,%r14
add    %r11,%r15
add    %r10,%r13
cmp    (%rsp),%r12
je     2c11 <dradfg+0x1af1>
cmpq   $0x0,0x18(%rsp)
jle    2e20 <dradfg+0x1d00>
mov    %r13,%rdx
mov    %r15,%rsi
mov    %r14,%rax
xor    %edi,%edi
jmp    2e66 <dradfg+0x1d46>
nopl   0x0(%rax)
add    $0x1,%rdi
add    0x30(%rsp),%rax
add    %rcx,%rsi
add    %rcx,%rdx
cmp    0x18(%rsp),%rdi
je     2e20 <dradfg+0x1d00>
cmp    $0x3,%rbp
jl     2e50 <dradfg+0x1d30>
mov    $0x2,%ebx
mov    $0xfffffffffffffffe,%r8
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbx,8),%xmm0
addsd  -0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbx,8)
movsd  -0x8(%rdx,%rbx,8),%xmm0
subsd  -0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r8,8)
movsd  (%rdx,%rbx,8),%xmm0
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm0
subsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%r8,8)
add    $0x2,%rbx
add    $0xfffffffffffffffe,%r8
cmp    %rbp,%rbx
jl     2e80 <dradfg+0x1d60>
jmp    2e50 <dradfg+0x1d30>
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rcx,%rsi,8),%xmm1
movups 0x10(%rcx,%rsi,8),%xmm2
movups %xmm1,(%rbx,%rsi,8)
movups %xmm2,0x10(%rbx,%rsi,8)
movups 0x20(%rcx,%rsi,8),%xmm1
movups 0x30(%rcx,%rsi,8),%xmm2
movups %xmm1,0x20(%rbx,%rsi,8)
movups %xmm2,0x30(%rbx,%rsi,8)
movups 0x40(%rcx,%rsi,8),%xmm1
movups 0x50(%rcx,%rsi,8),%xmm2
movups %xmm1,0x40(%rbx,%rsi,8)
movups %xmm2,0x50(%rbx,%rsi,8)
movupd 0x60(%rcx,%rsi,8),%xmm1
movupd 0x70(%rcx,%rsi,8),%xmm2
movupd %xmm1,0x60(%rbx,%rsi,8)
movupd %xmm2,0x70(%rbx,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    2ef0 <dradfg+0x1dd0>
test   %r10,%r10
je     2f8f <dradfg+0x1e6f>
lea    (%rbx,%rsi,8),%rdx
add    $0x10,%rdx
lea    (%rcx,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%r10
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rdi,1),%xmm1
movupd (%rsi,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rdi,1)
movupd %xmm2,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    2f70 <dradfg+0x1e50>
cmp    %rbp,%rax
jne    12d2 <dradfg+0x1b2>
cmpq   $0x2,0x38(%rsp)
jl     386e <dradfg+0x274e>
lea    -0x4(%r13),%rax
mov    %rax,0xe0(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    $0x4,%r13
setae  %al
cmp    $0x1,%r8
sete   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
mov    %r13,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x78(%rsp)
imul   %r8,%rax
mov    %rax,0xc8(%rsp)
mov    %rcx,%rax
mov    %rcx,0xd8(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xc0(%rsp)
mov    %r13d,%r10d
and    $0x3,%r10d
lea    0x4(%r13),%rax
imul   %r8,%rax
lea    (%r9,%rax,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x50(%rsp)
mov    %r8,%rcx
shl    $0x6,%rcx
mov    %rcx,0xa8(%rsp)
lea    (%r12,%rax,8),%rdi
add    $0x10,%rdi
mov    %r10,0x68(%rsp)
neg    %r10
mov    %r8,%r15
shl    $0x5,%r15
lea    0x0(,%r8,8),%r11
lea    (%r11,%r11,2),%rax
lea    (%r9,%rax,1),%rcx
mov    %rcx,0x88(%rsp)
add    %r12,%rax
mov    %rax,0x90(%rsp)
shl    $0x4,%r8
lea    (%r9,%r8,1),%rax
mov    %rax,0x80(%rsp)
add    %r12,%r8
mov    %r8,0x48(%rsp)
mov    0x1b8(%rsp),%r14
mov    %r13,%rax
add    %r13,%rax
mov    %rax,0x70(%rsp)
mov    0xa0(%rsp),%rax
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x60(%rsp)
lea    0x10(%r12,%rax,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    (%r9,%rax,8),%rax
add    $0x10,%rax
mov    %rax,0x98(%rsp)
mov    $0x1,%ecx
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    %rdi,0xb8(%rsp)
jmp    311e <dradfg+0x1ffe>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0x20(%rsp)
mov    0x40(%rsp),%rax
add    0x60(%rsp),%rax
mov    %rax,0x40(%rsp)
cmp    0x38(%rsp),%rcx
mov    0x18(%rsp),%r13
je     3390 <dradfg+0x2270>
mov    %rcx,0x58(%rsp)
mov    0x28(%rsp),%rax
add    0xa0(%rsp),%rax
mov    %rax,0x28(%rsp)
test   %r13,%r13
jle    30f0 <dradfg+0x1fd0>
cmpb   $0x0,0x10(%rsp)
je     31b0 <dradfg+0x2090>
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%r8
imul   %r8,%rax
mov    0x70(%rsp),%rcx
add    %rax,%rcx
add    %r8,%rax
mov    0x1a8(%rsp),%rbp
lea    0x0(,%rax,8),%rdx
add    %rbp,%rdx
mov    (%rsp),%rdi
lea    (%rdi,%rcx,8),%rsi
cmp    %rsi,%rdx
mov    0x8(%rsp),%rdx
jae    32b0 <dradfg+0x2190>
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    (%rdi,%rax,8),%rax
cmp    %rcx,%rax
jae    32b0 <dradfg+0x2190>
xor    %r9d,%r9d
mov    0x28(%rsp),%rbx
jmp    31ce <dradfg+0x20ae>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r9d,%r9d
mov    0x28(%rsp),%rbx
mov    0x18(%rsp),%r8
mov    0x8(%rsp),%rdx
mov    0x1a8(%rsp),%rbp
mov    (%rsp),%rdi
mov    %r9,%rax
not    %rax
add    %r8,%rax
cmpq   $0x0,0x68(%rsp)
je     320a <dradfg+0x20ea>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    %rdx,%rbx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%r10
jne    31f0 <dradfg+0x20d0>
sub    %rcx,%r9
cmp    $0x3,%rax
jb     30f0 <dradfg+0x1fd0>
mov    0x18(%rsp),%rsi
sub    %r9,%rsi
mov    (%rsp),%r9
lea    (%r9,%rbx,8),%rbp
mov    0x1a8(%rsp),%r8
lea    (%r8,%rbx,8),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
mov    0x80(%rsp),%rdi
lea    (%rdi,%rbx,8),%r13
mov    0x48(%rsp),%rdi
lea    (%rdi,%rbx,8),%r12
add    0x8(%rsp),%rbx
lea    (%r8,%rbx,8),%r8
lea    (%r9,%rbx,8),%rbx
xor    %r9d,%r9d
nopl   (%rax)
movsd  0x0(%rbp,%r9,1),%xmm1
movsd  %xmm1,(%rax,%r9,1)
movsd  (%rbx,%r9,1),%xmm1
movsd  %xmm1,(%r8,%r9,1)
movsd  (%r12,%r9,1),%xmm1
movsd  %xmm1,0x0(%r13,%r9,1)
movsd  (%rdx,%r9,1),%xmm1
movsd  %xmm1,(%rcx,%r9,1)
add    %r15,%r9
add    $0xfffffffffffffffc,%rsi
jne    3270 <dradfg+0x2150>
jmp    30f0 <dradfg+0x1fd0>
cmpq   $0x4,0xe0(%rsp)
jae    32bf <dradfg+0x219f>
xor    %ebx,%ebx
jmp    333b <dradfg+0x221b>
mov    0xc0(%rsp),%rax
mov    0x40(%rsp),%rcx
xor    %ebx,%ebx
mov    0xd0(%rsp),%r9
mov    0x98(%rsp),%r12
mov    0x50(%rsp),%rsi
mov    0xa8(%rsp),%r13
mov    0xb8(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r9,%rcx,1),%xmm1
movups (%r9,%rcx,1),%xmm2
movups %xmm1,-0x10(%r12,%rcx,1)
movups %xmm2,(%r12,%rcx,1)
movupd -0x10(%r8,%rcx,1),%xmm1
movupd (%r8,%rcx,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rcx,1)
movupd %xmm2,(%rsi,%rcx,1)
add    $0x8,%rbx
add    %r13,%rcx
add    $0xfffffffffffffffe,%rax
jne    3300 <dradfg+0x21e0>
testb  $0x1,0xd8(%rsp)
01
je     3365 <dradfg+0x2245>
imul   %rdx,%rbx
add    0x28(%rsp),%rbx
movupd (%rdi,%rbx,8),%xmm1
movupd 0x10(%rdi,%rbx,8),%xmm2
movupd %xmm1,0x0(%rbp,%rbx,8)
movupd %xmm2,0x10(%rbp,%rbx,8)
mov    0x18(%rsp),%rax
cmp    %rax,0x78(%rsp)
je     30f0 <dradfg+0x1fd0>
mov    0xc8(%rsp),%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
mov    0x78(%rsp),%r9
jmp    31b8 <dradfg+0x2098>
mov    0x8(%rsp),%r9
mov    %r9,%r10
neg    %r10
cmp    %r13,0x118(%rsp)
jle    3788 <dradfg+0x2668>
cmpq   $0x2,0x38(%rsp)
mov    0x1a8(%rsp),%rcx
mov    (%rsp),%rsi
jl     386e <dradfg+0x274e>
mov    0xa0(%rsp),%rdx
lea    0x1(%rdx),%rax
mov    %rax,0xb8(%rsp)
lea    -0x3(%r9),%rdi
mov    %rdi,%rax
shr    %rax
mov    %rdi,0x40(%rsp)
and    $0xfffffffffffffffe,%rdi
lea    (%rdx,%rdi,1),%rbp
add    $0x3,%rbp
mov    %rbp,0xf0(%rsp)
add    $0x2,%rdi
mov    %rdi,0xf8(%rsp)
lea    0x1(%rax),%rdi
mov    %rdi,0xd0(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x48(%rsp)
add    %rdi,%rdi
mov    %rdi,0x80(%rsp)
add    %rax,%rax
add    $0x2,%rax
or     $0x2,%rax
mov    %rax,0x98(%rsp)
lea    (%rcx,%rdx,8),%rax
add    $0x8,%rax
mov    %rax,0xc0(%rsp)
lea    0x8(%rsi,%rdx,8),%rax
mov    %rax,0x50(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x58(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x20(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%ecx
xor    %eax,%eax
mov    %rax,0xa8(%rsp)
mov    %r14,%r15
xor    %edx,%edx
jmp    34df <dradfg+0x23bf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xc8(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0xa8(%rsp)
mov    0x60(%rsp),%rax
add    %rax,0xc0(%rsp)
add    %rax,0x50(%rsp)
add    %r11,%r15
mov    0xd8(%rsp),%rdx
cmp    0x38(%rsp),%rcx
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%r13
mov    0xe0(%rsp),%r10
je     386e <dradfg+0x274e>
mov    %rcx,0xc8(%rsp)
mov    0xa0(%rsp),%rax
add    %rdx,%rax
mov    %rax,0xd8(%rsp)
add    %r9,%r10
mov    %r10,0xe0(%rsp)
test   %r13,%r13
jle    3490 <dradfg+0x2370>
mov    %rdx,%rcx
mov    0xb8(%rsp),%rax
add    %rdx,%rax
mov    %rax,0x70(%rsp)
add    0xf0(%rsp),%rcx
mov    %rcx,0x68(%rsp)
mov    0xa8(%rsp),%rax
mov    0x8(%rsp),%rdx
imul   %rdx,%rax
mov    0xf8(%rsp),%rcx
add    %rax,%rcx
lea    (%r14,%rax,8),%rax
mov    %rax,0x90(%rsp)
lea    (%r14,%rcx,8),%rax
mov    %rax,0x88(%rsp)
mov    0xd8(%rsp),%r10
sub    %rdx,%r10
mov    0xe0(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x28(%rsp)
mov    0x80(%rsp),%rcx
lea    -0x1(%rax,%rcx,1),%rax
mov    %rax,0x78(%rsp)
mov    0x50(%rsp),%rax
mov    0xc0(%rsp),%r13
xor    %edi,%edi
jmp    35b5 <dradfg+0x2495>
nopl   (%rax)
add    $0x1,%rdi
add    %r11,%r13
add    %r11,%rax
cmp    0x18(%rsp),%rdi
je     3490 <dradfg+0x2370>
mov    0x8(%rsp),%rcx
add    %rcx,%r10
cmp    $0x3,%rcx
jl     35a0 <dradfg+0x2480>
mov    $0x2,%r8d
cmpq   $0x2,0x40(%rsp)
jae    3660 <dradfg+0x2540>
mov    0x28(%rsp),%rcx
mov    %r10,%r9
mov    0x8(%rsp),%r12
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,8),%rbp
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,8),%rbx
xor    %ecx,%ecx
nop
movsd  (%rsi,%rcx,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
movsd  -0x8(%rsi,%rcx,8),%xmm2
mulsd  -0x8(%rbx,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rbp,%rcx,8)
movsd  -0x8(%rbx,%rcx,8),%xmm1
mulsd  (%rsi,%rcx,8),%xmm1
movsd  -0x8(%rsi,%rcx,8),%xmm2
mulsd  (%rbx,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
lea    (%r8,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    %r12,%rdx
jl     3600 <dradfg+0x24e0>
jmp    35a0 <dradfg+0x2480>
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,%rcx
imul   0x8(%rsp),%rcx
mov    0x70(%rsp),%rdx
lea    (%rdx,%rcx,1),%rsi
add    0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rdx
lea    (%rdx,%rsi,8),%rbp
lea    (%rdx,%rcx,8),%rbx
mov    (%rsp),%rdx
lea    (%rdx,%rsi,8),%rsi
lea    (%rdx,%rcx,8),%rcx
cmp    0x88(%rsp),%rbp
setb   %r9b
cmp    %rbx,0x90(%rsp)
setb   %r12b
cmp    %rcx,%rbp
setb   %bpl
cmp    %rbx,%rsi
setb   %sil
test   %r12b,%r9b
jne    35d5 <dradfg+0x24b5>
mov    0x28(%rsp),%rcx
mov    %r10,%r9
and    %sil,%bpl
mov    0x8(%rsp),%r12
jne    35e2 <dradfg+0x24c2>
mov    0x80(%rsp),%rcx
lea    (%r10,%rcx,1),%r9
mov    0x48(%rsp),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rbp,1),%xmm1
movupd 0x10(%r15,%rbp,1),%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm2,%xmm3
movupd (%rax,%rbp,1),%xmm4
movupd 0x10(%rax,%rbp,1),%xmm5
movapd %xmm4,%xmm6
unpcklpd %xmm5,%xmm6
unpckhpd %xmm2,%xmm1
unpckhpd %xmm5,%xmm4
movapd %xmm1,%xmm2
mulpd  %xmm4,%xmm2
mulpd  %xmm3,%xmm4
mulpd  %xmm6,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm6,%xmm1
subpd  %xmm1,%xmm4
movapd %xmm3,%xmm1
unpcklpd %xmm4,%xmm1
movhlps %xmm3,%xmm4
movups %xmm4,0x10(%r13,%rbp,1)
movupd %xmm1,0x0(%r13,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rsi
jne    36f0 <dradfg+0x25d0>
mov    0x78(%rsp),%rcx
mov    0x98(%rsp),%r8
mov    0x48(%rsp),%rdx
cmp    %rdx,0xd0(%rsp)
mov    0x8(%rsp),%r12
je     35a0 <dradfg+0x2480>
jmp    35e2 <dradfg+0x24c2>
cmpq   $0x2,0x38(%rsp)
mov    0xd0(%rsp),%r15
mov    0x98(%rsp),%r12
jl     386e <dradfg+0x274e>
mov    $0x1,%r8d
jmp    37ca <dradfg+0x26aa>
nopl   0x0(%rax)
add    $0x1,%r8
mov    0x60(%rsp),%rax
add    %rax,%r15
add    %rax,%r12
cmp    0x38(%rsp),%r8
je     386e <dradfg+0x274e>
add    %r9,%r10
cmp    $0x3,%r9
jl     37b0 <dradfg+0x2690>
lea    -0x1(%r10),%rbp
mov    $0x2,%esi
mov    %r12,%rdi
mov    %r15,%rbx
jmp    3804 <dradfg+0x26e4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rsi
add    $0x10,%rbx
add    $0x10,%rdi
mov    %rax,%rbp
cmp    %r9,%rsi
jge    37b0 <dradfg+0x2690>
lea    0x2(%rbp),%rax
test   %r13,%r13
jle    37f0 <dradfg+0x26d0>
xor    %ecx,%ecx
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%r14,%rbp,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
mulsd  (%rbx,%rcx,1),%xmm2
mulsd  -0x8(%rbx,%rcx,1),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%rdi,%rcx,1)
movsd  0x8(%r14,%rbp,8),%xmm1
movsd  -0x8(%rbx,%rcx,1),%xmm2
mulsd  (%r14,%rax,8),%xmm2
mulsd  (%rbx,%rcx,1),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rcx,1)
add    %r11,%rcx
add    $0xffffffffffffffff,%rdx
jne    3820 <dradfg+0x2700>
jmp    37f0 <dradfg+0x26d0>
cmp    %r13,0x118(%rsp)
jge    39ce <dradfg+0x28ae>
cmpq   $0x3,0x38(%rsp)
jl     11c4 <dradfg+0xa4>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovge %rax,%rcx
mov    %rcx,0x28(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0xa0(%rsp),%rsi
imul   %rsi,%rax
mov    0x1a8(%rsp),%rdx
lea    (%rdx,%rax,8),%r11
add    $0x10,%r11
lea    0x0(,%rsi,8),%r9
mov    %r9,%r10
neg    %r10
mov    0x8(%rsp),%rcx
lea    0x0(,%rcx,8),%rdi
mov    (%rsp),%rcx
lea    (%rcx,%rax,8),%r14
add    $0x10,%r14
lea    (%rdx,%rsi,8),%r15
add    $0x10,%r15
lea    (%rcx,%rsi,8),%r12
add    $0x10,%r12
mov    $0x1,%r13d
jmp    392b <dradfg+0x280b>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r10,%r11
add    %r10,%r14
add    %r9,%r15
add    %r9,%r12
cmp    0x28(%rsp),%r13
je     11c4 <dradfg+0xa4>
cmpq   $0x3,0x8(%rsp)
jl     3910 <dradfg+0x27f0>
mov    $0x2,%ebx
mov    %r12,%rdx
mov    %r15,%rax
mov    %r14,%rbp
mov    %r11,%rcx
jmp    396b <dradfg+0x284b>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rbx
add    $0x10,%rcx
add    $0x10,%rbp
add    $0x10,%rax
add    $0x10,%rdx
cmp    0x8(%rsp),%rbx
jge    3910 <dradfg+0x27f0>
cmpq   $0x0,0x18(%rsp)
jle    3950 <dradfg+0x2830>
xor    %esi,%esi
mov    0x18(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rsi,1),%xmm1
addsd  -0x8(%rcx,%rsi,1),%xmm1
movsd  %xmm1,-0x8(%rdx,%rsi,1)
movsd  (%rax,%rsi,1),%xmm1
subsd  (%rcx,%rsi,1),%xmm1
movsd  %xmm1,-0x8(%rbp,%rsi,1)
movsd  (%rax,%rsi,1),%xmm1
addsd  (%rcx,%rsi,1),%xmm1
movsd  %xmm1,(%rdx,%rsi,1)
movsd  -0x8(%rcx,%rsi,1),%xmm1
subsd  -0x8(%rax,%rsi,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,1)
add    %rdi,%rsi
add    $0xffffffffffffffff,%r8
jne    3980 <dradfg+0x2860>
jmp    3950 <dradfg+0x2830>
cmpq   $0x3,0x38(%rsp)
jl     11c4 <dradfg+0xa4>
mov    0xb0(%rsp),%rax
cmp    $0x3,%rax
mov    $0x2,%ecx
cmovge %rax,%rcx
mov    %rcx,0x28(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0xa0(%rsp),%rdx
imul   %rdx,%rax
mov    (%rsp),%rsi
lea    (%rsi,%rax,8),%r11
lea    0x0(,%rdx,8),%r9
mov    %r9,%r10
neg    %r10
mov    0x8(%rsp),%rcx
lea    0x0(,%rcx,8),%rdi
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
lea    (%rsi,%rdx,8),%r15
lea    (%rcx,%rdx,8),%r12
mov    $0x1,%r13d
mov    0x8(%rsp),%r8
jmp    3a6b <dradfg+0x294b>
nopl   (%rax)
add    $0x1,%r13
add    %r10,%r11
add    %r10,%r14
add    %r9,%r15
add    %r9,%r12
cmp    0x28(%rsp),%r13
je     11c4 <dradfg+0xa4>
cmpq   $0x0,0x18(%rsp)
jle    3a50 <dradfg+0x2930>
mov    %r12,%rdx
mov    %r15,%rax
mov    %r14,%rbp
mov    %r11,%rcx
xor    %ebx,%ebx
jmp    3aa7 <dradfg+0x2987>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
add    %rdi,%rcx
add    %rdi,%rbp
add    %rdi,%rax
add    %rdi,%rdx
cmp    0x18(%rsp),%rbx
je     3a50 <dradfg+0x2930>
cmp    $0x3,%r8
jl     3a90 <dradfg+0x2970>
mov    $0x2,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rdx,%rsi,8),%xmm1
addsd  -0x8(%rbp,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm1
subsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm1
addsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,(%rax,%rsi,8)
movsd  -0x8(%rbp,%rsi,8),%xmm1
subsd  -0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %r8,%rsi
jl     3ac0 <dradfg+0x29a0>
jmp    3a90 <dradfg+0x2970>

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

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