void radfg(int ido, int ip, int l1, int idl1, double cc[], double c1[],
           double c2[], double ch[], double ch2[], const double wa[]) {
  static const double twopi = 6.28318530717959;
  int idij, ipph, i, j, k, l, j2, ic, jc, lc, ik, is, nbd;
  double dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h;
  arg = twopi / ip;
  dcp = cos(arg);
  dsp = sin(arg);
  ipph = (ip + 1) / 2;
  nbd = (ido - 1) / 2;
  if (ido != 1) {
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] = c2[ik];
    for (j = 1; j < ip; j++)
      for (k = 0; k < l1; k++)
        ch[(k + j * l1) * ido] = c1[(k + j * l1) * ido];
    if (nbd <= l1) {
      is = -ido;
      for (j = 1; j < ip; j++) {
        is += ido;
        idij = is - 1;
        for (i = 2; i < ido; i += 2) {
          idij += 2;
          for (k = 0; k < l1; k++) {
            ch[i - 1 + (k + j * l1) * ido] =
                wa[idij - 1] * c1[i - 1 + (k + j * l1) * ido] +
                wa[idij] * c1[i + (k + j * l1) * ido];
            ch[i + (k + j * l1) * ido] =
                wa[idij - 1] * c1[i + (k + j * l1) * ido] -
                wa[idij] * c1[i - 1 + (k + j * l1) * ido];
          }
        }
      }
    } else {
      is = -ido;
      for (j = 1; j < ip; j++) {
        is += ido;
        for (k = 0; k < l1; k++) {
          idij = is - 1;
          for (i = 2; i < ido; i += 2) {
            idij += 2;
            ch[i - 1 + (k + j * l1) * ido] =
                wa[idij - 1] * c1[i - 1 + (k + j * l1) * ido] +
                wa[idij] * c1[i + (k + j * l1) * ido];
            ch[i + (k + j * l1) * ido] =
                wa[idij - 1] * c1[i + (k + j * l1) * ido] -
                wa[idij] * c1[i - 1 + (k + j * l1) * ido];
          }
        }
      }
    }
    if (nbd >= l1) {
      for (j = 1; j < ipph; j++) {
        jc = ip - j;
        for (k = 0; k < l1; k++) {
          for (i = 2; i < ido; i += 2) {
            c1[i - 1 + (k + j * l1) * ido] = ch[i - 1 + (k + j * l1) * ido] +
                                             ch[i - 1 + (k + jc * l1) * ido];
            c1[i - 1 + (k + jc * l1) * ido] =
                ch[i + (k + j * l1) * ido] - ch[i + (k + jc * l1) * ido];
            c1[i + (k + j * l1) * ido] =
                ch[i + (k + j * l1) * ido] + ch[i + (k + jc * l1) * ido];
            c1[i + (k + jc * l1) * ido] = ch[i - 1 + (k + jc * l1) * ido] -
                                          ch[i - 1 + (k + j * l1) * ido];
          }
        }
      }
    } else {
      for (j = 1; j < ipph; j++) {
        jc = ip - j;
        for (i = 2; i < ido; i += 2) {
          for (k = 0; k < l1; k++) {
            c1[i - 1 + (k + j * l1) * ido] = ch[i - 1 + (k + j * l1) * ido] +
                                             ch[i - 1 + (k + jc * l1) * ido];
            c1[i - 1 + (k + jc * l1) * ido] =
                ch[i + (k + j * l1) * ido] - ch[i + (k + jc * l1) * ido];
            c1[i + (k + j * l1) * ido] =
                ch[i + (k + j * l1) * ido] + ch[i + (k + jc * l1) * ido];
            c1[i + (k + jc * l1) * ido] = ch[i - 1 + (k + jc * l1) * ido] -
                                          ch[i - 1 + (k + j * l1) * ido];
          }
        }
      }
    }
  } else {
    for (ik = 0; ik < idl1; ik++)
      c2[ik] = ch2[ik];
  }
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    for (k = 0; k < l1; k++) {
      c1[(k + j * l1) * ido] = ch[(k + j * l1) * ido] + ch[(k + jc * l1) * ido];
      c1[(k + jc * l1) * ido] =
          ch[(k + jc * l1) * ido] - ch[(k + j * l1) * ido];
    }
  }
  ar1 = 1;
  ai1 = 0;
  for (l = 1; l < ipph; l++) {
    lc = ip - l;
    ar1h = dcp * ar1 - dsp * ai1;
    ai1 = dcp * ai1 + dsp * ar1;
    ar1 = ar1h;
    for (ik = 0; ik < idl1; ik++) {
      ch2[ik + l * idl1] = c2[ik] + ar1 * c2[ik + idl1];
      ch2[ik + lc * idl1] = ai1 * c2[ik + (ip - 1) * idl1];
    }
    dc2 = ar1;
    ds2 = ai1;
    ar2 = ar1;
    ai2 = ai1;
    for (j = 2; j < ipph; j++) {
      jc = ip - j;
      ar2h = dc2 * ar2 - ds2 * ai2;
      ai2 = dc2 * ai2 + ds2 * ar2;
      ar2 = ar2h;
      for (ik = 0; ik < idl1; ik++) {
        ch2[ik + l * idl1] += ar2 * c2[ik + j * idl1];
        ch2[ik + lc * idl1] += ai2 * c2[ik + jc * idl1];
      }
    }
  }
  for (j = 1; j < ipph; j++)
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += c2[ik + j * idl1];
  if (ido >= l1) {
    for (k = 0; k < l1; k++) {
      for (i = 0; i < ido; i++) {
        cc[i + k * ip * ido] = ch[i + k * ido];
      }
    }
  } else {
    for (i = 0; i < ido; i++) {
      for (k = 0; k < l1; k++) {
        cc[i + k * ip * ido] = ch[i + k * ido];
      }
    }
  }
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    j2 = 2 * j;
    for (k = 0; k < l1; k++) {
      cc[ido - 1 + (j2 - 1 + k * ip) * ido] = ch[(k + j * l1) * ido];
      cc[(j2 + k * ip) * ido] = ch[(k + jc * l1) * ido];
    }
  }
  if (ido == 1)
    return;
  if (nbd >= l1) {
    for (j = 1; j < ipph; j++) {
      jc = ip - j;
      j2 = 2 * j;
      for (k = 0; k < l1; k++) {
        for (i = 2; i < ido; i += 2) {
          ic = ido - i;
          cc[i - 1 + (j2 + k * ip) * ido] =
              ch[i - 1 + (k + j * l1) * ido] + ch[i - 1 + (k + jc * l1) * ido];
          cc[ic - 1 + (j2 - 1 + k * ip) * ido] =
              ch[i - 1 + (k + j * l1) * ido] - ch[i - 1 + (k + jc * l1) * ido];
          cc[i + (j2 + k * ip) * ido] =
              ch[i + (k + j * l1) * ido] + ch[i + (k + jc * l1) * ido];
          cc[ic + (j2 - 1 + k * ip) * ido] =
              ch[i + (k + jc * l1) * ido] - ch[i + (k + j * l1) * ido];
        }
      }
    }
  } else {
    for (j = 1; j < ipph; j++) {
      jc = ip - j;
      j2 = 2 * j;
      for (i = 2; i < ido; i += 2) {
        ic = ido - i;
        for (k = 0; k < l1; k++) {
          cc[i - 1 + (j2 + k * ip) * ido] =
              ch[i - 1 + (k + j * l1) * ido] + ch[i - 1 + (k + jc * l1) * ido];
          cc[ic - 1 + (j2 - 1 + k * ip) * ido] =
              ch[i - 1 + (k + j * l1) * ido] - ch[i - 1 + (k + jc * l1) * ido];
          cc[i + (j2 + k * ip) * ido] =
              ch[i + (k + j * l1) * ido] + ch[i + (k + jc * l1) * ido];
          cc[ic + (j2 - 1 + k * ip) * ido] =
              ch[i + (k + jc * l1) * ido] - ch[i + (k + j * l1) * ido];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<radfg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
cvtsi2sdl -0x8(%rbp),%xmm1
movsd  0x1ea4(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1040 <cos@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
cmpl   $0x1,-0x4(%rbp)
je     1a59 <radfg+0x939>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11f9 <radfg+0xd9>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11c5 <radfg+0xa5>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1278 <radfg+0x158>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1265 <radfg+0x145>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1213 <radfg+0xf3>
jmp    126a <radfg+0x14a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1200 <radfg+0xe0>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     144d <radfg+0x32d>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1448 <radfg+0x328>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1435 <radfg+0x315>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1422 <radfg+0x302>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%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    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12d4 <radfg+0x1b4>
jmp    1427 <radfg+0x307>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b8 <radfg+0x198>
jmp    143a <radfg+0x31a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1293 <radfg+0x173>
jmp    1616 <radfg+0x4f6>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1611 <radfg+0x4f1>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15fe <radfg+0x4de>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15eb <radfg+0x4cb>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%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    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1494 <radfg+0x374>
jmp    15f0 <radfg+0x4d0>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1478 <radfg+0x358>
jmp    1603 <radfg+0x4e3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    145c <radfg+0x33c>
jmp    1616 <radfg+0x4f6>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     183b <radfg+0x71b>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1836 <radfg+0x716>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1823 <radfg+0x703>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1810 <radfg+0x6f0>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1658 <radfg+0x538>
jmp    1815 <radfg+0x6f5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1645 <radfg+0x525>
jmp    1828 <radfg+0x708>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1629 <radfg+0x509>
jmp    1a54 <radfg+0x934>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a4f <radfg+0x92f>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a3c <radfg+0x91c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a29 <radfg+0x909>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1871 <radfg+0x751>
jmp    1a2e <radfg+0x90e>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    185e <radfg+0x73e>
jmp    1a41 <radfg+0x921>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1842 <radfg+0x722>
jmp    1a54 <radfg+0x934>
jmp    1a99 <radfg+0x979>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a94 <radfg+0x974>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a60 <radfg+0x940>
jmp    1a99 <radfg+0x979>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b91 <radfg+0xa71>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b7e <radfg+0xa5e>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1abc <radfg+0x99c>
jmp    1b83 <radfg+0xa63>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1aa0 <radfg+0x980>
movsd  0x146f(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e55 <radfg+0xd35>
mov    -0x8(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1cd4 <radfg+0xbb4>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c3e <radfg+0xb1e>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e42 <radfg+0xd22>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e2f <radfg+0xd0f>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d91 <radfg+0xc71>
jmp    1e34 <radfg+0xd14>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d06 <radfg+0xbe6>
jmp    1e47 <radfg+0xd27>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bad <radfg+0xa8d>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ec6 <radfg+0xda6>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1eb3 <radfg+0xd93>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e6f <radfg+0xd4f>
jmp    1eb8 <radfg+0xd98>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e5c <radfg+0xd3c>
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1f52 <radfg+0xe32>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1f4d <radfg+0xe2d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f3a <radfg+0xe1a>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1eec <radfg+0xdcc>
jmp    1f3f <radfg+0xe1f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ed9 <radfg+0xdb9>
jmp    1fd2 <radfg+0xeb2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1fcd <radfg+0xead>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fba <radfg+0xe9a>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f6c <radfg+0xe4c>
jmp    1fbf <radfg+0xe9f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f59 <radfg+0xe39>
jmp    1fd2 <radfg+0xeb2>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    20a6 <radfg+0xf86>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2093 <radfg+0xf73>
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ffe <radfg+0xede>
jmp    2098 <radfg+0xf78>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1fd9 <radfg+0xeb9>
cmpl   $0x1,-0x4(%rbp)
jne    20b5 <radfg+0xf95>
jmp    2523 <radfg+0x1403>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     22f2 <radfg+0x11d2>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    22ed <radfg+0x11cd>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    22da <radfg+0x11ba>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    22c7 <radfg+0x11a7>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2100 <radfg+0xfe0>
jmp    22cc <radfg+0x11ac>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20ed <radfg+0xfcd>
jmp    22df <radfg+0x11bf>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20c8 <radfg+0xfa8>
jmp    2523 <radfg+0x1403>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    251e <radfg+0x13fe>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    250b <radfg+0x13eb>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    24f8 <radfg+0x13d8>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    233a <radfg+0x121a>
jmp    24fd <radfg+0x13dd>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    231e <radfg+0x11fe>
jmp    2510 <radfg+0x13f0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    22f9 <radfg+0x11d9>
jmp    2523 <radfg+0x1403>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radfg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%rbp
mov    %r8,0x80(%rsp)
mov    %ecx,%r15d
mov    %edx,0x4(%rsp)
mov    %esi,%r14d
mov    %edi,%ebx
mov    0x1b0(%rsp),%r12
cvtsi2sd %esi,%xmm1
movsd  0x2ea4(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0xb0(%rsp)
movsd  0x28(%rsp),%xmm0
call   1030 <sin@plt>
lea    0x1(%r14),%eax
shr    $0x1f,%eax
add    %r14d,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,0x5c(%rsp)
lea    -0x1(%rbx),%eax
shr    $0x1f,%eax
add    %ebx,%eax
add    $0xffffffff,%eax
sar    %eax
mov    %eax,0x94(%rsp)
mov    %rbx,0x28(%rsp)
cmp    $0x1,%ebx
mov    %r14,0x38(%rsp)
mov    %r15d,0x60(%rsp)
jne    129c <radfg+0x17c>
test   %r15d,%r15d
mov    0x28(%rsp),%rbx
movapd 0xb0(%rsp),%xmm11
jle    146d <radfg+0x34d>
mov    0x60(%rsp),%ecx
mov    %ecx,%r9d
cmp    $0x4,%ecx
jb     120c <radfg+0xec>
mov    0x1c0(%rsp),%rdx
lea    (%rdx,%r9,8),%rcx
mov    0x1b0(%rsp),%rax
cmp    %rax,%rcx
jbe    1360 <radfg+0x240>
lea    (%rax,%r9,8),%rcx
cmp    %rdx,%rcx
jbe    1360 <radfg+0x240>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     1244 <radfg+0x124>
mov    0x1c0(%rsp),%rdi
mov    0x1b0(%rsp),%rax
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1230 <radfg+0x110>
cmp    $0x3,%rdx
jb     146d <radfg+0x34d>
xchg   %ax,%ax
mov    0x1c0(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
mov    0x1b0(%rsp),%rax
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rax,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1250 <radfg+0x130>
jmp    146d <radfg+0x34d>
test   %r15d,%r15d
mov    0x1c0(%rsp),%rdx
movapd 0xb0(%rsp),%xmm11
jle    29dd <radfg+0x18bd>
mov    0x60(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x4,%ecx
jb     12dc <radfg+0x1bc>
lea    (%r12,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1389 <radfg+0x269>
lea    (%rdx,%rax,8),%rcx
cmp    %r12,%rcx
jbe    1389 <radfg+0x269>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rsi
and    $0x3,%rsi
je     1305 <radfg+0x1e5>
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12f0 <radfg+0x1d0>
cmp    $0x3,%rdi
mov    0x38(%rsp),%r14
jb     29dd <radfg+0x18bd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rcx,8)
movsd  0x10(%r12,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rcx,8)
movsd  0x18(%r12,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1320 <radfg+0x200>
jmp    29dd <radfg+0x18bd>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdi
jae    13b5 <radfg+0x295>
xor    %edi,%edi
jmp    141c <radfg+0x2fc>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdi
jae    291e <radfg+0x17fe>
xor    %edi,%edi
jmp    2994 <radfg+0x1874>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,8),%xmm1
movups 0x10(%rdx,%rdi,8),%xmm2
movups %xmm1,(%rax,%rdi,8)
movups %xmm2,0x10(%rax,%rdi,8)
movups 0x20(%rdx,%rdi,8),%xmm1
movups 0x30(%rdx,%rdi,8),%xmm2
movups %xmm1,0x20(%rax,%rdi,8)
movups %xmm2,0x30(%rax,%rdi,8)
movups 0x40(%rdx,%rdi,8),%xmm1
movups 0x50(%rdx,%rdi,8),%xmm2
movups %xmm1,0x40(%rax,%rdi,8)
movups %xmm2,0x50(%rax,%rdi,8)
movupd 0x60(%rdx,%rdi,8),%xmm1
movupd 0x70(%rdx,%rdi,8),%xmm2
movupd %xmm1,0x60(%rax,%rdi,8)
movupd %xmm2,0x70(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13c0 <radfg+0x2a0>
test   %r8,%r8
je     145f <radfg+0x33f>
lea    (%rax,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rdx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbx,1),%xmm1
movupd (%rdi,%rbx,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rbx,1)
movupd %xmm2,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1440 <radfg+0x320>
cmp    %r9,%rcx
mov    0x28(%rsp),%rbx
jne    120e <radfg+0xee>
mov    0x38(%rsp),%rcx
cmp    $0x3,%ecx
jl     155a <radfg+0x43a>
movslq %ebx,%rax
mov    %ecx,%edx
mov    0x4(%rsp),%r15d
movslq %r15d,%rdi
mov    0x5c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%r9d
cmovge %ecx,%r9d
mov    %r15d,%r8d
mov    %rdx,0xc0(%rsp)
lea    -0x1(%rdx),%rcx
imul   %rax,%rdi
mov    %rcx,0xa0(%rsp)
imul   %rdi,%rcx
mov    0x1b8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
lea    0x0(,%rdi,8),%r10
mov    %r10,%r11
neg    %r11
shl    $0x3,%rax
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    (%rdx,%rdi,8),%rdx
lea    0x0(%rbp,%rdi,8),%rbp
mov    $0x1,%r14d
mov    0x1b0(%rsp),%r12
jmp    1519 <radfg+0x3f9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r11,%rsi
add    %r11,%rcx
add    %r10,%rdx
add    %r10,%rbp
cmp    %r9,%r14
je     164d <radfg+0x52d>
test   %r15d,%r15d
jle    1500 <radfg+0x3e0>
mov    %r8,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rdi,1),%xmm1
addsd  (%rsi,%rdi,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rdi,1)
movsd  (%rsi,%rdi,1),%xmm1
subsd  (%rdx,%rdi,1),%xmm1
movsd  %xmm1,(%rcx,%rdi,1)
add    %rax,%rdi
add    $0xffffffffffffffff,%rbx
jne    1530 <radfg+0x410>
jmp    1500 <radfg+0x3e0>
movl   $0x0,0x10(%rsp)
mov    0x4(%rsp),%r15d
cmp    %r15d,%ebx
jge    210b <radfg+0xfeb>
test   %ebx,%ebx
jle    23b2 <radfg+0x1292>
mov    0x38(%rsp),%r10
imul   %ebx,%r10d
mov    %ebx,%ecx
mov    %r15d,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
mov    %rcx,%r14
shl    $0x4,%r14
lea    (%r10,%r10,1),%r12d
xor    %edx,%edx
mov    0x1b8(%rsp),%r9
mov    0x80(%rsp),%rbp
jmp    15c1 <radfg+0x4a1>
nopl   0x0(%rax)
add    $0x1,%rdx
add    $0x8,%r9
cmp    %rcx,%rdx
je     23b2 <radfg+0x1292>
test   %r15d,%r15d
jle    15b0 <radfg+0x490>
cmp    $0x1,%r15d
jne    15d0 <radfg+0x4b0>
xor    %eax,%eax
jmp    1615 <radfg+0x4f5>
xor    %ebx,%ebx
mov    %r9,%rsi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm0
movslq %ebx,%rbx
lea    (%rdx,%rbx,1),%rdi
movsd  %xmm0,0x0(%rbp,%rdi,8)
movsd  (%rsi,%rcx,8),%xmm0
lea    (%r10,%rbx,1),%edi
movslq %edi,%rdi
add    %rdx,%rdi
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x2,%rax
add    %r14,%rsi
add    %r12d,%ebx
cmp    %rax,%r11
jne    15e0 <radfg+0x4c0>
test   $0x1,%r8b
je     15b0 <radfg+0x490>
mov    %rax,%rsi
imul   %rcx,%rsi
add    %rdx,%rsi
mov    0x1b8(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm0
imul   %r10d,%eax
cltq
add    %rdx,%rax
mov    0x80(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
jmp    15b0 <radfg+0x490>
mov    0x38(%rsp),%rax
cmp    $0x3,%eax
jl     1e88 <radfg+0xd68>
movapd 0x29ac(%rip),%xmm9
xorpd  %xmm0,%xmm9
add    $0xffffffff,%eax
mov    0x60(%rsp),%r14d
imul   %r14d,%eax
movslq %r14d,%rsi
mov    0x5c(%rsp),%ecx
cmp    $0x4,%ecx
mov    $0x3,%r15d
cmovge %ecx,%r15d
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x158(%rsp)
movslq %eax,%r11
mov    %r14d,%r10d
mov    0xa0(%rsp),%rdx
imul   %rsi,%rdx
mov    0xc0(%rsp),%rcx
lea    -0x2(%rcx),%rbp
imul   %rsi,%rbp
lea    (%r11,%r10,1),%rax
lea    (%r12,%rax,8),%rax
mov    %rax,0x138(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm10
mov    %r10d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%rdi),%rax
mov    %rax,0x120(%rsp)
mov    %rax,%rbx
shr    %rbx
add    $0x1,%rbx
mov    %rbx,%rax
mov    %rbx,0x118(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x110(%rsp)
lea    0x0(,%rsi,8),%r8
lea    -0x1(%rcx),%rbx
imul   %rsi,%rbx
mov    %r8,%r9
neg    %r9
mov    %rsi,%rax
shl    $0x4,%rax
add    %r12,%rax
mov    %rax,0x148(%rsp)
lea    -0x2(%rcx),%rax
imul   %rsi,%rax
lea    (%r12,%rax,8),%rax
mov    %rax,0x140(%rsp)
movsd  0x28b9(%rip),%xmm2
movapd 0x28b8(%rip),%xmm8
lea    (%rsi,%r10,1),%rax
mov    %rdx,0xa0(%rsp)
lea    (%rdx,%r10,1),%rcx
mov    %rcx,0x150(%rsp)
lea    (%rsi,%rsi,1),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%r10,%rsi,2),%rcx
mov    %rcx,0x170(%rsp)
mov    %rbp,0x98(%rsp)
lea    0x0(%rbp,%r10,1),%rcx
mov    %rcx,0x168(%rsp)
lea    (%r12,%r10,8),%rcx
mov    %rcx,0x130(%rsp)
lea    (%r12,%rsi,8),%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,0xe0(%rsp)
lea    (%r12,%rax,8),%rax
mov    %rax,0x128(%rsp)
mov    %r11,0xd8(%rsp)
lea    (%r12,%r11,8),%rax
mov    %rsi,%r12
mov    %rax,0xc8(%rsp)
mov    0x1c0(%rsp),%r11
lea    0x10(%r11,%rsi,8),%rax
lea    0x10(%r11,%rbx,8),%rdx
lea    (%r11,%rsi,8),%rbp
mov    %rbx,0xf0(%rsp)
lea    (%r11,%rbx,8),%rcx
mov    $0x1,%ebx
mov    %rbx,0xa8(%rsp)
xor    %esi,%esi
mov    %r12,0xe8(%rsp)
mov    %r12,0x18(%rsp)
mov    %r8,0x30(%rsp)
mov    %r15,0x78(%rsp)
mov    %rdi,0x108(%rsp)
mov    %r9,0x70(%rsp)
jmp    18a7 <radfg+0x787>
nopw   0x0(%rax,%rax,1)
mov    0xa8(%rsp),%rbx
add    $0x1,%rbx
mov    0x160(%rsp),%rsi
add    $0x1,%rsi
mov    0x100(%rsp),%rax
add    %r8,%rax
mov    0xf8(%rsp),%rdx
add    %r9,%rdx
mov    0x18(%rsp),%r12
sub    %r12,0xf0(%rsp)
add    %r12,0xe8(%rsp)
add    %r8,%rbp
add    %r9,%rcx
mov    %rbx,0xa8(%rsp)
cmp    0x158(%rsp),%rbx
mov    0x1c0(%rsp),%r11
je     1e95 <radfg+0xd75>
mov    %rdx,0xf8(%rsp)
mov    %rax,0x100(%rsp)
mov    %rsi,0x160(%rsp)
mov    %rsi,%rax
imul   %r12,%rax
lea    (%rax,%r12,1),%rdx
mov    0xe0(%rsp),%rsi
add    %rax,%rsi
mov    0xa0(%rsp),%rdi
sub    %rax,%rdi
mov    0x150(%rsp),%rbx
sub    %rax,%rbx
lea    (%r11,%rdx,8),%rax
mov    %rax,0x10(%rsp)
lea    (%r11,%rsi,8),%rax
mov    %rax,0x48(%rsp)
lea    (%r11,%rdi,8),%rax
mov    %rax,0x40(%rsp)
lea    (%r11,%rbx,8),%rax
mov    %rax,0x50(%rsp)
movapd %xmm2,%xmm3
unpckhpd %xmm10,%xmm3
movapd %xmm9,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
mulpd  %xmm11,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
test   %r14d,%r14d
jle    19cc <radfg+0x8ac>
cmp    $0x1,%r14d
jne    1c40 <radfg+0xb20>
xor    %r12d,%r12d
mov    0xf0(%rsp),%rax
add    %r12,%rax
lea    (%r11,%rax,8),%r15
mov    0xd8(%rsp),%rax
lea    (%rax,%r12,1),%rax
mov    0x1b0(%rsp),%rdx
lea    (%rdx,%rax,8),%r9
mov    0xe8(%rsp),%rax
add    %r12,%rax
lea    (%r11,%rax,8),%rbx
mov    0x18(%rsp),%rax
add    %r12,%rax
lea    (%rdx,%rax,8),%rax
lea    (%rdx,%r12,8),%rdx
mov    %r10,%rsi
sub    %r12,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%rdi,8),%xmm3
movsd  %xmm3,(%rbx,%rdi,8)
movsd  (%r9,%rdi,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%r15,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    19a0 <radfg+0x880>
cmpl   $0x5,0x38(%rsp)
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%r9
jl     1840 <radfg+0x720>
xorpd  %xmm8,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x50(%rsp),%rax
cmp    %rax,0x10(%rsp)
setb   %al
mov    0x40(%rsp),%rdx
cmp    0x48(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0x88(%rsp)
mov    $0x2,%eax
mov    0x140(%rsp),%rdx
mov    0x148(%rsp),%r12
xor    %r11d,%r11d
movapd %xmm2,%xmm6
jmp    1a57 <radfg+0x937>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
add    $0x1,%r11
add    %r8,%r12
add    %r9,%rdx
cmp    %r15,%rax
je     1840 <radfg+0x720>
movapd %xmm6,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm4,%xmm7
unpcklpd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
test   %r14d,%r14d
jle    1a40 <radfg+0x920>
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
cmp    $0x1,%r14d
jne    1a90 <radfg+0x970>
xor    %ebx,%ebx
jmp    1c00 <radfg+0xae0>
nopl   (%rax)
mov    %r11,%rsi
imul   0x18(%rsp),%rsi
mov    0xb0(%rsp),%rdi
lea    (%rdi,%rsi,1),%r9
mov    0x170(%rsp),%rdi
lea    (%rdi,%rsi,1),%r8
mov    0x98(%rsp),%rbx
sub    %rsi,%rbx
mov    0x168(%rsp),%rdi
sub    %rsi,%rdi
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%r9,8),%r9
lea    (%rsi,%r8,8),%r15
lea    (%rsi,%rbx,8),%r8
lea    (%rsi,%rdi,8),%r14
mov    0x10(%rsp),%rsi
cmp    %r15,%rsi
setb   %bl
mov    0x48(%rsp),%r13
cmp    %r13,%r9
setb   %dil
and    %bl,%dil
or     0x88(%rsp),%dil
cmp    %r14,%rsi
setb   %bl
cmp    %r13,%r8
setb   0x20(%rsp)
mov    0x40(%rsp),%rsi
cmp    %r15,%rsi
setb   %r15b
mov    0x50(%rsp),%r13
cmp    %r13,%r9
setb   0x8(%rsp)
cmp    %r14,%rsi
setb   %r9b
cmp    %r13,%r8
setb   %r8b
test   %dil,%dil
jne    1bd7 <radfg+0xab7>
and    0x20(%rsp),%bl
jne    1bd7 <radfg+0xab7>
and    0x8(%rsp),%r15b
mov    0x60(%rsp),%r14d
jne    1be0 <radfg+0xac0>
mov    $0x0,%ebx
and    %r8b,%r9b
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r15
mov    0x108(%rsp),%rdi
mov    0x70(%rsp),%r9
jne    1c00 <radfg+0xae0>
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd (%r12,%rbx,8),%xmm1
mulpd  %xmm3,%xmm1
movupd 0x0(%rbp,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x0(%rbp,%rbx,8)
movupd (%rdx,%rbx,8),%xmm0
movupd (%rcx,%rbx,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    1b90 <radfg+0xa70>
mov    %rdi,%rbx
cmp    %r10,%rdi
jne    1c00 <radfg+0xae0>
jmp    1a40 <radfg+0x920>
xor    %ebx,%ebx
mov    0x60(%rsp),%r14d
jmp    1be2 <radfg+0xac2>
xor    %ebx,%ebx
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rbx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r10
jne    1c00 <radfg+0xae0>
jmp    1a40 <radfg+0x920>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rbx
mov    0x50(%rsp),%rax
cmp    %rax,%rbx
setb   0x20(%rsp)
mov    0x48(%rsp),%r9
mov    0x40(%rsp),%r15
cmp    %r9,%r15
setb   0x8(%rsp)
mov    0x130(%rsp),%rsi
cmp    %rsi,%rbx
setb   %r13b
mov    0x1b0(%rsp),%rdx
cmp    %rdx,%r9
seta   0x88(%rsp)
mov    0x128(%rsp),%rdi
cmp    %rdi,%rbx
setb   0x6f(%rsp)
mov    0xd0(%rsp),%r8
cmp    %r9,%r8
setb   0x6e(%rsp)
mov    0x138(%rsp),%r12
cmp    %r12,%rbx
setb   %bl
mov    0xc8(%rsp),%rdx
cmp    %r9,%rdx
setb   0x6d(%rsp)
cmp    %rsi,%r15
setb   %sil
cmp    0x1b0(%rsp),%rax
seta   0x6c(%rsp)
cmp    %rdi,%r15
setb   %r9b
cmp    %rax,%r8
setb   %r8b
cmp    %r12,%r15
setb   %dil
cmp    %rax,%rdx
setb   %al
mov    0x8(%rsp),%dl
test   %dl,0x20(%rsp)
jne    1949 <radfg+0x829>
and    0x88(%rsp),%r13b
jne    1949 <radfg+0x829>
mov    0x6e(%rsp),%dl
and    %dl,0x6f(%rsp)
jne    1949 <radfg+0x829>
and    0x6d(%rsp),%bl
jne    1949 <radfg+0x829>
and    0x6c(%rsp),%sil
jne    1949 <radfg+0x829>
and    %r8b,%r9b
jne    1949 <radfg+0x829>
mov    $0x0,%r12d
and    %al,%dil
jne    194c <radfg+0x82c>
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
cmpq   $0x0,0x120(%rsp)
mov    0x100(%rsp),%r9
mov    0xf8(%rsp),%r15
je     1dff <radfg+0xcdf>
mov    0x110(%rsp),%rdx
xor    %eax,%eax
mov    0x1b0(%rsp),%rbx
mov    0xd0(%rsp),%rsi
mov    0xc8(%rsp),%rdi
mov    0x18(%rsp),%r8
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm3
movupd (%rsi,%rax,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%r9,%rax,8)
movupd (%rdi,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%r15,%rax,8)
movupd 0x10(%rbx,%rax,8),%xmm3
movupd 0x10(%rsi,%rax,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%r9,%rax,8)
movupd 0x10(%rdi,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%r15,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rdx
jne    1da0 <radfg+0xc80>
jmp    1e0e <radfg+0xcee>
xor    %eax,%eax
mov    0x1b0(%rsp),%rbx
mov    0x18(%rsp),%r8
testb  $0x1,0x118(%rsp)
01
mov    0x108(%rsp),%r9
je     1e77 <radfg+0xd57>
mov    0xc0(%rsp),%rdx
mov    0xa8(%rsp),%rsi
sub    %rsi,%rdx
imul   %r8,%rsi
imul   %r8,%rdx
movupd (%rbx,%rax,8),%xmm3
lea    (%rax,%r8,1),%rdi
movupd (%rbx,%rdi,8),%xmm6
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
add    %rax,%rsi
movupd %xmm5,(%r11,%rsi,8)
mov    0xd8(%rsp),%rsi
add    %rax,%rsi
movupd (%rbx,%rsi,8),%xmm3
mulpd  %xmm4,%xmm3
add    %rax,%rdx
movupd %xmm3,(%r11,%rdx,8)
mov    %r9,%r12
cmp    %r10,%r9
jne    194c <radfg+0x82c>
jmp    19cc <radfg+0x8ac>
movl   $0x0,0x10(%rsp)
jmp    20fd <radfg+0xfdd>
mov    0x5c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r15d
cmovge %eax,%r15d
lea    (%r11,%r10,8),%r13
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0x10(%rsp)
and    %rax,%rdx
mov    %rdx,0x48(%rsp)
mov    %r12,%rcx
mov    %r10,%r12
neg    %r12
mov    0x1b0(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
add    $0x30,%rbp
lea    (%rax,%rcx,8),%rdi
add    $0x8,%rdi
mov    $0x1,%edx
xor    %r11d,%r11d
mov    0x18(%rsp),%rcx
jmp    1f37 <radfg+0xe17>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
add    $0x1,%r11
add    %r8,%rbp
add    %r8,%rdi
cmp    %r15,%rdx
je     20f2 <radfg+0xfd2>
cmpl   $0x0,0x60(%rsp)
jle    1f20 <radfg+0xe00>
mov    %rdx,%r14
imul   %rcx,%r14
cmpl   $0x4,0x60(%rsp)
jb     1f85 <radfg+0xe65>
mov    %r11,%rax
imul   %rcx,%rax
mov    0xe0(%rsp),%rsi
lea    (%rsi,%rax,1),%rbx
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
cmp    0x1c0(%rsp),%rbx
jbe    1fff <radfg+0xedf>
add    %rcx,%rax
lea    (%rsi,%rax,8),%rax
cmp    %r13,%rax
jae    1fff <radfg+0xedf>
xor    %ebx,%ebx
mov    %rbx,%rax
test   $0x1,%r10b
je     1fba <radfg+0xe9a>
add    %rbx,%r14
mov    0x1b0(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mov    0x1c0(%rsp),%rax
addsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
mov    %rbx,%rax
or     $0x1,%rax
not    %rbx
cmp    %r12,%rbx
mov    0x1c0(%rsp),%rbx
je     1f20 <radfg+0xe00>
xchg   %ax,%ax
movsd  -0x8(%rdi,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rdi,%rax,8),%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1fd0 <radfg+0xeb0>
jmp    1f20 <radfg+0xe00>
cmpq   $0x0,0x8(%rsp)
je     20e7 <radfg+0xfc7>
mov    0x48(%rsp),%rbx
xor    %eax,%eax
mov    0x1c0(%rsp),%r9
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rbp,%rax,8),%xmm0
movupd -0x20(%rbp,%rax,8),%xmm1
movupd (%r9,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r9,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%r9,%rax,8),%xmm1
movupd 0x30(%r9,%rax,8),%xmm3
movupd %xmm2,(%r9,%rax,8)
movupd %xmm0,0x10(%r9,%rax,8)
movupd -0x10(%rbp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r9,%rax,8)
movupd %xmm1,0x30(%r9,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    2020 <radfg+0xf00>
testb  $0x1,0x10(%rsp)
je     20cc <radfg+0xfac>
lea    (%rax,%r14,1),%rbx
mov    0x1b0(%rsp),%rsi
movupd (%rsi,%rbx,8),%xmm0
movupd 0x10(%rsi,%rbx,8),%xmm1
mov    0x1c0(%rsp),%rbx
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm0,0x10(%rbx,%rax,8)
mov    0x20(%rsp),%rax
mov    %rax,%rbx
cmp    %r10,%rax
mov    0x30(%rsp),%r8
je     1f20 <radfg+0xe00>
jmp    1f87 <radfg+0xe67>
xor    %eax,%eax
testb  $0x1,0x10(%rsp)
jne    208f <radfg+0xf6f>
jmp    20cc <radfg+0xfac>
mov    $0x1,%al
mov    %eax,0x10(%rsp)
mov    0x4(%rsp),%r15d
mov    0x28(%rsp),%rbx
cmp    %r15d,%ebx
jl     1570 <radfg+0x450>
test   %r15d,%r15d
jle    23b2 <radfg+0x1292>
mov    0x38(%rsp),%rax
mov    %eax,%r12d
imul   %ebx,%r12d
movslq %ebx,%r9
mov    %r15d,%r13d
mov    %ebx,%edi
mov    0x80(%rsp),%r10
lea    (%r10,%rdi,8),%rbp
mov    %rbp,0x60(%rsp)
mov    %edi,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,0x48(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,0x40(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
mov    %rbp,%rdx
mov    %rbp,0x50(%rsp)
and    %rbp,%rax
mov    %rax,0x30(%rsp)
mov    %edi,%ecx
and    $0x3,%ecx
mov    0x1b8(%rsp),%r14
lea    0x30(%r14),%r8
mov    %r9,0x8(%rsp)
lea    0x0(,%r9,8),%r9
lea    0x30(%r10),%rax
mov    %rax,0x78(%rsp)
lea    0x18(%r10),%rax
mov    %rax,0x18(%rsp)
xor    %r11d,%r11d
xor    %r10d,%r10d
jmp    21c6 <radfg+0x10a6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r9,%r8
add    %r12d,%r11d
add    %r9,%r14
cmp    %r13,%r10
je     23b2 <radfg+0x1292>
test   %ebx,%ebx
jle    21b0 <radfg+0x1090>
movslq %r11d,%rsi
cmp    $0x4,%ebx
jae    21e0 <radfg+0x10c0>
xor    %edx,%edx
jmp    2310 <radfg+0x11f0>
nopl   0x0(%rax)
mov    %rsi,0x20(%rsp)
mov    %r12d,%eax
imul   %r10d,%eax
mov    %r10,%rdx
imul   0x8(%rsp),%rdx
lea    (%rdx,%rdi,1),%rbx
cltq
mov    0x80(%rsp),%rsi
lea    (%rsi,%rax,8),%rbp
mov    0x1b8(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
cmp    %rbx,%rbp
mov    %rsi,%rbp
jae    2240 <radfg+0x1120>
mov    0x60(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
cmp    %rax,%rbx
jae    2240 <radfg+0x1120>
xor    %edx,%edx
mov    0x20(%rsp),%rsi
jmp    2310 <radfg+0x11f0>
cmpq   $0x0,0x40(%rsp)
je     23a0 <radfg+0x1280>
mov    0x78(%rsp),%rax
mov    0x20(%rsp),%rsi
lea    (%rax,%rsi,8),%r15
mov    0x30(%rsp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%r8,%rbx,8),%xmm0
movups -0x20(%r8,%rbx,8),%xmm1
movups %xmm0,-0x30(%r15,%rbx,8)
movups %xmm1,-0x20(%r15,%rbx,8)
movupd -0x10(%r8,%rbx,8),%xmm0
movupd (%r8,%rbx,8),%xmm1
movupd %xmm0,-0x10(%r15,%rbx,8)
movupd %xmm1,(%r15,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    2270 <radfg+0x1150>
testb  $0x1,0x50(%rsp)
je     22e1 <radfg+0x11c1>
mov    %r12d,%eax
imul   %r10d,%eax
cltq
add    %rbx,%rdx
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
add    %rbx,%rax
mov    0x80(%rsp),%rdx
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    0x48(%rsp),%rax
mov    %rax,%rdx
cmp    %rdi,%rax
mov    0x4(%rsp),%r15d
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rsi
je     21b0 <radfg+0x1090>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rbx
not    %rbx
add    %rdi,%rbx
test   %rcx,%rcx
je     2345 <radfg+0x1225>
mov    0x80(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rcx,%rbp
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbp
jne    2330 <radfg+0x1210>
cmp    $0x3,%rbx
mov    0x28(%rsp),%rbx
jb     21b0 <radfg+0x1090>
mov    0x18(%rsp),%rax
lea    (%rax,%rsi,8),%rax
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rdx,8)
movsd  0x10(%r14,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rdx,8)
movsd  0x18(%r14,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    2360 <radfg+0x1240>
jmp    21b0 <radfg+0x1090>
xor    %ebx,%ebx
testb  $0x1,0x50(%rsp)
jne    22b3 <radfg+0x1193>
jmp    22e1 <radfg+0x11c1>
cmpb   $0x0,0x10(%rsp)
je     24bb <radfg+0x139b>
mov    0x28(%rsp),%rdx
movslq %edx,%rbx
mov    0x38(%rsp),%rax
movslq %eax,%rcx
mov    0x5c(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%edi
cmovge %esi,%edi
mov    %rdi,0x8(%rsp)
movslq %r15d,%r14
mov    %r15d,%esi
mov    %rsi,0x18(%rsp)
lea    -0x1(%rcx),%rbp
imul   %rbx,%r14
imul   %r14,%rbp
shl    $0x3,%rbp
shl    $0x3,%r14
lea    0x0(,%rbx,8),%rdi
imul   %rbx,%rcx
shl    $0x4,%rbx
mov    0x80(%rsp),%rsi
mov    %rbx,0x20(%rsp)
lea    (%rsi,%rbx,1),%r9
shl    $0x3,%rcx
lea    (%rdx,%rdx,1),%r11d
lea    (%rdx,%rdx,1),%r12d
add    $0xffffffff,%r12d
mov    %eax,%esi
imul   %edx,%esi
mov    $0x1,%r13d
mov    %r14,%rax
mov    0x80(%rsp),%rdx
jmp    246e <radfg+0x134e>
nopl   0x0(%rax)
add    $0x1,%r13
sub    %r14,%rbp
add    0x20(%rsp),%r9
add    %r11d,%r12d
add    %r14,%rax
cmp    0x8(%rsp),%r13
mov    0x4(%rsp),%r15d
je     24bb <radfg+0x139b>
test   %r15d,%r15d
jle    2450 <radfg+0x1330>
mov    0x18(%rsp),%rbx
mov    %r12d,%r8d
mov    %r9,%r15
mov    0x1b8(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
movsd  (%r10,%rax,1),%xmm0
movslq %r8d,%r8
movsd  %xmm0,(%rdx,%r8,8)
movsd  (%r10,%rbp,1),%xmm0
movsd  %xmm0,(%r15)
add    %rdi,%r10
add    %rcx,%r15
add    %esi,%r8d
add    $0xffffffffffffffff,%rbx
jne    2490 <radfg+0x1370>
jmp    2450 <radfg+0x1330>
mov    0x28(%rsp),%rbx
cmp    $0x1,%ebx
je     290c <radfg+0x17ec>
cmp    %r15d,0x94(%rsp)
jge    270c <radfg+0x15ec>
cmpb   $0x0,0x10(%rsp)
je     290c <radfg+0x17ec>
movslq %ebx,%rdi
mov    0x38(%rsp),%rdx
movslq %edx,%rcx
movslq %r15d,%rax
mov    0x5c(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%ebp
cmovge %esi,%ebp
mov    %rbp,0x78(%rsp)
mov    %r15d,%esi
mov    %rsi,0x60(%rsp)
lea    (%rbx,%rbx,1),%esi
mov    %esi,0x70(%rsp)
imul   %ebx,%edx
mov    %rdx,0x38(%rsp)
lea    (%rbx,%rbx,1),%edx
add    $0xfffffffd,%edx
mov    %edx,0x50(%rsp)
mov    %rdi,%rsi
shl    $0x4,%rsi
mov    0x80(%rsp),%rdx
mov    %rsi,0x88(%rsp)
add    %rsi,%rdx
add    $0x10,%rdx
mov    %rdx,0x10(%rsp)
mov    %rcx,%rbp
imul   %rdi,%rbp
shl    $0x3,%rbp
add    $0xffffffffffffffff,%rcx
imul   %rdi,%rax
imul   %rax,%rcx
mov    0x1b8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x30(%rsp)
lea    0x0(,%rax,8),%rcx
mov    %rcx,0x98(%rsp)
neg    %rcx
mov    %rcx,0xb0(%rsp)
mov    %rdi,0x8(%rsp)
lea    0x0(,%rdi,8),%rdi
lea    (%rdx,%rax,8),%rax
add    $0x10,%rax
mov    %rax,0x48(%rsp)
mov    $0x1,%ecx
mov    %ebx,%eax
mov    %ebx,0x18(%rsp)
mov    0x38(%rsp),%r13
mov    0x80(%rsp),%r14
jmp    2626 <radfg+0x1506>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
mov    0x70(%rsp),%eax
add    %eax,0x18(%rsp)
add    %eax,0x50(%rsp)
mov    0x10(%rsp),%rax
add    0x88(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xb0(%rsp),%rax
add    %rax,0x30(%rsp)
mov    0x48(%rsp),%rax
add    0x98(%rsp),%rax
mov    %rax,0x48(%rsp)
cmp    0x78(%rsp),%rcx
mov    0x28(%rsp),%rbx
je     290c <radfg+0x17ec>
mov    %rcx,0x40(%rsp)
cmp    $0x3,%ebx
jl     25d0 <radfg+0x14b0>
mov    $0x2,%ecx
mov    0x48(%rsp),%r8
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x50(%rsp),%r12d
jmp    2676 <radfg+0x1556>
add    $0x2,%rcx
add    $0xfffffffe,%r12d
addq   $0x10,0x20(%rsp)
add    $0x10,%rsi
add    $0x10,%r8
cmp    0x8(%rsp),%rcx
mov    0x4(%rsp),%r15d
jge    25d0 <radfg+0x14b0>
test   %r15d,%r15d
jle    2650 <radfg+0x1530>
mov    0x8(%rsp),%rax
sub    %rcx,%rax
mov    0x60(%rsp),%rdx
xor    %r9d,%r9d
mov    0x20(%rsp),%r15
mov    %r12d,%r11d
mov    0x18(%rsp),%ebx
mov    %ebx,%r10d
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r8,%r9,1),%xmm0
addsd  -0x8(%rsi,%r9,1),%xmm0
movsd  %xmm0,-0x8(%r15)
movsd  -0x8(%r8,%r9,1),%xmm0
subsd  -0x8(%rsi,%r9,1),%xmm0
movslq %r11d,%r11
movsd  %xmm0,(%r14,%r11,8)
movsd  (%r8,%r9,1),%xmm0
addsd  (%rsi,%r9,1),%xmm0
movsd  %xmm0,(%r15)
movsd  (%rsi,%r9,1),%xmm0
subsd  (%r8,%r9,1),%xmm0
movslq %r10d,%r10
lea    (%rax,%r10,1),%rbx
movsd  %xmm0,(%r14,%rbx,8)
add    %r13d,%r10d
add    %r13d,%r11d
add    %rbp,%r15
add    %rdi,%r9
add    $0xffffffffffffffff,%rdx
jne    26a0 <radfg+0x1580>
jmp    2650 <radfg+0x1530>
cmpb   $0x0,0x10(%rsp)
je     290c <radfg+0x17ec>
movslq %ebx,%rax
mov    0x38(%rsp),%r9
movslq %r9d,%rcx
movslq %r15d,%rdi
mov    0x5c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%esi
cmovge %edx,%esi
mov    %rsi,0x40(%rsp)
mov    %r15d,%r13d
mov    %rax,%rsi
shl    $0x4,%rsi
mov    0x80(%rsp),%rdx
mov    %rsi,0x50(%rsp)
add    %rdx,%rsi
mov    %rsi,0x8(%rsp)
mov    %rcx,%rbp
imul   %rax,%rbp
shl    $0x3,%rbp
add    $0xffffffffffffffff,%rcx
imul   %rax,%rdi
imul   %rdi,%rcx
mov    0x1b8(%rsp),%r8
lea    (%r8,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
lea    0x0(,%rdi,8),%rcx
mov    %rcx,0x30(%rsp)
neg    %rcx
mov    %rcx,0x78(%rsp)
lea    0x0(,%rax,8),%rsi
lea    (%r8,%rdi,8),%rcx
mov    %rcx,0x18(%rsp)
lea    (%rbx,%rbx,1),%ecx
mov    %ecx,0x70(%rsp)
lea    (%rbx,%rbx,1),%ecx
add    $0xfffffffd,%ecx
mov    %ecx,0x10(%rsp)
imul   %ebx,%r9d
lea    -0x10(%rdx),%rcx
mov    %rcx,0x20(%rsp)
mov    $0x1,%edx
mov    %ebx,%ecx
mov    %ebx,0x48(%rsp)
jmp    282d <radfg+0x170d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdx
add    $0x1,%rdx
mov    0x8(%rsp),%rcx
add    0x50(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    0x78(%rsp),%rcx
add    %rcx,0x60(%rsp)
mov    0x18(%rsp),%rcx
add    0x30(%rsp),%rcx
mov    %rcx,0x18(%rsp)
mov    0x70(%rsp),%ecx
add    %ecx,0x10(%rsp)
add    %ecx,0x48(%rsp)
cmp    0x40(%rsp),%rdx
mov    0x4(%rsp),%r15d
je     290c <radfg+0x17ec>
mov    %rdx,0x38(%rsp)
test   %r15d,%r15d
jle    27e0 <radfg+0x16c0>
mov    0x48(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x18(%rsp),%rdi
mov    0x60(%rsp),%r15
mov    0x8(%rsp),%r14
xor    %r12d,%r12d
jmp    2883 <radfg+0x1763>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    %rbp,%r14
add    %rsi,%r15
add    %rsi,%rdi
mov    %r9,%rbx
add    %ebx,%r8d
add    %ebx,%ecx
cmp    %r13,%r12
mov    0x28(%rsp),%rbx
je     27e0 <radfg+0x16c0>
cmp    $0x3,%ebx
jl     2860 <radfg+0x1740>
movslq %ecx,%rbx
add    %rax,%rbx
mov    0x20(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
mov    $0x2,%r11d
mov    %r8d,%r10d
movsd  -0x8(%rdi,%r11,8),%xmm0
addsd  -0x8(%r15,%r11,8),%xmm0
movsd  %xmm0,-0x8(%r14,%r11,8)
movsd  -0x8(%rdi,%r11,8),%xmm0
subsd  -0x8(%r15,%r11,8),%xmm0
movslq %r10d,%r10
mov    0x80(%rsp),%rdx
movsd  %xmm0,(%rdx,%r10,8)
movsd  (%rdi,%r11,8),%xmm0
addsd  (%r15,%r11,8),%xmm0
movsd  %xmm0,(%r14,%r11,8)
movsd  (%r15,%r11,8),%xmm0
subsd  (%rdi,%r11,8),%xmm0
movsd  %xmm0,(%rbx)
add    $0x2,%r11
add    $0xfffffffe,%r10d
add    $0xfffffffffffffff0,%rbx
cmp    %rax,%r11
jl     28a0 <radfg+0x1780>
jmp    2860 <radfg+0x1740>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r12,%rdi,8),%xmm1
movups 0x10(%r12,%rdi,8),%xmm2
movups %xmm1,(%rdx,%rdi,8)
movups %xmm2,0x10(%rdx,%rdi,8)
movups 0x20(%r12,%rdi,8),%xmm1
movups 0x30(%r12,%rdi,8),%xmm2
movups %xmm1,0x20(%rdx,%rdi,8)
movups %xmm2,0x30(%rdx,%rdi,8)
movups 0x40(%r12,%rdi,8),%xmm1
movups 0x50(%r12,%rdi,8),%xmm2
movups %xmm1,0x40(%rdx,%rdi,8)
movups %xmm2,0x50(%rdx,%rdi,8)
movupd 0x60(%r12,%rdi,8),%xmm1
movupd 0x70(%r12,%rdi,8),%xmm2
movupd %xmm1,0x60(%rdx,%rdi,8)
movupd %xmm2,0x70(%rdx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2930 <radfg+0x1810>
test   %r8,%r8
je     29cf <radfg+0x18af>
lea    (%rdx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%r12,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebx,%ebx
nop
movupd -0x10(%rdi,%rbx,1),%xmm1
movupd (%rdi,%rbx,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rbx,1)
movupd %xmm2,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    29b0 <radfg+0x1890>
cmp    %rax,%rcx
mov    0x38(%rsp),%r14
jne    12de <radfg+0x1be>
cmp    $0x2,%r14d
mov    0x28(%rsp),%rbx
jl     2eb9 <radfg+0x1d99>
movslq %ebx,%rax
movslq 0x4(%rsp),%r12
mov    %r12d,%ebx
mov    %ebx,%ecx
and    $0x3,%ecx
mov    %rcx,0x40(%rsp)
mov    %ebx,%r13d
and    $0xfffffffc,%r13d
lea    0x2(%r12),%rdx
imul   %rax,%rdx
mov    0x1b8(%rsp),%rcx
lea    (%rcx,%rdx,8),%rsi
mov    %rsi,0x88(%rsp)
mov    %r12,%rdi
imul   %rax,%rdi
lea    0x0(,%rdi,8),%rsi
mov    %rsi,0x30(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,0x98(%rsp)
lea    0x0(,%rdx,8),%rsi
add    %rbp,%rsi
lea    0x1(%r12),%rdx
imul   %rax,%rdx
lea    (%rcx,%rdx,8),%r9
lea    0x0(,%rdx,8),%r8
add    %rbp,%r8
lea    0x3(%r12),%rdx
imul   %rax,%rdx
lea    (%rcx,%rdx,8),%r10
lea    0x0(,%rdx,8),%r14
add    %rbp,%r14
lea    0x0(%rbp,%rdi,8),%r15
lea    (%rcx,%rdi,8),%r11
mov    0x1c8(%rsp),%rdx
mov    0x38(%rsp),%ecx
mov    %rcx,0x48(%rsp)
mov    %rbx,0x20(%rsp)
lea    -0x1(%rbx),%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rax,8),%rdi
mov    $0x1,%ecx
xor    %ebx,%ebx
mov    %rbx,0x18(%rsp)
mov    %r12,0x50(%rsp)
mov    %r12,0x8(%rsp)
mov    %rdi,0x78(%rsp)
jmp    2b02 <radfg+0x19e2>
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
mov    0x18(%rsp),%rbx
add    0x30(%rsp),%rbx
mov    %rbx,0x18(%rsp)
mov    0x8(%rsp),%rbx
add    0x50(%rsp),%rbx
mov    %rbx,0x8(%rsp)
cmp    0x48(%rsp),%rcx
je     2bcb <radfg+0x1aab>
mov    %rcx,0x10(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    2ad0 <radfg+0x19b0>
cmpq   $0x3,0x70(%rsp)
jae    2b20 <radfg+0x1a00>
xor    %r12d,%r12d
jmp    2b7a <radfg+0x1a5a>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rbx
xor    %r12d,%r12d
mov    0x88(%rsp),%rcx
mov    0x98(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,1),%xmm1
movsd  %xmm1,(%r11,%rbx,1)
movsd  (%r8,%rbx,1),%xmm1
movsd  %xmm1,(%r9,%rbx,1)
movsd  (%rsi,%rbx,1),%xmm1
movsd  %xmm1,(%rcx,%rbx,1)
movsd  (%r14,%rbx,1),%xmm1
movsd  %xmm1,(%r10,%rbx,1)
add    $0x4,%r12
add    %rdi,%rbx
cmp    %r12,%r13
jne    2b40 <radfg+0x1a20>
cmpq   $0x0,0x40(%rsp)
mov    0x1b8(%rsp),%rcx
mov    0x78(%rsp),%rdi
je     2ad0 <radfg+0x19b0>
add    0x8(%rsp),%r12
imul   %rdi,%r12
mov    0x40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r12,1),%xmm1
movsd  %xmm1,(%rcx,%r12,1)
add    %rdi,%r12
add    $0xffffffffffffffff,%rbx
jne    2bb0 <radfg+0x1a90>
jmp    2ad0 <radfg+0x19b0>
mov    0x94(%rsp),%ecx
cmp    0x4(%rsp),%ecx
jle    2d4b <radfg+0x1c2b>
cmpl   $0x2,0x38(%rsp)
mov    0x28(%rsp),%rbx
jl     2eb9 <radfg+0x1d99>
movslq 0x4(%rsp),%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%r8
mov    %rcx,0x70(%rsp)
add    %rcx,%r8
mov    %r8,0x8(%rsp)
mov    %rax,%r13
shl    $0x20,%r13
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x10(%rsp)
mov    0x1b8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x40(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x30(%rsp)
movl   $0xffffffff,0x50(%rsp)
ff
mov    $0x1,%esi
movabs $0x200000000,%r8
jmp    2c96 <radfg+0x1b76>
nopl   (%rax)
mov    0x18(%rsp),%rsi
add    $0x1,%rsi
add    %ebx,0x50(%rsp)
mov    0x8(%rsp),%rcx
add    0x70(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    0x30(%rsp),%rcx
add    %rcx,0x10(%rsp)
add    %rcx,0x40(%rsp)
cmp    0x48(%rsp),%rsi
je     2eb9 <radfg+0x1d99>
mov    %rsi,0x18(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    2c60 <radfg+0x1b40>
movslq 0x50(%rsp),%rcx
lea    (%rdx,%rcx,8),%rcx
mov    0x40(%rsp),%rsi
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%r10
xor    %r14d,%r14d
jmp    2cd9 <radfg+0x1bb9>
nop
add    $0x1,%r14
add    %r13,%r10
add    %rdi,%r12
add    %rdi,%rsi
cmp    0x20(%rsp),%r14
mov    0x28(%rsp),%rbx
je     2c60 <radfg+0x1b40>
cmp    $0x3,%ebx
mov    0x1b8(%rsp),%r15
jl     2cc0 <radfg+0x1ba0>
mov    $0x2,%ebx
mov    %r10,%r9
xchg   %ax,%ax
mov    %r9,%r11
sar    $0x1d,%r11
movsd  (%rcx,%rbx,8),%xmm1
mulsd  (%r12,%rbx,8),%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm2
mulsd  0x0(%rbp,%r11,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%r11,1)
movsd  0x0(%rbp,%r11,1),%xmm1
mulsd  (%rcx,%rbx,8),%xmm1
movsd  -0x8(%rcx,%rbx,8),%xmm2
mulsd  (%r12,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,8)
add    $0x2,%rbx
add    %r8,%r9
cmp    %rax,%rbx
jl     2cf0 <radfg+0x1bd0>
jmp    2cc0 <radfg+0x1ba0>
cmpl   $0x2,0x38(%rsp)
mov    0x28(%rsp),%rbx
jl     2eb9 <radfg+0x1d99>
mov    0x4(%rsp),%ecx
movslq %ecx,%rsi
imul   %ebx,%ecx
mov    %rcx,0x30(%rsp)
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
imul   %rax,%rsi
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x10(%rsp)
mov    0x1b8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x40(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x50(%rsp)
mov    $0xffffffff,%r13d
mov    $0x1,%esi
mov    0x28(%rsp),%r14
jmp    2df7 <radfg+0x1cd7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rsi
add    $0x1,%rsi
mov    0x28(%rsp),%rbx
add    %ebx,%r13d
mov    0x8(%rsp),%ecx
add    0x30(%rsp),%ecx
mov    %ecx,0x8(%rsp)
mov    0x50(%rsp),%rcx
add    %rcx,0x10(%rsp)
add    %rcx,0x40(%rsp)
cmp    0x48(%rsp),%rsi
je     2eb9 <radfg+0x1d99>
mov    %rsi,0x18(%rsp)
cmp    $0x3,%ebx
jl     2dc0 <radfg+0x1ca0>
movslq %r13d,%r10
mov    $0x2,%esi
mov    0x40(%rsp),%rcx
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%r11d
jmp    2e38 <radfg+0x1d18>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rsi
add    $0x2,%r11d
add    $0x10,%rdi
add    $0x10,%rcx
mov    %r9,%r10
cmp    %rax,%rsi
jge    2dc0 <radfg+0x1ca0>
lea    0x2(%r10),%r9
cmpl   $0x0,0x4(%rsp)
mov    0x1b8(%rsp),%r15
jle    2e20 <radfg+0x1d00>
mov    $0x2,%ebx
mov    0x20(%rsp),%r12
mov    %r11d,%r8d
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rdx,%r10,8),%xmm1
movsd  (%rdx,%r9,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm2
movslq %r8d,%r8
mulsd  0x0(%rbp,%r8,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%r8,8)
movsd  0x0(%rbp,%r8,8),%xmm1
mulsd  (%rdx,%r9,8),%xmm1
movsd  0x8(%rdx,%r10,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
add    %r14d,%r8d
add    %rax,%rbx
add    $0xffffffffffffffff,%r12
jne    2e60 <radfg+0x1d40>
jmp    2e20 <radfg+0x1d00>
mov    0x4(%rsp),%r15d
cmp    %r15d,0x94(%rsp)
jge    303c <radfg+0x1f1c>
mov    0x38(%rsp),%rcx
cmp    $0x3,%ecx
jl     318a <radfg+0x206a>
movslq %ebx,%rax
mov    %ecx,%esi
movslq %r15d,%rdi
mov    0x5c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x18(%rsp)
mov    %r15d,%edx
add    $0xffffffffffffffff,%rsi
imul   %rax,%rdi
imul   %rdi,%rsi
mov    0x1b8(%rsp),%r8
lea    (%r8,%rsi,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rdi,8),%r13
mov    %r13,0x10(%rsp)
neg    %r13
lea    0x0(,%rax,8),%rcx
lea    0x10(,%rsi,8),%rsi
add    %rbp,%rsi
mov    %rsi,0x8(%rsp)
lea    (%r8,%rdi,8),%r9
add    $0x10,%r9
lea    0x10(,%rdi,8),%r8
add    %rbp,%r8
mov    $0x1,%esi
jmp    2f8c <radfg+0x1e6c>
nopl   0x0(%rax)
add    $0x1,%rsi
mov    %r13,%rdi
add    %r13,0x20(%rsp)
add    %r13,0x8(%rsp)
mov    0x10(%rsp),%rdi
add    %rdi,%r9
add    %rdi,%r8
cmp    0x18(%rsp),%rsi
mov    0x28(%rsp),%rbx
je     146d <radfg+0x34d>
cmp    $0x3,%ebx
jl     2f60 <radfg+0x1e40>
mov    $0x2,%edi
mov    %r8,%r15
mov    %r9,%r12
mov    0x8(%rsp),%r14
mov    0x20(%rsp),%r11
jmp    2fc9 <radfg+0x1ea9>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdi
add    $0x10,%r11
add    $0x10,%r14
add    $0x10,%r12
add    $0x10,%r15
cmp    %rax,%rdi
jge    2f60 <radfg+0x1e40>
cmpl   $0x0,0x4(%rsp)
jle    2fb0 <radfg+0x1e90>
mov    %rdx,%rbx
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r12,%r10,1),%xmm1
addsd  -0x8(%r11,%r10,1),%xmm1
movsd  %xmm1,-0x8(%r15,%r10,1)
movsd  (%r12,%r10,1),%xmm1
subsd  (%r11,%r10,1),%xmm1
movsd  %xmm1,-0x8(%r14,%r10,1)
movsd  (%r12,%r10,1),%xmm1
addsd  (%r11,%r10,1),%xmm1
movsd  %xmm1,(%r15,%r10,1)
movsd  -0x8(%r11,%r10,1),%xmm1
subsd  -0x8(%r12,%r10,1),%xmm1
movsd  %xmm1,(%r14,%r10,1)
add    %rcx,%r10
add    $0xffffffffffffffff,%rbx
jne    2fe0 <radfg+0x1ec0>
jmp    2fb0 <radfg+0x1e90>
mov    0x38(%rsp),%rcx
cmp    $0x3,%ecx
jl     318a <radfg+0x206a>
movslq %ebx,%rax
mov    %ecx,%esi
movslq %r15d,%rdi
mov    0x5c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x8(%rsp)
mov    %r15d,%edx
add    $0xffffffffffffffff,%rsi
imul   %rax,%rdi
imul   %rdi,%rsi
mov    0x1b8(%rsp),%r8
lea    (%r8,%rsi,8),%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rdi,8),%r13
mov    %r13,0x18(%rsp)
neg    %r13
lea    0x0(,%rax,8),%rcx
lea    0x0(,%rsi,8),%r9
add    %rbp,%r9
lea    (%r8,%rdi,8),%r8
lea    0x0(,%rdi,8),%r15
add    %rbp,%r15
mov    $0x1,%esi
jmp    30e5 <radfg+0x1fc5>
nop
add    $0x1,%rsi
mov    %r13,%rdi
add    %r13,0x20(%rsp)
add    %r13,%r9
mov    0x18(%rsp),%rdi
add    %rdi,%r8
add    %rdi,%r15
cmp    0x8(%rsp),%rsi
je     146d <radfg+0x34d>
cmpl   $0x0,0x4(%rsp)
jle    30c0 <radfg+0x1fa0>
mov    %r15,%rdi
mov    %r8,%r12
mov    %r9,%r14
mov    0x20(%rsp),%r11
xor    %r10d,%r10d
jmp    311a <radfg+0x1ffa>
nop
add    $0x1,%r10
add    %rcx,%r11
add    %rcx,%r14
add    %rcx,%r12
add    %rcx,%rdi
cmp    %rdx,%r10
mov    0x28(%rsp),%rbx
je     30c0 <radfg+0x1fa0>
cmp    $0x3,%ebx
jl     3100 <radfg+0x1fe0>
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%r12,%rbx,8),%xmm1
addsd  -0x8(%r11,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%rbx,8)
movsd  (%r12,%rbx,8),%xmm1
subsd  (%r11,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rbx,8)
movsd  (%r12,%rbx,8),%xmm1
addsd  (%r11,%rbx,8),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
movsd  -0x8(%r11,%rbx,8),%xmm1
subsd  -0x8(%r12,%rbx,8),%xmm1
movsd  %xmm1,(%r14,%rbx,8)
add    $0x2,%rbx
cmp    %rax,%rbx
jl     3130 <radfg+0x2010>
jmp    3100 <radfg+0x1fe0>
movl   $0x0,0x10(%rsp)
cmp    %r15d,%ebx
jl     1570 <radfg+0x450>
jmp    210b <radfg+0xfeb>

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

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