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


x86 assembly (clang, -O0):
<radbg>:
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    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1243 <radbg+0x123>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123e <radbg+0x11e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    122b <radbg+0x10b>
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  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%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    11dd <radbg+0xbd>
jmp    1230 <radbg+0x110>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ca <radbg+0xaa>
jmp    12c3 <radbg+0x1a3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12be <radbg+0x19e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ab <radbg+0x18b>
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  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%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    125d <radbg+0x13d>
jmp    12b0 <radbg+0x190>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    124a <radbg+0x12a>
jmp    12c3 <radbg+0x1a3>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13da <radbg+0x2ba>
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    13c7 <radbg+0x2a7>
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  (%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
addsd  (%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    -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  (%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ef <radbg+0x1cf>
jmp    13cc <radbg+0x2ac>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ca <radbg+0x1aa>
cmpl   $0x1,-0x4(%rbp)
je     1884 <radbg+0x764>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1639 <radbg+0x519>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1634 <radbg+0x514>
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    1621 <radbg+0x501>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    160e <radbg+0x4ee>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1429 <radbg+0x309>
jmp    1613 <radbg+0x4f3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1416 <radbg+0x2f6>
jmp    1626 <radbg+0x506>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13fa <radbg+0x2da>
jmp    187f <radbg+0x75f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    187a <radbg+0x75a>
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    1867 <radbg+0x747>
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    1854 <radbg+0x734>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%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    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1678 <radbg+0x558>
jmp    1859 <radbg+0x739>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    165c <radbg+0x53c>
jmp    186c <radbg+0x74c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1640 <radbg+0x520>
jmp    187f <radbg+0x75f>
jmp    1884 <radbg+0x764>
movsd  0x177c(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b3f <radbg+0xa1f>
mov    -0x8(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x60(%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  -0x60(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19c7 <radbg+0x8a7>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    0x20(%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    0x10(%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  -0x60(%rbp),%xmm0
mov    0x20(%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    0x10(%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    1931 <radbg+0x811>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b2c <radbg+0xa0c>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x68(%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  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b19 <radbg+0x9f9>
movsd  -0x78(%rbp),%xmm0
mov    0x20(%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    0x10(%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  -0x68(%rbp),%xmm0
mov    0x20(%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    0x10(%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    1a7b <radbg+0x95b>
jmp    1b1e <radbg+0x9fe>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19f6 <radbg+0x8d6>
jmp    1b31 <radbg+0xa11>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18a0 <radbg+0x780>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1bb0 <radbg+0xa90>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b9d <radbg+0xa7d>
mov    0x20(%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    1b59 <radbg+0xa39>
jmp    1ba2 <radbg+0xa82>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b46 <radbg+0xa26>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ca8 <radbg+0xb88>
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    1c95 <radbg+0xb75>
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    -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
subsd  (%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    -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    -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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bd3 <radbg+0xab3>
jmp    1c9a <radbg+0xb7a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bb7 <radbg+0xa97>
cmpl   $0x1,-0x4(%rbp)
jne    1cb7 <radbg+0xb97>
jmp    2550 <radbg+0x1430>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1edf <radbg+0xdbf>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1eda <radbg+0xdba>
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    1ec7 <radbg+0xda7>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1eb4 <radbg+0xd94>
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cfc <radbg+0xbdc>
jmp    1eb9 <radbg+0xd99>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ce9 <radbg+0xbc9>
jmp    1ecc <radbg+0xdac>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ccd <radbg+0xbad>
jmp    20f8 <radbg+0xfd8>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    20f3 <radbg+0xfd3>
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    20e0 <radbg+0xfc0>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    20cd <radbg+0xfad>
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
addsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
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),%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
subsd  (%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f15 <radbg+0xdf5>
jmp    20d2 <radbg+0xfb2>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f02 <radbg+0xde2>
jmp    20e5 <radbg+0xfc5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ee6 <radbg+0xdc6>
jmp    20f8 <radbg+0xfd8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2133 <radbg+0x1013>
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    20ff <radbg+0xfdf>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    21b2 <radbg+0x1092>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    219f <radbg+0x107f>
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    -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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    214d <radbg+0x102d>
jmp    21a4 <radbg+0x1084>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    213a <radbg+0x101a>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     238a <radbg+0x126a>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2385 <radbg+0x1265>
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    2372 <radbg+0x1252>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    235f <radbg+0x123f>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -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    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),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2211 <radbg+0x10f1>
jmp    2364 <radbg+0x1244>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    21f5 <radbg+0x10d5>
jmp    2377 <radbg+0x1257>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    21d0 <radbg+0x10b0>
jmp    2550 <radbg+0x1430>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    254b <radbg+0x142b>
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    2538 <radbg+0x1418>
mov    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2525 <radbg+0x1405>
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    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),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -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    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),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    23ce <radbg+0x12ae>
jmp    252a <radbg+0x140a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    23b5 <radbg+0x1295>
jmp    253d <radbg+0x141d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2399 <radbg+0x1279>
jmp    2550 <radbg+0x1430>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x98(%rsp)
mov    %r8,%rbp
mov    %ecx,0xb0(%rsp)
mov    %edx,%ebx
mov    %esi,%r15d
mov    %edi,%r14d
cvtsi2sd %esi,%xmm1
movsd  0x1ea9(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x80(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%r14),%ecx
shr    $0x1f,%ecx
lea    0x1(%r15),%eax
shr    $0x1f,%eax
mov    %r15,0x30(%rsp)
add    %r15d,%eax
add    $0x1,%eax
mov    %eax,0x4c(%rsp)
cmp    %ebx,%r14d
mov    %ebx,0xc(%rsp)
mov    %r14,0x18(%rsp)
mov    %rcx,0x40(%rsp)
jge    129a <radbg+0x17a>
test   %r14d,%r14d
movapd 0x80(%rsp),%xmm11
jle    1522 <radbg+0x402>
mov    0x30(%rsp),%r10
mov    0x18(%rsp),%rax
imul   %eax,%r10d
mov    %eax,%ecx
mov    %ebx,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    (%r10,%r10,1),%r14d
mov    %rcx,%r15
shl    $0x4,%r15
xor    %edx,%edx
mov    0x1c8(%rsp),%r9
jmp    1211 <radbg+0xf1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
add    $0x8,%r9
cmp    %rcx,%rdx
je     1522 <radbg+0x402>
test   %ebx,%ebx
jle    1200 <radbg+0xe0>
cmp    $0x1,%ebx
jne    1220 <radbg+0x100>
xor    %eax,%eax
jmp    1265 <radbg+0x145>
xchg   %ax,%ax
xor    %esi,%esi
mov    %r9,%rdi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
lea    (%rdx,%rsi,1),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm1,(%rdi)
lea    (%r10,%rsi,1),%ebx
movslq %ebx,%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x2,%rax
add    %r14d,%esi
add    %r15,%rdi
cmp    %rax,%r11
jne    1230 <radbg+0x110>
test   $0x1,%r8b
mov    0xc(%rsp),%ebx
je     1200 <radbg+0xe0>
mov    %r10d,%esi
imul   %eax,%esi
movslq %esi,%rsi
add    %rdx,%rsi
movsd  0x0(%rbp,%rsi,8),%xmm1
imul   %rcx,%rax
add    %rdx,%rax
mov    0x1c8(%rsp),%rsi
movsd  %xmm1,(%rsi,%rax,8)
jmp    1200 <radbg+0xe0>
test   %ebx,%ebx
movapd 0x80(%rsp),%xmm11
jle    1522 <radbg+0x402>
mov    0x30(%rsp),%rax
mov    %eax,%r13d
mov    0x18(%rsp),%rax
imul   %eax,%r13d
movslq %eax,%r12
mov    %ebx,%ecx
mov    %eax,%edi
lea    0x0(,%rdi,8),%rax
add    %rbp,%rax
mov    %rax,0x20(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,0x60(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x78(%rsp)
mov    %edi,%edx
and    $0x3,%edx
lea    0x30(%rbp),%rax
mov    %rax,0x70(%rsp)
mov    0x1c8(%rsp),%r15
lea    0x30(%r15),%r14
lea    0x0(,%r12,8),%r10
lea    0x18(%rbp),%rax
mov    %rax,0x58(%rsp)
xor    %r8d,%r8d
xor    %r11d,%r11d
mov    %rdx,0x28(%rsp)
mov    %rcx,0x10(%rsp)
jmp    1356 <radbg+0x236>
add    $0x1,%r11
add    %r13d,%r8d
add    %r10,%r14
add    %r10,%r15
cmp    %rcx,%r11
je     1522 <radbg+0x402>
cmpl   $0x0,0x18(%rsp)
jle    1340 <radbg+0x220>
movslq %r8d,%r9
cmpl   $0x4,0x18(%rsp)
jae    1370 <radbg+0x250>
xor    %ebx,%ebx
jmp    1480 <radbg+0x360>
xchg   %ax,%ax
mov    %r11,%rbx
imul   %r12,%rbx
mov    %r13d,%eax
imul   %r11d,%eax
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
cltq
mov    0x20(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
cmp    %rsi,%rdx
jae    13c3 <radbg+0x2a3>
lea    (%rbx,%rdi,1),%rdx
lea    (%rcx,%rdx,8),%rdx
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rdx,%rax
jae    13c3 <radbg+0x2a3>
xor    %ebx,%ebx
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
jmp    1480 <radbg+0x360>
mov    %r12,%rcx
cmpq   $0x0,0x50(%rsp)
je     1510 <radbg+0x3f0>
mov    0x70(%rsp),%rax
lea    (%rax,%r9,8),%rsi
mov    0x78(%rsp),%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rsi,%rax,8),%xmm1
movups -0x20(%rsi,%rax,8),%xmm2
movups %xmm1,-0x30(%r14,%rax,8)
movups %xmm2,-0x20(%r14,%rax,8)
movupd -0x10(%rsi,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movupd %xmm1,-0x10(%r14,%rax,8)
movupd %xmm2,(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r12
jne    13f0 <radbg+0x2d0>
testb  $0x1,0x60(%rsp)
je     145e <radbg+0x33e>
mov    %r13d,%edx
imul   %r11d,%edx
movslq %edx,%rdx
add    %rax,%rdx
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
add    %rax,%rbx
mov    0x1c8(%rsp),%rax
movupd %xmm1,(%rax,%rbx,8)
movupd %xmm2,0x10(%rax,%rbx,8)
mov    0x38(%rsp),%rax
mov    %rax,%rbx
cmp    %rdi,%rax
mov    %rcx,%r12
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
je     1340 <radbg+0x220>
nopl   0x0(%rax)
mov    %rbx,%rax
not    %rax
add    %rdi,%rax
test   %rdx,%rdx
je     14b5 <radbg+0x395>
lea    0x0(,%r9,8),%rsi
add    %rbp,%rsi
nopl   0x0(%rax)
movsd  (%rsi,%rbx,8),%xmm1
movsd  %xmm1,(%r15,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    14a0 <radbg+0x380>
cmp    $0x3,%rax
mov    0x28(%rsp),%rdx
jb     1340 <radbg+0x220>
mov    0x58(%rsp),%rax
lea    (%rax,%r9,8),%rax
nopl   (%rax)
movsd  -0x18(%rax,%rbx,8),%xmm1
movsd  %xmm1,(%r15,%rbx,8)
movsd  -0x10(%rax,%rbx,8),%xmm1
movsd  %xmm1,0x8(%r15,%rbx,8)
movsd  -0x8(%rax,%rbx,8),%xmm1
movsd  %xmm1,0x10(%r15,%rbx,8)
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,0x18(%r15,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    14d0 <radbg+0x3b0>
jmp    1340 <radbg+0x220>
xor    %eax,%eax
testb  $0x1,0x60(%rsp)
jne    142f <radbg+0x30f>
jmp    145e <radbg+0x33e>
mov    0x18(%rsp),%rax
mov    0x40(%rsp),%rcx
add    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,0xa4(%rsp)
sarl   0x4c(%rsp)
cmpl   $0x3,0x30(%rsp)
jl     1642 <radbg+0x522>
mov    0x30(%rsp),%r10
mov    %r10d,%ecx
mov    0x18(%rsp),%rsi
movslq %esi,%rax
mov    0x4c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%edi
cmovge %edx,%edi
mov    %rdi,0x28(%rsp)
mov    0xc(%rsp),%edx
movslq %edx,%r8
mov    %edx,%edx
mov    %rdx,0x10(%rsp)
lea    -0x1(%rcx),%rdi
imul   %rax,%r8
imul   %r8,%rdi
shl    $0x3,%rdi
shl    $0x3,%r8
lea    0x0(,%rax,8),%rbx
mov    %rax,%r11
shl    $0x4,%r11
lea    (%r11,%rbp,1),%r9
imul   %rcx,%rax
shl    $0x3,%rax
lea    (%rsi,%rsi,1),%ecx
mov    %ecx,0x20(%rsp)
lea    (%rsi,%rsi,1),%r12d
add    $0xffffffff,%r12d
mov    %r10d,%edx
imul   %esi,%edx
mov    $0x1,%r13d
mov    %r8,%r14
jmp    15e9 <radbg+0x4c9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
sub    %r8,%rdi
add    %r8,%r14
add    %r11,%r9
add    0x20(%rsp),%r12d
cmp    0x28(%rsp),%r13
je     1642 <radbg+0x522>
cmpl   $0x0,0xc(%rsp)
jle    15d0 <radbg+0x4b0>
mov    0x10(%rsp),%rsi
mov    %r12d,%ecx
mov    %r9,%r15
mov    0x1c8(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%r14,1)
movsd  (%r15),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%rdi,1)
add    %rbx,%r10
add    %rax,%r15
add    %edx,%ecx
add    $0xffffffffffffffff,%rsi
jne    1610 <radbg+0x4f0>
jmp    15d0 <radbg+0x4b0>
sarl   0xa4(%rsp)
cmpl   $0x1,0x18(%rsp)
mov    0xc(%rsp),%eax
jne    1ea2 <radbg+0xd82>
cmpl   $0x3,0x30(%rsp)
mov    0xb0(%rsp),%r13d
jl     25d9 <radbg+0x14b9>
movapd 0x199c(%rip),%xmm9
xorpd  %xmm0,%xmm9
mov    0x30(%rsp),%rcx
lea    -0x1(%rcx),%eax
imul   %r13d,%eax
movslq %r13d,%r12
movslq %eax,%r8
mov    %ecx,%ecx
mov    0x4c(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%edx
cmovge %eax,%edx
mov    %rdx,0x50(%rsp)
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %rdx,0x170(%rsp)
mov    %r12d,%r14d
lea    -0x1(%rcx),%rbp
imul   %r12,%rbp
mov    %rcx,0xd0(%rsp)
lea    -0x2(%rcx),%rbx
imul   %r12,%rbx
lea    (%r8,%r14,1),%rax
mov    0x1d0(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
mov    %rax,0x148(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm10
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x120(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x138(%rsp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,0x130(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x128(%rsp)
lea    0x0(,%r12,8),%rsi
mov    %rsi,%rax
neg    %rax
mov    %rax,0x60(%rsp)
mov    %r12,%rax
shl    $0x4,%rax
add    %rdi,%rax
mov    %rax,0x158(%rsp)
movsd  0x18af(%rip),%xmm2
movapd 0x18ae(%rip),%xmm8
lea    (%r12,%r14,1),%rax
lea    0x0(%rbp,%r14,1),%rdx
mov    %rdx,0x160(%rsp)
lea    (%r12,%r12,1),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%r14,%r12,2),%rdx
mov    %rdx,0xc8(%rsp)
lea    (%rbx,%r14,1),%rdx
mov    %rdx,0x180(%rsp)
lea    (%rdi,%r14,8),%rdx
mov    %rdx,0xe0(%rsp)
lea    (%rdi,%r12,8),%rdx
mov    %rdx,0xe8(%rsp)
mov    %rax,0xf8(%rsp)
lea    (%rdi,%rax,8),%rax
mov    %rax,0x140(%rsp)
mov    %r8,0xf0(%rsp)
lea    (%rdi,%r8,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x1c0(%rsp),%rax
lea    0x10(%rax,%r12,8),%rdx
lea    0x10(%rax,%rbp,8),%rcx
lea    (%rax,%r12,8),%r8
mov    %rbx,0xa8(%rsp)
lea    (%rdi,%rbx,8),%rdi
mov    %rdi,0x150(%rsp)
lea    (%rax,%rbp,8),%r11
mov    $0x1,%eax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
mov    %r12,0x108(%rsp)
mov    %rbp,0x168(%rsp)
mov    %rbp,0x100(%rsp)
mov    %r12,0x70(%rsp)
mov    %rsi,0x38(%rsp)
jmp    189a <radbg+0x77a>
nopl   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rbp
add    $0x1,%rbp
mov    0x178(%rsp),%rax
add    $0x1,%rax
mov    0x118(%rsp),%rdx
add    %rsi,%rdx
mov    0x110(%rsp),%rcx
add    %rdi,%rcx
sub    %r12,0x100(%rsp)
add    %r12,0x108(%rsp)
add    %rsi,%r8
add    %rdi,%r11
mov    %rbp,0xc0(%rsp)
cmp    0x170(%rsp),%rbp
je     20d9 <radbg+0xfb9>
mov    %rcx,0x110(%rsp)
mov    %rdx,0x118(%rsp)
mov    %rax,0x178(%rsp)
imul   %r12,%rax
lea    (%rax,%r12,1),%rcx
mov    0xf8(%rsp),%rdx
add    %rax,%rdx
mov    0x168(%rsp),%rsi
sub    %rax,%rsi
mov    0x160(%rsp),%rdi
sub    %rax,%rdi
mov    0x1c0(%rsp),%r9
lea    (%r9,%rcx,8),%rax
mov    %rax,0x10(%rsp)
lea    (%r9,%rdx,8),%rax
mov    %rax,0x58(%rsp)
lea    (%r9,%rsi,8),%rax
mov    %rax,0x40(%rsp)
lea    (%r9,%rdi,8),%rax
mov    %rax,0x80(%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   %r13d,%r13d
jle    1c0b <radbg+0xaeb>
cmp    $0x1,%r13d
jne    1950 <radbg+0x830>
xor    %r10d,%r10d
jmp    1b90 <radbg+0xa70>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rbx
mov    0x80(%rsp),%r9
cmp    %r9,%rbx
setb   0x28(%rsp)
mov    0x58(%rsp),%r10
mov    0x40(%rsp),%rcx
cmp    %r10,%rcx
setb   0x20(%rsp)
mov    0xe0(%rsp),%rbp
cmp    %rbp,%rbx
setb   %dl
mov    0x1d0(%rsp),%rax
cmp    %rax,%r10
seta   0x78(%rsp)
mov    0x140(%rsp),%rax
cmp    %rax,%rbx
setb   0x6f(%rsp)
mov    0xe8(%rsp),%rdi
cmp    %r10,%rdi
setb   0x6e(%rsp)
mov    0x148(%rsp),%rsi
cmp    %rsi,%rbx
setb   %bl
mov    0xd8(%rsp),%r15
cmp    %r10,%r15
setb   %r10b
cmp    %rbp,%rcx
setb   %bpl
cmp    0x1d0(%rsp),%r9
seta   0x6d(%rsp)
cmp    %rax,%rcx
setb   %al
cmp    %r9,%rdi
setb   0x6c(%rsp)
cmp    %rsi,%rcx
setb   %dil
cmp    %r9,%r15
setb   %sil
mov    0x20(%rsp),%cl
test   %cl,0x28(%rsp)
jne    1b7f <radbg+0xa5f>
and    0x78(%rsp),%dl
jne    1b7f <radbg+0xa5f>
mov    0x6e(%rsp),%cl
and    %cl,0x6f(%rsp)
jne    1b7f <radbg+0xa5f>
and    %r10b,%bl
jne    1b7f <radbg+0xa5f>
and    0x6d(%rsp),%bpl
jne    1b7f <radbg+0xa5f>
and    0x6c(%rsp),%al
jne    1b7f <radbg+0xa5f>
mov    $0x0,%r10d
and    %sil,%dil
mov    0x1c0(%rsp),%r9
jne    1b90 <radbg+0xa70>
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
cmpq   $0x0,0x138(%rsp)
mov    0xe8(%rsp),%rax
mov    0x118(%rsp),%rdx
mov    0x110(%rsp),%rdi
je     1e85 <radbg+0xd65>
mov    0x128(%rsp),%rbx
xor    %ebp,%ebp
mov    0x1d0(%rsp),%rsi
mov    0xd8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rbp,8),%xmm3
movupd (%rax,%rbp,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%rdx,%rbp,8)
movupd (%rcx,%rbp,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rdi,%rbp,8)
movupd 0x10(%rsi,%rbp,8),%xmm3
movupd 0x10(%rax,%rbp,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%rdx,%rbp,8)
movupd 0x10(%rcx,%rbp,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%rdi,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1ab0 <radbg+0x990>
testb  $0x1,0x130(%rsp)
01
je     1b6a <radbg+0xa4a>
mov    0xd0(%rsp),%rax
mov    0xc0(%rsp),%rcx
sub    %rcx,%rax
imul   %r12,%rcx
imul   %r12,%rax
movupd (%rsi,%rbp,8),%xmm3
lea    (%r12,%rbp,1),%rdx
movupd (%rsi,%rdx,8),%xmm6
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
add    %rbp,%rcx
movupd %xmm5,(%r9,%rcx,8)
mov    0xf0(%rsp),%rcx
add    %rbp,%rcx
movupd (%rsi,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
add    %rbp,%rax
movupd %xmm3,(%r9,%rax,8)
mov    0x120(%rsp),%rax
mov    %rax,%r10
cmp    %r14,%rax
jne    1b90 <radbg+0xa70>
jmp    1c0b <radbg+0xaeb>
xor    %r10d,%r10d
mov    0x1c0(%rsp),%r9
nopw   0x0(%rax,%rax,1)
mov    0x100(%rsp),%rax
add    %r10,%rax
lea    (%r9,%rax,8),%rbx
mov    0xf0(%rsp),%rax
lea    (%rax,%r10,1),%rax
mov    0x1d0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0x108(%rsp),%rax
add    %r10,%rax
lea    (%r9,%rax,8),%rsi
lea    (%r12,%r10,1),%rax
lea    (%rcx,%rax,8),%rdi
lea    (%rcx,%r10,8),%rbp
mov    %r14,%rax
sub    %r10,%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%rbp,%rcx,8),%xmm3
movsd  %xmm3,(%rsi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1be0 <radbg+0xac0>
cmpl   $0x5,0x30(%rsp)
mov    0x38(%rsp),%rsi
mov    0x50(%rsp),%rcx
mov    0x60(%rsp),%rdi
jb     1840 <radbg+0x720>
xorpd  %xmm8,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x80(%rsp),%rax
cmp    %rax,0x10(%rsp)
setb   %al
mov    0x40(%rsp),%rdx
cmp    0x58(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0x78(%rsp)
mov    $0x2,%r10d
mov    0x150(%rsp),%r9
mov    0x158(%rsp),%r15
xor    %ebp,%ebp
movapd %xmm2,%xmm6
jmp    1c97 <radbg+0xb77>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%rbp
add    %rsi,%r15
add    %rdi,%r9
cmp    %rcx,%r10
je     1840 <radbg+0x720>
movapd %xmm6,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm4,%xmm7
unpcklpd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
test   %r13d,%r13d
jle    1c80 <radbg+0xb60>
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
cmp    $0x1,%r13d
jne    1d10 <radbg+0xbf0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,(%r8,%rbx,8)
movsd  (%r9,%rbx,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%r11,%rbx,8),%xmm0
movsd  %xmm0,(%r11,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1cd0 <radbg+0xbb0>
jmp    1c80 <radbg+0xb60>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
imul   %r12,%rax
mov    0xb8(%rsp),%rcx
add    %rax,%rcx
mov    0xc8(%rsp),%rdx
add    %rax,%rdx
mov    0xa8(%rsp),%rsi
sub    %rax,%rsi
mov    0x180(%rsp),%rdi
sub    %rax,%rdi
mov    0x1d0(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
lea    (%rax,%rdx,8),%rbx
lea    (%rax,%rsi,8),%r12
lea    (%rax,%rdi,8),%rdi
mov    0x10(%rsp),%rdx
cmp    %rbx,%rdx
setb   %al
mov    0x58(%rsp),%rsi
cmp    %rsi,%rcx
setb   %r13b
and    %al,%r13b
or     0x78(%rsp),%r13b
cmp    %rdi,%rdx
setb   %dl
cmp    %rsi,%r12
setb   0x28(%rsp)
mov    0x40(%rsp),%rsi
cmp    %rbx,%rsi
setb   %bl
mov    0x80(%rsp),%rax
cmp    %rax,%rcx
setb   0x20(%rsp)
cmp    %rdi,%rsi
setb   %cl
cmp    %rax,%r12
setb   %dil
test   %r13b,%r13b
jne    1e5e <radbg+0xd3e>
and    0x28(%rsp),%dl
jne    1e5e <radbg+0xd3e>
and    0x20(%rsp),%bl
mov    0xb0(%rsp),%r13d
mov    0x70(%rsp),%r12
jne    1e6f <radbg+0xd4f>
mov    $0x0,%ebx
and    %dil,%cl
mov    0x38(%rsp),%rsi
mov    0x50(%rsp),%rcx
mov    0x60(%rsp),%rdi
jne    1cd0 <radbg+0xbb0>
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
xor    %edx,%edx
mov    0x120(%rsp),%rax
nopl   0x0(%rax)
movupd (%r15,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
movupd (%r8,%rdx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r8,%rdx,8)
movupd (%r9,%rdx,8),%xmm0
movupd (%r11,%rdx,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r11,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1e10 <radbg+0xcf0>
mov    %rax,%rbx
cmp    %r14,%rax
jne    1cd0 <radbg+0xbb0>
jmp    1c80 <radbg+0xb60>
xor    %ebx,%ebx
mov    0xb0(%rsp),%r13d
mov    0x70(%rsp),%r12
jmp    1e71 <radbg+0xd51>
xor    %ebx,%ebx
mov    0x38(%rsp),%rsi
mov    0x50(%rsp),%rcx
mov    0x60(%rsp),%rdi
jmp    1cd0 <radbg+0xbb0>
xor    %ebp,%ebp
mov    0x1d0(%rsp),%rsi
testb  $0x1,0x130(%rsp)
01
jne    1b13 <radbg+0x9f3>
jmp    1b6a <radbg+0xa4a>
cmp    %eax,0xa4(%rsp)
jge    230f <radbg+0x11ef>
cmpl   $0x3,0x30(%rsp)
jl     28a6 <radbg+0x1786>
mov    0x30(%rsp),%rax
mov    %eax,%r8d
mov    0x18(%rsp),%r9
movslq %r9d,%rbx
mov    0xc(%rsp),%esi
movslq %esi,%rcx
mov    0x4c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%edi
cmovge %edx,%edi
mov    %rdi,0x78(%rsp)
mov    %esi,%edx
mov    %rdx,0x58(%rsp)
lea    -0x1(%r8),%rdx
imul   %rbx,%rcx
imul   %rcx,%rdx
mov    0x1c8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
add    $0x10,%rdx
mov    %rdx,0x50(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0x70(%rsp)
neg    %rdx
mov    %rdx,0xa8(%rsp)
lea    0x0(,%rbx,8),%rdx
lea    (%rdi,%rcx,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x40(%rsp)
lea    (%r9,%r9,1),%ecx
mov    %ecx,0xb8(%rsp)
mov    %eax,%edi
imul   %r9d,%edi
lea    (%r9,%r9,1),%ecx
add    $0xfffffffd,%ecx
mov    %ecx,0x60(%rsp)
mov    %rbx,%rcx
shl    $0x4,%rcx
mov    %rcx,0xc8(%rsp)
add    %rbp,%rcx
add    $0x10,%rcx
mov    %rcx,0x80(%rsp)
mov    %rbx,0x20(%rsp)
imul   %rbx,%r8
shl    $0x3,%r8
mov    $0x1,%ebx
mov    %r9d,%ecx
mov    %r9d,0x10(%rsp)
jmp    1fe7 <radbg+0xec7>
mov    0x38(%rsp),%rbx
add    $0x1,%rbx
mov    0xa8(%rsp),%rcx
add    %rcx,0x50(%rsp)
mov    0x40(%rsp),%rcx
add    0x70(%rsp),%rcx
mov    %rcx,0x40(%rsp)
mov    0xb8(%rsp),%ecx
add    %ecx,0x10(%rsp)
add    %ecx,0x60(%rsp)
mov    0x80(%rsp),%rcx
add    0xc8(%rsp),%rcx
mov    %rcx,0x80(%rsp)
cmp    0x78(%rsp),%rbx
je     1658 <radbg+0x538>
mov    %rbx,0x38(%rsp)
cmpl   $0x3,0x18(%rsp)
jl     1f90 <radbg+0xe70>
mov    $0x2,%eax
mov    0x80(%rsp),%r12
mov    0x60(%rsp),%ecx
mov    %ecx,0x28(%rsp)
mov    0x40(%rsp),%r15
mov    0x50(%rsp),%r11
jmp    2044 <radbg+0xf24>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
add    $0x10,%r11
add    $0x10,%r15
addl   $0xfffffffe,0x28(%rsp)
add    $0x10,%r12
cmp    0x20(%rsp),%rax
mov    0xc(%rsp),%esi
jge    1f90 <radbg+0xe70>
test   %esi,%esi
jle    2020 <radbg+0xf00>
mov    0x20(%rsp),%rcx
sub    %rax,%rcx
mov    0x58(%rsp),%rsi
mov    %r12,%rbx
mov    %rax,%r13
mov    0x28(%rsp),%eax
mov    %eax,%r14d
mov    0x10(%rsp),%eax
mov    %eax,%r9d
mov    %r13,%rax
xor    %r13d,%r13d
nop
movsd  -0x8(%rbx),%xmm1
movslq %r14d,%r14
addsd  0x0(%rbp,%r14,8),%xmm1
movsd  %xmm1,-0x8(%r15,%r13,1)
movsd  -0x8(%rbx),%xmm1
subsd  0x0(%rbp,%r14,8),%xmm1
movsd  %xmm1,-0x8(%r11,%r13,1)
movsd  (%rbx),%xmm1
movslq %r9d,%r9
lea    (%rcx,%r9,1),%r10
subsd  0x0(%rbp,%r10,8),%xmm1
movsd  %xmm1,(%r15,%r13,1)
movsd  (%rbx),%xmm1
addsd  0x0(%rbp,%r10,8),%xmm1
movsd  %xmm1,(%r11,%r13,1)
add    %rdx,%r13
add    %edi,%r9d
add    %edi,%r14d
add    %r8,%rbx
add    $0xffffffffffffffff,%rsi
jne    2070 <radbg+0xf50>
jmp    2020 <radbg+0xf00>
cmpl   $0x3,0x30(%rsp)
jl     25d9 <radbg+0x14b9>
mov    0x4c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r15d
cmovge %eax,%r15d
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x10(%rsp)
mov    %r14,%r9
neg    %r9
mov    0x1d0(%rsp),%rax
lea    (%rax,%r12,8),%rsi
add    $0x30,%rsi
lea    (%rax,%r12,8),%rdi
add    $0x8,%rdi
mov    $0x1,%edx
xor    %r10d,%r10d
mov    0x70(%rsp),%rbp
jmp    216c <radbg+0x104c>
xchg   %ax,%ax
add    $0x1,%rdx
add    $0x1,%r10
mov    0x38(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdi
cmp    %r15,%rdx
je     24ff <radbg+0x13df>
test   %r13d,%r13d
jle    2150 <radbg+0x1030>
mov    %rdx,%r12
imul   %rbp,%r12
cmp    $0x4,%r13d
jb     21b7 <radbg+0x1097>
mov    %r10,%rcx
imul   %rbp,%rcx
mov    0xf8(%rsp),%rax
lea    (%rax,%rcx,1),%rbx
mov    0x1d0(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
cmp    %rax,%rbx
jbe    222f <radbg+0x110f>
add    %rbp,%rcx
lea    (%rax,%rcx,8),%rcx
cmp    0xe0(%rsp),%rcx
jae    222f <radbg+0x110f>
xor    %ebx,%ebx
mov    %rbx,%rcx
test   $0x1,%r14b
je     21e4 <radbg+0x10c4>
add    %rbx,%r12
mov    0x1d0(%rsp),%rax
movsd  (%rax,%r12,8),%xmm0
addsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    %r9,%rbx
mov    0x1d0(%rsp),%rbx
je     2150 <radbg+0x1030>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rcx,8),%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm0
addsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    2200 <radbg+0x10e0>
jmp    2150 <radbg+0x1030>
cmpq   $0x0,0x28(%rsp)
je     2304 <radbg+0x11e4>
mov    0x10(%rsp),%rcx
xor    %ebx,%ebx
mov    0x1d0(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rsi,%rbx,8),%xmm0
movupd -0x20(%rsi,%rbx,8),%xmm1
movupd (%r8,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r8,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%r8,%rbx,8),%xmm1
movupd 0x30(%r8,%rbx,8),%xmm3
movupd %xmm2,(%r8,%rbx,8)
movupd %xmm0,0x10(%r8,%rbx,8)
movupd -0x10(%rsi,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rsi,%rbx,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r8,%rbx,8)
movupd %xmm1,0x30(%r8,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    2250 <radbg+0x1130>
testb  $0x1,0x20(%rsp)
je     22f3 <radbg+0x11d3>
lea    (%rbx,%r12,1),%rcx
mov    0x1d0(%rsp),%rax
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
movupd (%rax,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
mov    %r11,%rbx
cmp    %r14,%r11
je     2150 <radbg+0x1030>
jmp    21b9 <radbg+0x1099>
xor    %ebx,%ebx
testb  $0x1,0x20(%rsp)
jne    22be <radbg+0x119e>
jmp    22f3 <radbg+0x11d3>
cmpl   $0x3,0x30(%rsp)
jl     28a6 <radbg+0x1786>
mov    0x18(%rsp),%rdi
movslq %edi,%rax
mov    0x30(%rsp),%r8
mov    %r8d,%r12d
mov    0xc(%rsp),%esi
movslq %esi,%rcx
mov    0x4c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%ebx
cmovge %edx,%ebx
mov    %rbx,0x50(%rsp)
mov    %esi,%r13d
lea    -0x1(%r12),%rdx
imul   %rax,%rcx
imul   %rcx,%rdx
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rdx,8),%rdx
mov    %rdx,0x40(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0x60(%rsp)
neg    %rdx
mov    %rdx,0x78(%rsp)
lea    0x0(,%rax,8),%rdx
lea    (%rbx,%rcx,8),%rcx
mov    %rcx,0x20(%rsp)
mov    %rax,%rcx
shl    $0x4,%rcx
mov    %rcx,0x70(%rsp)
add    %rbp,%rcx
mov    %rcx,0x10(%rsp)
imul   %rax,%r12
shl    $0x3,%r12
lea    (%rdi,%rdi,1),%ecx
mov    %ecx,0xa8(%rsp)
lea    (%rdi,%rdi,1),%ecx
add    $0xfffffffd,%ecx
mov    %ecx,0x80(%rsp)
mov    %r8d,%r10d
imul   %edi,%r10d
lea    -0x10(%rbp),%rcx
mov    %rcx,0x28(%rsp)
mov    $0x1,%ebx
mov    %edi,%ecx
mov    %edi,0x38(%rsp)
jmp    2432 <radbg+0x1312>
nopl   0x0(%rax)
mov    0x58(%rsp),%rbx
add    $0x1,%rbx
mov    0x78(%rsp),%rcx
add    %rcx,0x40(%rsp)
mov    0x20(%rsp),%rcx
add    0x60(%rsp),%rcx
mov    %rcx,0x20(%rsp)
mov    0x10(%rsp),%rcx
add    0x70(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0xa8(%rsp),%ecx
add    %ecx,0x80(%rsp)
add    %ecx,0x38(%rsp)
cmp    0x50(%rsp),%rbx
mov    0xc(%rsp),%esi
je     1658 <radbg+0x538>
mov    %rbx,0x58(%rsp)
test   %esi,%esi
jle    23e0 <radbg+0x12c0>
mov    0x38(%rsp),%ebx
mov    0x80(%rsp),%r9d
mov    0x10(%rsp),%rdi
mov    0x20(%rsp),%r15
mov    0x40(%rsp),%r11
xor    %r8d,%r8d
jmp    247c <radbg+0x135c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %rdx,%r11
add    %rdx,%r15
add    %r12,%rdi
add    %r10d,%r9d
add    %r10d,%ebx
cmp    %r13,%r8
je     23e0 <radbg+0x12c0>
cmpl   $0x3,0x18(%rsp)
jl     2460 <radbg+0x1340>
movslq %ebx,%rcx
add    %rax,%rcx
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    $0x2,%esi
mov    %r9d,%r14d
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rsi,8),%xmm1
movslq %r14d,%r14
addsd  0x0(%rbp,%r14,8),%xmm1
movsd  %xmm1,-0x8(%r15,%rsi,8)
movsd  -0x8(%rdi,%rsi,8),%xmm1
subsd  0x0(%rbp,%r14,8),%xmm1
movsd  %xmm1,-0x8(%r11,%rsi,8)
movsd  (%rdi,%rsi,8),%xmm1
subsd  (%rcx),%xmm1
movsd  %xmm1,(%r15,%rsi,8)
movsd  (%rdi,%rsi,8),%xmm1
addsd  (%rcx),%xmm1
movsd  %xmm1,(%r11,%rsi,8)
add    $0x2,%rsi
add    $0xfffffffe,%r14d
add    $0xfffffffffffffff0,%rcx
cmp    %rax,%rsi
jl     24a0 <radbg+0x1380>
jmp    2460 <radbg+0x1340>
cmpl   $0x3,0x30(%rsp)
jl     25d9 <radbg+0x14b9>
movslq 0x18(%rsp),%rax
mov    0xc(%rsp),%edx
movslq %edx,%rcx
mov    0x4c(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%r9d
cmovge %esi,%r9d
mov    %edx,%r8d
mov    0xd0(%rsp),%rbx
add    $0xffffffffffffffff,%rbx
imul   %rax,%rcx
imul   %rcx,%rbx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rbx,8),%rsi
lea    0x0(,%rcx,8),%r10
mov    %r10,%r11
neg    %r11
shl    $0x3,%rax
mov    0x1c8(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbx
lea    (%rdx,%rcx,8),%rdx
lea    (%rdi,%rcx,8),%rcx
mov    $0x1,%r14d
jmp    2595 <radbg+0x1475>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r11,%rsi
add    %r11,%rbx
add    %r10,%rdx
add    %r10,%rcx
cmp    %r9,%r14
je     25d9 <radbg+0x14b9>
cmpl   $0x0,0xc(%rsp)
jle    2580 <radbg+0x1460>
mov    %r8,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,1),%xmm0
subsd  (%rsi,%rbp,1),%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
movsd  (%rdx,%rbp,1),%xmm0
addsd  (%rsi,%rbp,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,1)
add    %rax,%rbp
add    $0xffffffffffffffff,%rdi
jne    25b0 <radbg+0x1490>
jmp    2580 <radbg+0x1460>
cmpl   $0x1,0x18(%rsp)
je     2f67 <radbg+0x1e47>
mov    0xa4(%rsp),%eax
cmp    0xc(%rsp),%eax
jge    275a <radbg+0x163a>
cmpl   $0x3,0x30(%rsp)
jl     28a6 <radbg+0x1786>
movslq 0x18(%rsp),%rax
mov    0x30(%rsp),%edx
mov    0xc(%rsp),%ecx
movslq %ecx,%rsi
mov    0x4c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,0x28(%rsp)
mov    %ecx,%edi
add    $0xffffffffffffffff,%rdx
imul   %rax,%rsi
imul   %rsi,%rdx
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rdx,8),%r10
add    $0x10,%r10
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x20(%rsp)
neg    %rcx
mov    %rcx,0x10(%rsp)
lea    0x0(,%rax,8),%rcx
mov    0x98(%rsp),%rbp
lea    0x10(,%rdx,8),%r9
add    %rbp,%r9
lea    0x10(,%rsi,8),%r8
add    %rbp,%r8
lea    (%rbx,%rsi,8),%r12
add    $0x10,%r12
mov    $0x1,%r13d
jmp    26b5 <radbg+0x1595>
nopl   (%rax)
add    $0x1,%r13
mov    0x10(%rsp),%rdx
add    %rdx,%r10
add    %rdx,%r9
mov    0x20(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%r12
cmp    0x28(%rsp),%r13
je     28a6 <radbg+0x1786>
cmpl   $0x3,0x18(%rsp)
jl     2690 <radbg+0x1570>
mov    $0x2,%ebx
mov    %r12,%rsi
mov    %r8,%r15
mov    %r9,%r14
mov    %r10,%r11
jmp    26e9 <radbg+0x15c9>
nop
add    $0x2,%rbx
add    $0x10,%r11
add    $0x10,%r14
add    $0x10,%r15
add    $0x10,%rsi
cmp    %rax,%rbx
jge    2690 <radbg+0x1570>
cmpl   $0x0,0xc(%rsp)
jle    26d0 <radbg+0x15b0>
mov    %rdi,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r15,%rbp,1),%xmm0
subsd  (%r14,%rbp,1),%xmm0
movsd  %xmm0,-0x8(%rsi,%rbp,1)
movsd  -0x8(%r15,%rbp,1),%xmm0
addsd  (%r14,%rbp,1),%xmm0
movsd  %xmm0,-0x8(%r11,%rbp,1)
movsd  (%r15,%rbp,1),%xmm0
addsd  -0x8(%r14,%rbp,1),%xmm0
movsd  %xmm0,(%rsi,%rbp,1)
movsd  (%r15,%rbp,1),%xmm0
subsd  -0x8(%r14,%rbp,1),%xmm0
movsd  %xmm0,(%r11,%rbp,1)
add    %rcx,%rbp
add    $0xffffffffffffffff,%rdx
jne    2700 <radbg+0x15e0>
jmp    26d0 <radbg+0x15b0>
cmpl   $0x3,0x30(%rsp)
jl     28a6 <radbg+0x1786>
movslq 0x18(%rsp),%rax
mov    0x30(%rsp),%ecx
mov    0xc(%rsp),%edx
movslq %edx,%rsi
mov    0x4c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,0x28(%rsp)
mov    %edx,%edx
imul   %rax,%rsi
mov    0x98(%rsp),%r10
lea    (%r10,%rsi,8),%r9
lea    0x0(,%rsi,8),%r13
lea    0x0(,%rax,8),%rbp
mov    0x1c8(%rsp),%rbx
lea    (%rbx,%rsi,8),%r8
add    $0xffffffffffffffff,%rcx
imul   %rsi,%rcx
lea    (%r10,%rcx,8),%r15
mov    %r13,0x20(%rsp)
neg    %r13
lea    (%rbx,%rcx,8),%r12
mov    $0x1,%ebx
jmp    2803 <radbg+0x16e3>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    0x20(%rsp),%rcx
add    %rcx,%r9
add    %rcx,%r8
mov    %r13,%rcx
add    %r13,%r15
add    %r13,%r12
cmp    0x28(%rsp),%rbx
je     28a6 <radbg+0x1786>
cmpl   $0x0,0xc(%rsp)
jle    27e0 <radbg+0x16c0>
mov    %r12,%rsi
mov    %r15,%rdi
mov    %r8,%r14
mov    %r9,%r11
xor    %r10d,%r10d
jmp    2835 <radbg+0x1715>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %rbp,%r11
add    %rbp,%r14
add    %rbp,%rdi
add    %rbp,%rsi
cmp    %rdx,%r10
je     27e0 <radbg+0x16c0>
cmpl   $0x3,0x18(%rsp)
jl     2820 <radbg+0x1700>
mov    $0x2,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r11,%rcx,8),%xmm0
subsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rcx,8)
movsd  -0x8(%r11,%rcx,8),%xmm0
addsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rcx,8)
movsd  (%r11,%rcx,8),%xmm0
addsd  -0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
movsd  (%r11,%rcx,8),%xmm0
subsd  -0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rax,%rcx
jl     2850 <radbg+0x1730>
jmp    2820 <radbg+0x1700>
mov    0xb0(%rsp),%ecx
test   %ecx,%ecx
mov    0x18(%rsp),%rdi
mov    0x1d0(%rsp),%rbx
mov    0x1c0(%rsp),%rax
jle    2a4d <radbg+0x192d>
mov    %ecx,%r8d
cmp    $0x4,%ecx
jb     28e8 <radbg+0x17c8>
lea    (%rbx,%r8,8),%rcx
cmp    %rax,%rcx
jbe    295c <radbg+0x183c>
lea    (%rax,%r8,8),%rcx
cmp    %rbx,%rcx
jbe    295c <radbg+0x183c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     2914 <radbg+0x17f4>
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2900 <radbg+0x17e0>
cmp    $0x3,%rdx
jb     2a4d <radbg+0x192d>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2920 <radbg+0x1800>
jmp    2a4d <radbg+0x192d>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    2980 <radbg+0x1860>
xor    %edi,%edi
jmp    29fc <radbg+0x18dc>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rdi,8),%xmm0
movups 0x10(%rbx,%rdi,8),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm0
movups 0x30(%rbx,%rdi,8),%xmm1
movups %xmm0,0x20(%rax,%rdi,8)
movups %xmm1,0x30(%rax,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm0
movups 0x50(%rbx,%rdi,8),%xmm1
movups %xmm0,0x40(%rax,%rdi,8)
movups %xmm1,0x50(%rax,%rdi,8)
movupd 0x60(%rbx,%rdi,8),%xmm0
movupd 0x70(%rbx,%rdi,8),%xmm1
movupd %xmm0,0x60(%rax,%rdi,8)
movupd %xmm1,0x70(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    29a0 <radbg+0x1880>
test   %rdx,%rdx
je     2a3f <radbg+0x191f>
lea    (%rax,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movupd %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    2a20 <radbg+0x1900>
cmp    %r8,%rcx
mov    0x18(%rsp),%rdi
jne    28ea <radbg+0x17ca>
cmpl   $0x2,0x30(%rsp)
jl     2f67 <radbg+0x1e47>
movslq %edi,%rax
mov    0xc(%rsp),%ecx
movslq %ecx,%rbp
mov    %ecx,%r15d
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x80(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x78(%rsp)
lea    0x2(%rbp),%rcx
imul   %rax,%rcx
mov    0x98(%rsp),%r8
lea    (%r8,%rcx,8),%rdx
mov    %rdx,0x70(%rsp)
mov    %rbp,%rdx
imul   %rax,%rdx
lea    0x0(,%rdx,8),%rsi
mov    %rsi,0x50(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,0xb0(%rsp)
mov    0x1c8(%rsp),%r9
lea    (%r9,%rcx,8),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x1(%rbp),%rdi
imul   %rax,%rdi
lea    (%r8,%rdi,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    (%r9,%rdi,8),%r10
lea    0x3(%rbp),%rdi
imul   %rax,%rdi
lea    (%r8,%rdi,8),%r14
lea    (%r9,%rdi,8),%r11
lea    (%r9,%rdx,8),%r9
lea    (%r8,%rdx,8),%r8
mov    0x1d8(%rsp),%rdx
mov    0x30(%rsp),%edi
mov    %rdi,0x20(%rsp)
mov    %r15,0x28(%rsp)
lea    -0x1(%r15),%rcx
mov    %rcx,0x60(%rsp)
lea    0x0(,%rax,8),%r13
mov    $0x1,%ecx
xor    %esi,%esi
mov    %rbp,0x38(%rsp)
mov    %rbp,%rbx
jmp    2b59 <radbg+0x1a39>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    0x50(%rsp),%rsi
add    0x38(%rsp),%rbx
cmp    0x20(%rsp),%rcx
je     2c4b <radbg+0x1b2b>
cmpl   $0x0,0xc(%rsp)
jle    2b40 <radbg+0x1a20>
mov    %rbx,0x40(%rsp)
mov    %rcx,0x10(%rsp)
cmpq   $0x3,0x60(%rsp)
mov    %rsi,0x58(%rsp)
jae    2b80 <radbg+0x1a60>
xor    %r12d,%r12d
jmp    2bea <radbg+0x1aca>
nopl   0x0(%rax)
mov    %rsi,%rdi
xor    %r12d,%r12d
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%rsi
mov    0xb0(%rsp),%rbx
mov    0xa8(%rsp),%rcx
mov    0xb8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rdi,1),%xmm0
movsd  %xmm0,(%r8,%rdi,1)
movsd  (%r10,%rdi,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,1)
movsd  (%rcx,%rdi,1),%xmm0
movsd  %xmm0,(%rsi,%rdi,1)
movsd  (%r11,%rdi,1),%xmm0
movsd  %xmm0,(%r14,%rdi,1)
add    $0x4,%r12
add    %rbx,%rdi
cmp    %r12,%r15
jne    2bb0 <radbg+0x1a90>
cmpq   $0x0,0x80(%rsp)
mov    0x98(%rsp),%r15
mov    0x1c8(%rsp),%rbp
mov    0x10(%rsp),%rcx
mov    0x58(%rsp),%rsi
mov    0x40(%rsp),%rbx
je     2b40 <radbg+0x1a20>
add    %rbx,%r12
imul   %r13,%r12
mov    0x80(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r12,1),%xmm0
movsd  %xmm0,(%r15,%r12,1)
add    %r13,%r12
add    $0xffffffffffffffff,%rdi
jne    2c30 <radbg+0x1b10>
jmp    2b40 <radbg+0x1a20>
mov    0xa4(%rsp),%ecx
cmp    0xc(%rsp),%ecx
jle    2df7 <radbg+0x1cd7>
cmpl   $0x2,0x30(%rsp)
mov    0x18(%rsp),%rdi
jl     2f67 <radbg+0x1e47>
movslq 0xc(%rsp),%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rbp
mov    %rcx,0x60(%rsp)
add    %rcx,%rbp
mov    %rbp,0x10(%rsp)
mov    %rax,%r12
shl    $0x20,%r12
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x80(%rsp)
mov    0x98(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x38(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x50(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x58(%rsp)
mov    $0x1,%esi
movabs $0x200000000,%r9
mov    0x98(%rsp),%r8
jmp    2d31 <radbg+0x1c11>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rsi
add    $0x1,%rsi
mov    0x58(%rsp),%rcx
add    %edi,%ecx
mov    %rcx,0x58(%rsp)
mov    0x10(%rsp),%rcx
add    0x60(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0x50(%rsp),%rcx
add    %rcx,0x80(%rsp)
add    %rcx,0x38(%rsp)
cmp    0x20(%rsp),%rsi
je     2f67 <radbg+0x1e47>
mov    %rsi,0x40(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    2cf0 <radbg+0x1bd0>
movslq 0x58(%rsp),%rcx
lea    (%rdx,%rcx,8),%rbx
mov    0x38(%rsp),%rcx
mov    0x80(%rsp),%rsi
mov    0x10(%rsp),%r15
xor    %r14d,%r14d
jmp    2d7d <radbg+0x1c5d>
nopl   (%rax)
add    $0x1,%r14
add    %r12,%r15
add    %r13,%rsi
add    %r13,%rcx
cmp    0x28(%rsp),%r14
mov    0x18(%rsp),%rdi
je     2cf0 <radbg+0x1bd0>
cmp    $0x3,%edi
mov    0x1c8(%rsp),%r10
jl     2d60 <radbg+0x1c40>
mov    $0x2,%ebp
mov    %r15,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rbp,8),%xmm0
mov    %r11,%rdi
movsd  (%rsi,%rbp,8),%xmm1
mulsd  (%rbx,%rbp,8),%xmm1
sar    $0x1d,%rdi
mulsd  (%r10,%rdi,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r8,%rdi,1)
movsd  (%rbx,%rbp,8),%xmm0
mulsd  (%r10,%rdi,1),%xmm0
movsd  -0x8(%rbx,%rbp,8),%xmm1
mulsd  (%rsi,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x2,%rbp
add    %r9,%r11
cmp    %rax,%rbp
jl     2da0 <radbg+0x1c80>
jmp    2d60 <radbg+0x1c40>
cmpl   $0x2,0x30(%rsp)
mov    0x18(%rsp),%rsi
jl     2f67 <radbg+0x1e47>
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
imul   %esi,%ecx
mov    %rcx,0x50(%rsp)
add    $0x1,%ecx
mov    %ecx,0x10(%rsp)
imul   %rax,%rdi
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x58(%rsp)
mov    0x98(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x40(%rsp)
shl    $0x3,%rdi
mov    %rdi,0x38(%rsp)
movl   $0xffffffff,0x80(%rsp)
ff ff ff ff
mov    $0x1,%r12d
mov    0x98(%rsp),%r14
mov    0x18(%rsp),%r10
jmp    2ea6 <radbg+0x1d86>
nopl   0x0(%rax)
add    $0x1,%r12
mov    0x18(%rsp),%rsi
add    %esi,0x80(%rsp)
mov    0x10(%rsp),%ecx
add    0x50(%rsp),%ecx
mov    %ecx,0x10(%rsp)
mov    0x38(%rsp),%rcx
add    %rcx,0x58(%rsp)
add    %rcx,0x40(%rsp)
cmp    0x20(%rsp),%r12
je     2f67 <radbg+0x1e47>
cmp    $0x3,%esi
jl     2e70 <radbg+0x1d50>
movslq 0x80(%rsp),%r8
mov    $0x2,%ebx
mov    0x40(%rsp),%rcx
mov    0x58(%rsp),%rsi
mov    0x10(%rsp),%r13d
jmp    2ee8 <radbg+0x1dc8>
nopl   0x0(%rax)
add    $0x2,%rbx
add    $0x2,%r13d
add    $0x10,%rsi
add    $0x10,%rcx
mov    %r9,%r8
cmp    %rax,%rbx
jge    2e70 <radbg+0x1d50>
lea    0x2(%r8),%r9
cmpl   $0x0,0xc(%rsp)
mov    0x1c8(%rsp),%r15
jle    2ed0 <radbg+0x1db0>
mov    $0x2,%edi
mov    0x28(%rsp),%rbp
mov    %r13d,%r11d
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rdx,%r8,8),%xmm0
movsd  (%rsi,%rdi,8),%xmm1
mulsd  (%rdx,%r9,8),%xmm1
movslq %r11d,%r11
mulsd  (%r15,%r11,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%r11,8)
movsd  (%rdx,%r9,8),%xmm0
mulsd  (%r15,%r11,8),%xmm0
movsd  0x8(%rdx,%r8,8),%xmm1
mulsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    %r10d,%r11d
add    %rax,%rdi
add    $0xffffffffffffffff,%rbp
jne    2f10 <radbg+0x1df0>
jmp    2ed0 <radbg+0x1db0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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