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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
double sin(double);
void radbg(int ido, int ip, int l1, int idl1, double cc[], double ch[],
           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++) {
      cc[ik + l * idl1] = ch[ik] + ar1 * ch[ik + idl1];
      cc[ik + lc * idl1] = ai1 * ch[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++) {
        cc[ik + l * idl1] += ar2 * ch[ik + j * idl1];
        cc[ik + lc * idl1] += ai2 * ch[ik + jc * idl1];
      }
    }
  }
  for (j = 1; j < ipph; j++) {
    for (ik = 0; ik < idl1; ik++) {
      ch[ik] += ch[ik + j * idl1];
    }
  }
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    for (k = 0; k < l1; k++) {
      ch[(k + j * l1) * ido] = cc[(k + j * l1) * ido] - cc[(k + jc * l1) * ido];
      ch[(k + jc * l1) * ido] =
          cc[(k + j * l1) * ido] + cc[(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] =
              cc[i - 1 + (k + j * l1) * ido] - cc[i + (k + jc * l1) * ido];
          ch[i - 1 + (k + jc * l1) * ido] =
              cc[i - 1 + (k + j * l1) * ido] + cc[i + (k + jc * l1) * ido];
          ch[i + (k + j * l1) * ido] =
              cc[i + (k + j * l1) * ido] + cc[i - 1 + (k + jc * l1) * ido];
          ch[i + (k + jc * l1) * ido] =
              cc[i + (k + j * l1) * ido] - cc[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] =
              cc[i - 1 + (k + j * l1) * ido] - cc[i + (k + jc * l1) * ido];
          ch[i - 1 + (k + jc * l1) * ido] =
              cc[i - 1 + (k + j * l1) * ido] + cc[i + (k + jc * l1) * ido];
          ch[i + (k + j * l1) * ido] =
              cc[i + (k + j * l1) * ido] + cc[i - 1 + (k + jc * l1) * ido];
          ch[i + (k + jc * l1) * ido] =
              cc[i + (k + j * l1) * ido] - cc[i - 1 + (k + jc * l1) * ido];
        }
      }
    }
  }
  for (ik = 0; ik < idl1; ik++)
    cc[ik] = ch[ik];
  for (j = 1; j < ip; j++)
    for (k = 0; k < l1; k++)
      cc[(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++) {
          cc[i - 1 + (k + j * l1) * ido] =
              wa[idij - 1] * ch[i - 1 + (k + j * l1) * ido] -
              wa[idij] * ch[i + (k + j * l1) * ido];
          cc[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 - 1;
        for (i = 2; i < ido; i += 2) {
          idij += 2;
          cc[i - 1 + (k + j * l1) * ido] =
              wa[idij - 1] * ch[i - 1 + (k + j * l1) * ido] -
              wa[idij] * ch[i + (k + j * l1) * ido];
          cc[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    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  0x1eb0(%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     1237 <radbg+0x117>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1232 <radbg+0x112>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    121f <radbg+0xff>
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    -0x20(%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    11d1 <radbg+0xb1>
jmp    1224 <radbg+0x104>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11be <radbg+0x9e>
jmp    12b7 <radbg+0x197>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b2 <radbg+0x192>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    129f <radbg+0x17f>
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    -0x20(%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    1251 <radbg+0x131>
jmp    12a4 <radbg+0x184>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123e <radbg+0x11e>
jmp    12b7 <radbg+0x197>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13ce <radbg+0x2ae>
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    13bb <radbg+0x29b>
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    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -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    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12e3 <radbg+0x1c3>
jmp    13c0 <radbg+0x2a0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12be <radbg+0x19e>
cmpl   $0x1,-0x4(%rbp)
je     1878 <radbg+0x758>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     162d <radbg+0x50d>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1628 <radbg+0x508>
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    1615 <radbg+0x4f5>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1602 <radbg+0x4e2>
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    141d <radbg+0x2fd>
jmp    1607 <radbg+0x4e7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    140a <radbg+0x2ea>
jmp    161a <radbg+0x4fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ee <radbg+0x2ce>
jmp    1873 <radbg+0x753>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    186e <radbg+0x74e>
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    185b <radbg+0x73b>
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    1848 <radbg+0x728>
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    166c <radbg+0x54c>
jmp    184d <radbg+0x72d>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1650 <radbg+0x530>
jmp    1860 <radbg+0x740>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1634 <radbg+0x514>
jmp    1873 <radbg+0x753>
jmp    1878 <radbg+0x758>
movsd  0x1788(%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    1b33 <radbg+0xa13>
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    19bb <radbg+0x89b>
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    -0x18(%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    -0x18(%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    1925 <radbg+0x805>
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    1b20 <radbg+0xa00>
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    1b0d <radbg+0x9ed>
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    -0x18(%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    -0x18(%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    1a6f <radbg+0x94f>
jmp    1b12 <radbg+0x9f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19ea <radbg+0x8ca>
jmp    1b25 <radbg+0xa05>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1894 <radbg+0x774>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ba4 <radbg+0xa84>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b91 <radbg+0xa71>
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    1b4d <radbg+0xa2d>
jmp    1b96 <radbg+0xa76>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b3a <radbg+0xa1a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c9c <radbg+0xb7c>
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    1c89 <radbg+0xb69>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -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    1bc7 <radbg+0xaa7>
jmp    1c8e <radbg+0xb6e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bab <radbg+0xa8b>
cmpl   $0x1,-0x4(%rbp)
jne    1cab <radbg+0xb8b>
jmp    2547 <radbg+0x1427>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1ed3 <radbg+0xdb3>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ece <radbg+0xdae>
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    1ebb <radbg+0xd9b>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ea8 <radbg+0xd88>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cf0 <radbg+0xbd0>
jmp    1ead <radbg+0xd8d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1cdd <radbg+0xbbd>
jmp    1ec0 <radbg+0xda0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1cc1 <radbg+0xba1>
jmp    20ec <radbg+0xfcc>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    20e7 <radbg+0xfc7>
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    20d4 <radbg+0xfb4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    20c1 <radbg+0xfa1>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f09 <radbg+0xde9>
jmp    20c6 <radbg+0xfa6>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ef6 <radbg+0xdd6>
jmp    20d9 <radbg+0xfb9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1eda <radbg+0xdba>
jmp    20ec <radbg+0xfcc>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2127 <radbg+0x1007>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    20f3 <radbg+0xfd3>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    21a6 <radbg+0x1086>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2193 <radbg+0x1073>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2141 <radbg+0x1021>
jmp    2198 <radbg+0x1078>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    212e <radbg+0x100e>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     237e <radbg+0x125e>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2379 <radbg+0x1259>
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    2366 <radbg+0x1246>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2353 <radbg+0x1233>
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2205 <radbg+0x10e5>
jmp    2358 <radbg+0x1238>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    21e9 <radbg+0x10c9>
jmp    236b <radbg+0x124b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    21c4 <radbg+0x10a4>
jmp    2547 <radbg+0x1427>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2542 <radbg+0x1422>
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    252f <radbg+0x140f>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    251c <radbg+0x13fc>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    23c5 <radbg+0x12a5>
jmp    2521 <radbg+0x1401>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    23a9 <radbg+0x1289>
jmp    2534 <radbg+0x1414>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    238d <radbg+0x126d>
jmp    2547 <radbg+0x1427>
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,0x18(%rsp)
mov    %r8,0x10(%rsp)
mov    %ecx,0x68(%rsp)
mov    %edx,%ebp
mov    %esi,%r15d
mov    %edi,%r14d
cvtsi2sd %esi,%xmm1
movsd  0x1ead(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x90(%rsp)
movsd  0x28(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%r14),%ecx
shr    $0x1f,%ecx
lea    0x1(%r15),%eax
shr    $0x1f,%eax
mov    %r15,0x40(%rsp)
add    %r15d,%eax
add    $0x1,%eax
mov    %eax,0x5c(%rsp)
cmp    %ebp,%r14d
mov    %ebp,0xc(%rsp)
mov    %r14,0x28(%rsp)
mov    %rcx,0x48(%rsp)
jge    1289 <radbg+0x169>
test   %r14d,%r14d
movapd 0x90(%rsp),%xmm11
jle    1520 <radbg+0x400>
mov    0x40(%rsp),%r10
mov    0x28(%rsp),%rax
imul   %eax,%r10d
mov    %eax,%ecx
mov    %ebp,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    (%r10,%r10,1),%r14d
mov    %rcx,%r15
shl    $0x4,%r15
xor    %edx,%edx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%rbx
jmp    1201 <radbg+0xe1>
add    $0x1,%rdx
add    $0x8,%r9
cmp    %rcx,%rdx
je     1520 <radbg+0x400>
test   %ebp,%ebp
jle    11f0 <radbg+0xd0>
cmp    $0x1,%ebp
jne    1210 <radbg+0xf0>
xor    %eax,%eax
jmp    1253 <radbg+0x133>
xchg   %ax,%ax
xor    %esi,%esi
mov    %r9,%rdi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
lea    (%rdx,%rsi,1),%rbp
movsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rdi)
lea    (%r10,%rsi,1),%ebp
movslq %ebp,%rbp
add    %rdx,%rbp
movsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x2,%rax
add    %r14d,%esi
add    %r15,%rdi
cmp    %rax,%r11
jne    1220 <radbg+0x100>
test   $0x1,%r8b
mov    0xc(%rsp),%ebp
je     11f0 <radbg+0xd0>
mov    %r10d,%esi
imul   %eax,%esi
movslq %esi,%rsi
add    %rdx,%rsi
mov    0x10(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm1
imul   %rcx,%rax
add    %rdx,%rax
mov    0x18(%rsp),%rsi
movsd  %xmm1,(%rsi,%rax,8)
jmp    11f0 <radbg+0xd0>
test   %ebp,%ebp
movapd 0x90(%rsp),%xmm11
jle    1520 <radbg+0x400>
mov    0x40(%rsp),%rax
mov    %eax,%r10d
mov    0x28(%rsp),%rax
imul   %eax,%r10d
movslq %eax,%r12
mov    %ebp,%ecx
mov    %eax,%edi
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdi,8),%rax
mov    %rax,0x38(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,0x88(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x80(%rsp)
mov    %edi,%edx
and    $0x3,%edx
lea    0x30(%rsi),%rax
mov    %rax,0xa8(%rsp)
mov    0x18(%rsp),%r14
lea    0x30(%r14),%r13
lea    0x0(,%r12,8),%r15
lea    0x18(%rsi),%rax
mov    %rax,0x60(%rsp)
xor    %r8d,%r8d
xor    %r9d,%r9d
mov    %rdx,0x30(%rsp)
mov    %rcx,0x20(%rsp)
jmp    1356 <radbg+0x236>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    %r10d,%r8d
add    %r15,%r13
add    %r15,%r14
cmp    %rcx,%r9
je     1520 <radbg+0x400>
mov    0x28(%rsp),%rax
test   %eax,%eax
jle    1340 <radbg+0x220>
movslq %r8d,%r11
cmp    $0x4,%eax
jae    1370 <radbg+0x250>
xor    %ebp,%ebp
jmp    1490 <radbg+0x370>
xchg   %ax,%ax
mov    %r9,%rbp
imul   %r12,%rbp
mov    %r10d,%eax
imul   %r9d,%eax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,8),%rdx
cltq
mov    0x38(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
cmp    %rsi,%rdx
jae    13be <radbg+0x29e>
lea    (%rdi,%rbp,1),%rdx
lea    (%rcx,%rdx,8),%rdx
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
cmp    %rdx,%rax
jae    13be <radbg+0x29e>
xor    %ebp,%ebp
mov    0x20(%rsp),%rcx
mov    0x30(%rsp),%rdx
jmp    1490 <radbg+0x370>
mov    %r12,%rsi
mov    %r10d,%ecx
cmpq   $0x0,0x70(%rsp)
je     142f <radbg+0x30f>
mov    0xa8(%rsp),%rax
lea    (%rax,%r11,8),%r10
mov    0x80(%rsp),%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%r10,%rax,8),%xmm1
movups -0x20(%r10,%rax,8),%xmm2
movups %xmm1,-0x30(%r13,%rax,8)
movups %xmm2,-0x20(%r13,%rax,8)
movupd -0x10(%r10,%rax,8),%xmm1
movupd (%r10,%rax,8),%xmm2
movupd %xmm1,-0x10(%r13,%rax,8)
movupd %xmm2,0x0(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r12
jne    13f0 <radbg+0x2d0>
jmp    1431 <radbg+0x311>
xor    %eax,%eax
testb  $0x1,0x88(%rsp)
01
mov    %ecx,%r10d
je     146e <radbg+0x34e>
mov    %r10d,%edx
imul   %r9d,%edx
movslq %edx,%rdx
add    %rax,%rdx
mov    0x10(%rsp),%rcx
movupd (%rcx,%rdx,8),%xmm1
movupd 0x10(%rcx,%rdx,8),%xmm2
add    %rax,%rbp
mov    0x18(%rsp),%rax
movupd %xmm1,(%rax,%rbp,8)
movupd %xmm2,0x10(%rax,%rbp,8)
mov    0x50(%rsp),%rax
mov    %rax,%rbp
cmp    %rdi,%rax
mov    %rsi,%r12
mov    0x20(%rsp),%rcx
mov    0x30(%rsp),%rdx
je     1340 <radbg+0x220>
nopl   0x0(%rax)
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %rdx,%rdx
je     14c5 <radbg+0x3a5>
mov    0x10(%rsp),%rsi
lea    (%rsi,%r11,8),%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%r14,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    14b0 <radbg+0x390>
cmp    $0x3,%rax
mov    0x30(%rsp),%rdx
jb     1340 <radbg+0x220>
mov    0x60(%rsp),%rax
lea    (%rax,%r11,8),%rax
nopl   (%rax)
movsd  -0x18(%rax,%rbp,8),%xmm1
movsd  %xmm1,(%r14,%rbp,8)
movsd  -0x10(%rax,%rbp,8),%xmm1
movsd  %xmm1,0x8(%r14,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm1
movsd  %xmm1,0x10(%r14,%rbp,8)
movsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,0x18(%r14,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    14e0 <radbg+0x3c0>
jmp    1340 <radbg+0x220>
mov    0x28(%rsp),%rax
mov    0x48(%rsp),%rcx
add    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,0xb4(%rsp)
sarl   0x5c(%rsp)
cmpl   $0x3,0x40(%rsp)
jl     1633 <radbg+0x513>
mov    0x40(%rsp),%r8
mov    %r8d,%ecx
mov    0x28(%rsp),%rsi
movslq %esi,%rax
mov    0x5c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%edi
cmovge %edx,%edi
mov    %rdi,0x30(%rsp)
mov    0xc(%rsp),%edx
movslq %edx,%r14
mov    %edx,%edx
mov    %rdx,0x20(%rsp)
lea    -0x1(%rcx),%rdi
imul   %rax,%r14
imul   %r14,%rdi
shl    $0x3,%rdi
shl    $0x3,%r14
lea    0x0(,%rax,8),%rbp
mov    %rax,%r11
shl    $0x4,%r11
mov    0x10(%rsp),%rdx
lea    (%rdx,%r11,1),%r9
imul   %rcx,%rax
shl    $0x3,%rax
lea    (%rsi,%rsi,1),%ecx
mov    %ecx,0x38(%rsp)
lea    (%rsi,%rsi,1),%r13d
add    $0xffffffff,%r13d
mov    %r8d,%edx
imul   %esi,%edx
mov    $0x1,%r12d
mov    %r14,%rsi
mov    0x10(%rsp),%rbx
jmp    15e9 <radbg+0x4c9>
add    $0x1,%r12
sub    %r14,%rdi
add    %r14,%rsi
add    %r11,%r9
add    0x38(%rsp),%r13d
cmp    0x30(%rsp),%r12
je     1633 <radbg+0x513>
cmpl   $0x0,0xc(%rsp)
jle    15d0 <radbg+0x4b0>
mov    0x20(%rsp),%rcx
mov    %r13d,%r8d
mov    %r9,%r15
mov    0x18(%rsp),%r10
movslq %r8d,%r8
movsd  (%rbx,%r8,8),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%rsi,1)
movsd  (%r15),%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,(%r10,%rdi,1)
add    %rbp,%r10
add    %rax,%r15
add    %edx,%r8d
add    $0xffffffffffffffff,%rcx
jne    1600 <radbg+0x4e0>
jmp    15d0 <radbg+0x4b0>
sarl   0xb4(%rsp)
cmpl   $0x1,0x28(%rsp)
jne    1e62 <radbg+0xd42>
cmpl   $0x3,0x40(%rsp)
jl     25ea <radbg+0x14ca>
movapd 0x19b7(%rip),%xmm9
xorpd  %xmm0,%xmm9
mov    0x40(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    0x68(%rsp),%r9d
imul   %r9d,%eax
movslq %r9d,%r12
movslq %eax,%r8
mov    %ecx,%ecx
mov    0x5c(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%edi
cmovge %eax,%edi
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %rdx,0x178(%rsp)
mov    %r12d,%r11d
lea    -0x1(%rcx),%rbp
imul   %r12,%rbp
mov    %rcx,0xd8(%rsp)
lea    -0x2(%rcx),%r14
imul   %r12,%r14
lea    (%r8,%r11,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x150(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm10
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x130(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x148(%rsp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,0x140(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x138(%rsp)
lea    0x0(,%r12,8),%r13
mov    %r13,%rax
neg    %rax
mov    %rax,0x30(%rsp)
mov    %r12,%rax
shl    $0x4,%rax
add    %rcx,%rax
mov    %rax,0x160(%rsp)
movsd  0x18cd(%rip),%xmm2
movapd 0x18cc(%rip),%xmm8
lea    (%r12,%r11,1),%rax
lea    0x0(%rbp,%r11,1),%rdx
mov    %rdx,0x168(%rsp)
lea    (%r12,%r12,1),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%r11,%r12,2),%rdx
mov    %rdx,0xc0(%rsp)
lea    (%r14,%r11,1),%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rcx,%r11,8),%rdx
mov    %rdx,0xf0(%rsp)
lea    (%rcx,%r12,8),%rdx
mov    %rdx,0xe8(%rsp)
mov    %rax,0x108(%rsp)
lea    (%rcx,%rax,8),%rax
mov    %rax,0xf8(%rsp)
mov    %r8,0x100(%rsp)
lea    (%rcx,%r8,8),%rax
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rbx
lea    0x10(%rbx,%r12,8),%rdx
lea    0x10(%rbx,%rbp,8),%rsi
lea    (%rbx,%r12,8),%r10
mov    %r14,0xa8(%rsp)
lea    (%rcx,%r14,8),%rax
mov    %rax,0x158(%rsp)
lea    (%rbx,%rbp,8),%r15
mov    $0x1,%eax
mov    %rax,0xc8(%rsp)
xor    %eax,%eax
mov    %r12,0x118(%rsp)
mov    %rbp,0x170(%rsp)
mov    %rbp,0x110(%rsp)
mov    %r12,0x80(%rsp)
mov    %r13,0x70(%rsp)
mov    %rdi,0x50(%rsp)
jmp    187f <radbg+0x75f>
nop
mov    0xc8(%rsp),%rcx
add    $0x1,%rcx
mov    0x180(%rsp),%rax
add    $0x1,%rax
mov    0x128(%rsp),%rdx
add    %r13,%rdx
mov    0x30(%rsp),%rbp
mov    0x120(%rsp),%rsi
add    %rbp,%rsi
sub    %r12,0x110(%rsp)
add    %r12,0x118(%rsp)
add    %r13,%r10
add    %rbp,%r15
mov    %rcx,0xc8(%rsp)
cmp    0x178(%rsp),%rcx
je     20be <radbg+0xf9e>
mov    %rsi,0x120(%rsp)
mov    %rdx,0x128(%rsp)
mov    %rax,0x180(%rsp)
imul   %r12,%rax
lea    (%rax,%r12,1),%rcx
mov    0x108(%rsp),%rdx
add    %rax,%rdx
mov    0x170(%rsp),%rsi
sub    %rax,%rsi
mov    0x168(%rsp),%rdi
sub    %rax,%rdi
mov    0x10(%rsp),%rbp
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
mov    %rax,0x20(%rsp)
lea    0x0(%rbp,%rdx,8),%rax
mov    %rax,0x60(%rsp)
lea    0x0(%rbp,%rsi,8),%rax
mov    %rax,0x48(%rsp)
lea    0x0(%rbp,%rdi,8),%rax
mov    %rax,0x90(%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   %r9d,%r9d
jle    19ac <radbg+0x88c>
cmp    $0x1,%r9d
jne    1c20 <radbg+0xb00>
xor    %r8d,%r8d
mov    0x110(%rsp),%rax
add    %r8,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rax,8),%r14
mov    0x100(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    0x118(%rsp),%rax
add    %r8,%rax
lea    (%rdx,%rax,8),%rbp
lea    (%r12,%r8,1),%rax
lea    (%rcx,%rax,8),%rax
lea    (%rcx,%r8,8),%rcx
mov    %r11,%rdi
sub    %r8,%rdi
xor    %edx,%edx
nop
movsd  (%rax,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rdx,8),%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%r14,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1980 <radbg+0x860>
cmpl   $0x5,0x40(%rsp)
mov    0x50(%rsp),%rdi
jb     1820 <radbg+0x700>
xorpd  %xmm8,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x90(%rsp),%rax
cmp    %rax,0x20(%rsp)
setb   %al
mov    0x48(%rsp),%rcx
cmp    0x60(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0x88(%rsp)
mov    $0x2,%ecx
mov    0x158(%rsp),%r8
mov    0x160(%rsp),%r14
xor    %esi,%esi
movapd %xmm2,%xmm6
jmp    1a29 <radbg+0x909>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x1,%rsi
add    %r13,%r14
add    0x30(%rsp),%r8
cmp    %rdi,%rcx
je     1820 <radbg+0x700>
movapd %xmm6,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm4,%xmm7
unpcklpd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
test   %r9d,%r9d
jle    1a10 <radbg+0x8f0>
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
cmp    $0x1,%r9d
jne    1aa0 <radbg+0x980>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r10,%rbp,8),%xmm0
movsd  %xmm0,(%r10,%rbp,8)
movsd  (%r8,%rbp,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1a60 <radbg+0x940>
jmp    1a10 <radbg+0x8f0>
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rax
imul   %r12,%rax
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,1),%rdi
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rax,1),%r12
mov    0xa8(%rsp),%rbp
sub    %rax,%rbp
mov    0xd0(%rsp),%rdx
sub    %rax,%rdx
mov    0x18(%rsp),%r9
lea    (%r9,%rdi,8),%rdi
lea    (%r9,%r12,8),%rax
lea    (%r9,%rbp,8),%r13
lea    (%r9,%rdx,8),%rbp
mov    0x20(%rsp),%rbx
cmp    %rax,%rbx
setb   %r9b
mov    0x60(%rsp),%rdx
cmp    %rdx,%rdi
setb   %r12b
and    %r9b,%r12b
or     0x88(%rsp),%r12b
cmp    %rbp,%rbx
setb   %bl
cmp    %rdx,%r13
setb   0x38(%rsp)
mov    0x48(%rsp),%rdx
cmp    %rax,%rdx
setb   %al
mov    0x90(%rsp),%r9
cmp    %r9,%rdi
setb   %dil
cmp    %rbp,%rdx
setb   %dl
cmp    %r9,%r13
setb   %r13b
test   %r12b,%r12b
jne    1bf1 <radbg+0xad1>
and    0x38(%rsp),%bl
jne    1bf1 <radbg+0xad1>
and    %dil,%al
mov    0x80(%rsp),%r12
jne    1c02 <radbg+0xae2>
mov    $0x0,%ebp
and    %r13b,%dl
mov    0x68(%rsp),%r9d
mov    0x70(%rsp),%r13
mov    0x50(%rsp),%rdi
jne    1a60 <radbg+0x940>
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
xor    %eax,%eax
mov    0x130(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r14,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
movupd (%r10,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r10,%rax,8)
movupd (%r8,%rax,8),%xmm0
movupd (%r15,%rax,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1ba0 <radbg+0xa80>
mov    %rdx,%rax
mov    %rdx,%rbp
cmp    %r11,%rdx
jne    1a60 <radbg+0x940>
jmp    1a10 <radbg+0x8f0>
xor    %ebp,%ebp
mov    0x68(%rsp),%r9d
mov    0x80(%rsp),%r12
jmp    1c09 <radbg+0xae9>
xor    %ebp,%ebp
mov    0x68(%rsp),%r9d
mov    0x70(%rsp),%r13
mov    0x50(%rsp),%rdi
jmp    1a60 <radbg+0x940>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    0x90(%rsp),%rdx
cmp    %rdx,%rax
setb   0x38(%rsp)
mov    0x60(%rsp),%r8
mov    0x48(%rsp),%rcx
cmp    %r8,%rcx
setb   0x88(%rsp)
mov    0xf0(%rsp),%rbp
cmp    %rbp,%rax
setb   %bl
mov    0x18(%rsp),%rsi
cmp    %rsi,%r8
seta   0x7f(%rsp)
cmp    0xf8(%rsp),%rax
setb   0x7e(%rsp)
mov    0xe8(%rsp),%rdi
cmp    %r8,%rdi
setb   0x7d(%rsp)
mov    0x150(%rsp),%r9
cmp    %r9,%rax
setb   %al
mov    0xe0(%rsp),%r14
cmp    %r8,%r14
setb   0x7c(%rsp)
cmp    %rbp,%rcx
setb   %bpl
cmp    %rsi,%rdx
seta   0x7b(%rsp)
cmp    0xf8(%rsp),%rcx
setb   %r8b
cmp    %rdx,%rdi
setb   %dil
cmp    %r9,%rcx
setb   %sil
cmp    %rdx,%r14
setb   %cl
mov    0x88(%rsp),%dl
test   %dl,0x38(%rsp)
jne    1e55 <radbg+0xd35>
and    0x7f(%rsp),%bl
jne    1e55 <radbg+0xd35>
mov    0x7d(%rsp),%dl
and    %dl,0x7e(%rsp)
mov    0x68(%rsp),%r9d
jne    1930 <radbg+0x810>
and    0x7c(%rsp),%al
jne    1930 <radbg+0x810>
and    0x7b(%rsp),%bpl
jne    1930 <radbg+0x810>
and    %dil,%r8b
jne    1930 <radbg+0x810>
mov    $0x0,%r8d
and    %cl,%sil
jne    1933 <radbg+0x813>
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
cmpq   $0x0,0x148(%rsp)
mov    0x128(%rsp),%rbp
mov    0x120(%rsp),%rdi
je     1dce <radbg+0xcae>
mov    0x138(%rsp),%rdx
xor    %ecx,%ecx
mov    0x18(%rsp),%r8
mov    0xe8(%rsp),%rax
mov    0xe0(%rsp),%rsi
movupd (%r8,%rcx,8),%xmm3
movupd (%rax,%rcx,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%rbp,%rcx,8)
movupd (%rsi,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rdi,%rcx,8)
movupd 0x10(%r8,%rcx,8),%xmm3
movupd 0x10(%rax,%rcx,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,0x0(%rbp,%rcx,8)
movupd 0x10(%rsi,%rcx,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1d70 <radbg+0xc50>
jmp    1dd5 <radbg+0xcb5>
xor    %ecx,%ecx
mov    0x18(%rsp),%r8
testb  $0x1,0x140(%rsp)
01
mov    0x130(%rsp),%rbp
je     1e44 <radbg+0xd24>
mov    0xd8(%rsp),%rax
mov    0xc8(%rsp),%rdx
sub    %rdx,%rax
imul   %r12,%rdx
imul   %r12,%rax
movupd (%r8,%rcx,8),%xmm3
lea    (%rcx,%r12,1),%rsi
movupd (%r8,%rsi,8),%xmm6
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
add    %rcx,%rdx
mov    0x10(%rsp),%rsi
movupd %xmm5,(%rsi,%rdx,8)
mov    0x100(%rsp),%rdx
add    %rcx,%rdx
movupd (%r8,%rdx,8),%xmm3
mulpd  %xmm4,%xmm3
add    %rcx,%rax
movupd %xmm3,(%rsi,%rax,8)
mov    %rbp,%r8
cmp    %r11,%rbp
jne    1933 <radbg+0x813>
jmp    19ac <radbg+0x88c>
xor    %r8d,%r8d
mov    0x68(%rsp),%r9d
jmp    1933 <radbg+0x813>
mov    0xb4(%rsp),%eax
cmp    0xc(%rsp),%eax
jge    22f3 <radbg+0x11d3>
cmpl   $0x3,0x40(%rsp)
jl     28c7 <radbg+0x17a7>
mov    0x40(%rsp),%r8
mov    %r8d,%eax
mov    0x28(%rsp),%rbp
movslq %ebp,%rsi
mov    0xc(%rsp),%r9d
movslq %r9d,%rcx
mov    0x5c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%edx
cmovge %edi,%edx
mov    %rdx,0x80(%rsp)
mov    %r9d,%edx
mov    %rdx,0x60(%rsp)
lea    -0x1(%rax),%rdx
imul   %rsi,%rcx
imul   %rcx,%rdx
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
add    $0x10,%rdx
mov    %rdx,0x70(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0xa8(%rsp)
neg    %rdx
mov    %rdx,0xb8(%rsp)
lea    0x0(,%rsi,8),%rdx
lea    (%rdi,%rcx,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x48(%rsp)
lea    0x0(%rbp,%rbp,1),%ecx
mov    %ecx,0xc0(%rsp)
mov    %r8d,%edi
imul   %ebp,%edi
lea    -0x3(%rbp,%rbp,1),%ecx
mov    %ecx,0x88(%rsp)
mov    %rsi,%rcx
shl    $0x4,%rcx
mov    %rcx,0xd0(%rsp)
mov    0x10(%rsp),%rbx
add    %rbx,%rcx
add    $0x10,%rcx
mov    %rcx,0x90(%rsp)
mov    %rsi,0x38(%rsp)
imul   %rsi,%rax
shl    $0x3,%rax
mov    $0x1,%esi
mov    %ebp,%ecx
mov    %ebp,0x20(%rsp)
jmp    1fc5 <radbg+0xea5>
nopl   0x0(%rax)
mov    0x50(%rsp),%rsi
add    $0x1,%rsi
mov    0xb8(%rsp),%rcx
add    %rcx,0x70(%rsp)
mov    0x48(%rsp),%rcx
add    0xa8(%rsp),%rcx
mov    %rcx,0x48(%rsp)
mov    0xc0(%rsp),%ecx
add    %ecx,0x20(%rsp)
add    %ecx,0x88(%rsp)
mov    0x90(%rsp),%rcx
add    0xd0(%rsp),%rcx
mov    %rcx,0x90(%rsp)
cmp    0x80(%rsp),%rsi
mov    0x28(%rsp),%rbp
je     1645 <radbg+0x525>
mov    %rsi,0x50(%rsp)
cmp    $0x3,%ebp
jl     1f60 <radbg+0xe40>
mov    $0x2,%ebp
mov    0x90(%rsp),%rcx
mov    %rcx,0x30(%rsp)
mov    0x88(%rsp),%r13d
mov    0x48(%rsp),%r15
mov    0x70(%rsp),%r11
jmp    2021 <radbg+0xf01>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rbp
add    $0x10,%r11
add    $0x10,%r15
add    $0xfffffffe,%r13d
addq   $0x10,0x30(%rsp)
cmp    0x38(%rsp),%rbp
jge    1f60 <radbg+0xe40>
cmpl   $0x0,0xc(%rsp)
jle    2000 <radbg+0xee0>
mov    0x38(%rsp),%rcx
sub    %rbp,%rcx
mov    0x60(%rsp),%rsi
mov    0x30(%rsp),%r9
mov    %r13d,%r8d
mov    0x20(%rsp),%ebx
mov    %ebx,%r14d
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r9),%xmm1
movslq %r8d,%r8
mov    0x10(%rsp),%rbx
addsd  (%rbx,%r8,8),%xmm1
movsd  %xmm1,-0x8(%r15,%r12,1)
movsd  -0x8(%r9),%xmm1
subsd  (%rbx,%r8,8),%xmm1
movsd  %xmm1,-0x8(%r11,%r12,1)
movsd  (%r9),%xmm1
movslq %r14d,%r14
lea    (%rcx,%r14,1),%r10
subsd  (%rbx,%r10,8),%xmm1
movsd  %xmm1,(%r15,%r12,1)
movsd  (%r9),%xmm1
addsd  (%rbx,%r10,8),%xmm1
movsd  %xmm1,(%r11,%r12,1)
add    %rdx,%r12
add    %edi,%r14d
add    %edi,%r8d
add    %rax,%r9
add    $0xffffffffffffffff,%rsi
jne    2050 <radbg+0xf30>
jmp    2000 <radbg+0xee0>
cmpl   $0x3,0x40(%rsp)
jl     25ea <radbg+0x14ca>
mov    0x5c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r15d
cmovge %eax,%r15d
mov    %r11d,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
mov    %r11,%r14
neg    %r14
mov    0x18(%rsp),%rax
lea    (%rax,%r12,8),%rsi
add    $0x30,%rsi
lea    (%rax,%r12,8),%rdx
add    $0x8,%rdx
mov    $0x1,%ecx
xor    %r12d,%r12d
mov    0x68(%rsp),%r9d
mov    0x80(%rsp),%r10
jmp    215c <radbg+0x103c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%r12
mov    0x70(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdx
cmp    %r15,%rcx
je     2516 <radbg+0x13f6>
test   %r9d,%r9d
jle    2140 <radbg+0x1020>
mov    %rcx,%r13
imul   %r10,%r13
cmp    $0x4,%r9d
jb     21a4 <radbg+0x1084>
mov    %r12,%rax
imul   %r10,%rax
mov    0x108(%rsp),%rdi
lea    (%rdi,%rax,1),%rbp
mov    0x18(%rsp),%rdi
lea    (%rdi,%rbp,8),%rbp
cmp    %rdi,%rbp
jbe    2211 <radbg+0x10f1>
add    %r10,%rax
lea    (%rdi,%rax,8),%rax
cmp    0xf0(%rsp),%rax
jae    2211 <radbg+0x10f1>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%r11b
je     21ce <radbg+0x10ae>
add    %rbp,%r13
mov    0x18(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
addsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    %r14,%rbp
mov    0x18(%rsp),%rbp
je     2140 <radbg+0x1020>
nop
movsd  -0x8(%rdx,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
addsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    21e0 <radbg+0x10c0>
jmp    2140 <radbg+0x1020>
cmpq   $0x0,0x30(%rsp)
je     22e8 <radbg+0x11c8>
mov    0x20(%rsp),%rax
xor    %ebp,%ebp
mov    0x18(%rsp),%r9
nopl   0x0(%rax)
movupd -0x30(%rsi,%rbp,8),%xmm0
movupd -0x20(%rsi,%rbp,8),%xmm1
movupd (%r9,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r9,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%r9,%rbp,8),%xmm1
movupd 0x30(%r9,%rbp,8),%xmm3
movupd %xmm2,(%r9,%rbp,8)
movupd %xmm0,0x10(%r9,%rbp,8)
movupd -0x10(%rsi,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rsi,%rbp,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%r9,%rbp,8)
movupd %xmm1,0x30(%r9,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    2230 <radbg+0x1110>
testb  $0x1,0x38(%rsp)
je     22d2 <radbg+0x11b2>
mov    %rbp,%rax
add    %r13,%rax
mov    0x18(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rdi,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rbp,8)
movupd %xmm0,0x10(%rdi,%rbp,8)
mov    %r8,%rbp
cmp    %r11,%r8
mov    0x68(%rsp),%r9d
je     2140 <radbg+0x1020>
jmp    21a6 <radbg+0x1086>
xor    %ebp,%ebp
testb  $0x1,0x38(%rsp)
jne    229e <radbg+0x117e>
jmp    22d2 <radbg+0x11b2>
cmpl   $0x3,0x40(%rsp)
jl     28c7 <radbg+0x17a7>
mov    0x28(%rsp),%rcx
movslq %ecx,%rax
mov    0x40(%rsp),%r8
mov    %r8d,%r9d
mov    0xc(%rsp),%edx
movslq %edx,%rbp
mov    0x5c(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%edi
cmovge %esi,%edi
mov    %r9,%rsi
mov    %rdi,0x70(%rsp)
mov    %edx,%edx
mov    %rdx,0x30(%rsp)
lea    -0x1(%r9),%rdx
imul   %rax,%rbp
imul   %rbp,%rdx
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
mov    %rdx,0x48(%rsp)
lea    0x0(,%rbp,8),%rdx
mov    %rdx,0x88(%rsp)
neg    %rdx
mov    %rdx,0x80(%rsp)
lea    0x0(,%rax,8),%r12
lea    (%rdi,%rbp,8),%rdi
mov    %rdi,0x20(%rsp)
mov    %rax,%rdi
shl    $0x4,%rdi
mov    %rdi,0xa8(%rsp)
mov    0x10(%rsp),%rdx
add    %rdx,%rdi
mov    %rdi,0x60(%rsp)
imul   %rax,%rsi
shl    $0x3,%rsi
lea    (%rcx,%rcx,1),%edi
mov    %edi,0xb8(%rsp)
lea    (%rcx,%rcx,1),%edi
add    $0xfffffffd,%edi
mov    %edi,0x90(%rsp)
mov    %r8d,%r9d
imul   %ecx,%r9d
lea    -0x10(%rdx),%rdi
mov    %rdi,0x38(%rsp)
mov    $0x1,%ebx
mov    %ecx,%edx
mov    %ecx,0x50(%rsp)
jmp    2432 <radbg+0x1312>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    0x80(%rsp),%rdi
add    %rdi,0x48(%rsp)
mov    0x20(%rsp),%rdi
add    0x88(%rsp),%rdi
mov    %rdi,0x20(%rsp)
mov    0x60(%rsp),%rdi
add    0xa8(%rsp),%rdi
mov    %rdi,0x60(%rsp)
mov    0xb8(%rsp),%edi
add    %edi,0x90(%rsp)
add    %edi,0x50(%rsp)
cmp    0x70(%rsp),%rbx
je     1645 <radbg+0x525>
cmpl   $0x0,0xc(%rsp)
jle    23e0 <radbg+0x12c0>
mov    0x50(%rsp),%ebp
mov    0x90(%rsp),%r8d
mov    0x60(%rsp),%rdi
mov    0x20(%rsp),%r15
mov    0x48(%rsp),%r11
xor    %r13d,%r13d
jmp    2483 <radbg+0x1363>
nopl   0x0(%rax)
add    $0x1,%r13
add    %r12,%r11
add    %r12,%r15
add    %rsi,%rdi
add    %r9d,%r8d
add    %r9d,%ebp
cmp    0x30(%rsp),%r13
mov    0x28(%rsp),%rcx
je     23e0 <radbg+0x12c0>
cmp    $0x3,%ecx
jl     2460 <radbg+0x1340>
movslq %ebp,%rcx
add    %rax,%rcx
mov    %rsi,%rdx
mov    0x38(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    %rdx,%rsi
mov    $0x2,%r14d
mov    %r8d,%r10d
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%r14,8),%xmm1
movslq %r10d,%r10
mov    0x10(%rsp),%rdx
addsd  (%rdx,%r10,8),%xmm1
movsd  %xmm1,-0x8(%r15,%r14,8)
movsd  -0x8(%rdi,%r14,8),%xmm1
subsd  (%rdx,%r10,8),%xmm1
movsd  %xmm1,-0x8(%r11,%r14,8)
movsd  (%rdi,%r14,8),%xmm1
subsd  (%rcx),%xmm1
movsd  %xmm1,(%r15,%r14,8)
movsd  (%rdi,%r14,8),%xmm1
addsd  (%rcx),%xmm1
movsd  %xmm1,(%r11,%r14,8)
add    $0x2,%r14
add    $0xfffffffe,%r10d
add    $0xfffffffffffffff0,%rcx
cmp    %rax,%r14
jl     24b0 <radbg+0x1390>
jmp    2460 <radbg+0x1340>
cmpl   $0x3,0x40(%rsp)
jl     25ea <radbg+0x14ca>
movslq 0x28(%rsp),%r15
mov    0xc(%rsp),%ecx
movslq %ecx,%rax
mov    0x5c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%r9d
cmovge %edx,%r9d
mov    %ecx,%r8d
mov    0xd8(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
imul   %r15,%rax
imul   %rax,%rcx
mov    0x10(%rsp),%rbx
lea    (%rbx,%rcx,8),%rsi
lea    0x0(,%rax,8),%r10
mov    %r10,%r11
neg    %r11
shl    $0x3,%r15
mov    0x18(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdx
lea    (%rbx,%rax,8),%rcx
lea    (%rdi,%rax,8),%rbp
mov    $0x1,%r14d
jmp    25a5 <radbg+0x1485>
nopl   0x0(%rax)
add    $0x1,%r14
add    %r11,%rsi
add    %r11,%rdx
add    %r10,%rcx
add    %r10,%rbp
cmp    %r9,%r14
je     25ea <radbg+0x14ca>
cmpl   $0x0,0xc(%rsp)
jle    2590 <radbg+0x1470>
mov    %r8,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,1),%xmm0
subsd  (%rsi,%rax,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,1)
movsd  (%rcx,%rax,1),%xmm0
addsd  (%rsi,%rax,1),%xmm0
movsd  %xmm0,(%rdx,%rax,1)
add    %r15,%rax
add    $0xffffffffffffffff,%rdi
jne    25c0 <radbg+0x14a0>
jmp    2590 <radbg+0x1470>
cmpl   $0x1,0x28(%rsp)
je     2f67 <radbg+0x1e47>
mov    0xb4(%rsp),%eax
cmp    0xc(%rsp),%eax
jge    277c <radbg+0x165c>
cmpl   $0x3,0x40(%rsp)
jl     28c7 <radbg+0x17a7>
movslq 0x28(%rsp),%rax
mov    0x40(%rsp),%edx
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
mov    0x5c(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%r10d
cmovge %esi,%r10d
mov    %ecx,%esi
add    $0xffffffffffffffff,%rdx
imul   %rax,%rdi
imul   %rdi,%rdx
mov    0x18(%rsp),%rbp
lea    0x10(,%rdx,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x30(%rsp)
lea    0x0(,%rdi,8),%rcx
mov    %rcx,0x38(%rsp)
neg    %rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rax,8),%rcx
mov    0x10(%rsp),%rbx
lea    (%rbx,%rdx,8),%r9
add    $0x10,%r9
lea    0x10(%rbx,%rdi,8),%r8
mov    %r10,%rbx
lea    0x10(,%rdi,8),%r13
add    %rbp,%r13
mov    $0x1,%r12d
jmp    26c5 <radbg+0x15a5>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x20(%rsp),%rdx
add    %rdx,0x30(%rsp)
add    %rdx,%r9
mov    0x38(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%r13
cmp    %rbx,%r12
je     28c7 <radbg+0x17a7>
cmpl   $0x3,0x28(%rsp)
jl     26a0 <radbg+0x1580>
mov    $0x2,%ebp
mov    %r13,%rdi
mov    %r8,%r15
mov    %r9,%r14
mov    0x30(%rsp),%r11
jmp    2709 <radbg+0x15e9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbp
add    $0x10,%r11
add    $0x10,%r14
add    $0x10,%r15
add    $0x10,%rdi
cmp    %rax,%rbp
jge    26a0 <radbg+0x1580>
cmpl   $0x0,0xc(%rsp)
jle    26f0 <radbg+0x15d0>
mov    %rsi,%rdx
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r15,%r10,1),%xmm0
subsd  (%r14,%r10,1),%xmm0
movsd  %xmm0,-0x8(%rdi,%r10,1)
movsd  -0x8(%r15,%r10,1),%xmm0
addsd  (%r14,%r10,1),%xmm0
movsd  %xmm0,-0x8(%r11,%r10,1)
movsd  (%r15,%r10,1),%xmm0
addsd  -0x8(%r14,%r10,1),%xmm0
movsd  %xmm0,(%rdi,%r10,1)
movsd  (%r15,%r10,1),%xmm0
subsd  -0x8(%r14,%r10,1),%xmm0
movsd  %xmm0,(%r11,%r10,1)
add    %rcx,%r10
add    $0xffffffffffffffff,%rdx
jne    2720 <radbg+0x1600>
jmp    26f0 <radbg+0x15d0>
cmpl   $0x3,0x40(%rsp)
jl     28c7 <radbg+0x17a7>
movslq 0x28(%rsp),%rax
mov    0x40(%rsp),%esi
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
mov    0x5c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%ebp
cmovge %edx,%ebp
mov    %rbp,0x30(%rsp)
mov    %ecx,%edx
imul   %rax,%rdi
mov    0x10(%rsp),%r10
lea    (%r10,%rdi,8),%r9
lea    0x0(,%rdi,8),%rbx
lea    0x0(,%rax,8),%rcx
mov    0x18(%rsp),%r11
lea    (%r11,%rdi,8),%r8
add    $0xffffffffffffffff,%rsi
imul   %rdi,%rsi
lea    (%r10,%rsi,8),%r15
mov    %rbx,0x38(%rsp)
neg    %rbx
lea    (%r11,%rsi,8),%r13
mov    $0x1,%r12d
jmp    2823 <radbg+0x1703>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
mov    0x38(%rsp),%rsi
add    %rsi,%r9
add    %rsi,%r8
mov    %rbx,%rsi
add    %rbx,%r15
add    %rbx,%r13
cmp    0x30(%rsp),%r12
je     28c7 <radbg+0x17a7>
cmpl   $0x0,0xc(%rsp)
jle    2800 <radbg+0x16e0>
mov    %r13,%rbp
mov    %r15,%rsi
mov    %r8,%r14
mov    %r9,%r10
xor    %r11d,%r11d
jmp    2855 <radbg+0x1735>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %rcx,%r10
add    %rcx,%r14
add    %rcx,%rsi
add    %rcx,%rbp
cmp    %rdx,%r11
je     2800 <radbg+0x16e0>
cmpl   $0x3,0x28(%rsp)
jl     2840 <radbg+0x1720>
mov    $0x2,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r10,%rdi,8),%xmm0
subsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rdi,8)
movsd  -0x8(%r10,%rdi,8),%xmm0
addsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdi,8)
movsd  (%r10,%rdi,8),%xmm0
addsd  -0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
movsd  (%r10,%rdi,8),%xmm0
subsd  -0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x2,%rdi
cmp    %rax,%rdi
jl     2870 <radbg+0x1750>
jmp    2840 <radbg+0x1720>
mov    0x68(%rsp),%ecx
test   %ecx,%ecx
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%r9
jle    2a78 <radbg+0x1958>
mov    %ecx,%r8d
cmp    $0x4,%ecx
jb     2906 <radbg+0x17e6>
lea    (%rax,%r8,8),%rcx
cmp    0x10(%rsp),%rcx
jbe    298c <radbg+0x186c>
mov    0x10(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
cmp    %rax,%rcx
jbe    298c <radbg+0x186c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     2934 <radbg+0x1814>
mov    0x10(%rsp),%rdi
nop
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2920 <radbg+0x1800>
cmp    $0x3,%rdx
jb     2a78 <radbg+0x1958>
mov    0x10(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rcx,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2950 <radbg+0x1830>
jmp    2a78 <radbg+0x1958>
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    29b3 <radbg+0x1893>
xor    %edi,%edi
jmp    2a2d <radbg+0x190d>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
mov    0x10(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,8),%xmm0
movups 0x10(%rax,%rdi,8),%xmm1
movups %xmm0,0x0(%rbp,%rdi,8)
movups %xmm1,0x10(%rbp,%rdi,8)
movups 0x20(%rax,%rdi,8),%xmm0
movups 0x30(%rax,%rdi,8),%xmm1
movups %xmm0,0x20(%rbp,%rdi,8)
movups %xmm1,0x30(%rbp,%rdi,8)
movups 0x40(%rax,%rdi,8),%xmm0
movups 0x50(%rax,%rdi,8),%xmm1
movups %xmm0,0x40(%rbp,%rdi,8)
movups %xmm1,0x50(%rbp,%rdi,8)
movupd 0x60(%rax,%rdi,8),%xmm0
movupd 0x70(%rax,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbp,%rdi,8)
movupd %xmm1,0x70(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    29d0 <radbg+0x18b0>
test   %rdx,%rdx
je     2a6f <radbg+0x194f>
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   (%rax)
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    2a50 <radbg+0x1930>
cmp    %r8,%rcx
jne    2908 <radbg+0x17e8>
cmpl   $0x2,0x40(%rsp)
jl     2f67 <radbg+0x1e47>
movslq %r9d,%rax
mov    0xc(%rsp),%ecx
movslq %ecx,%r13
mov    %ecx,%r15d
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x90(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x88(%rsp)
lea    0x2(%r13),%rcx
imul   %rax,%rcx
mov    0x10(%rsp),%rbx
lea    (%rbx,%rcx,8),%rdx
mov    %rdx,0x80(%rsp)
mov    %r13,%rdx
imul   %rax,%rdx
lea    0x0(,%rdx,8),%rsi
mov    %rsi,0x68(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,0xa8(%rsp)
mov    0x18(%rsp),%r10
lea    (%r10,%rcx,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x1(%r13),%rdi
imul   %rax,%rdi
lea    (%rbx,%rdi,8),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%r10,%rdi,8),%r9
lea    0x3(%r13),%rdi
imul   %rax,%rdi
lea    (%rbx,%rdi,8),%r8
lea    (%r10,%rdi,8),%r11
lea    (%r10,%rdx,8),%r10
lea    (%rbx,%rdx,8),%r14
mov    0x1c0(%rsp),%rdx
mov    0x40(%rsp),%edi
mov    %rdi,0x38(%rsp)
mov    %r15,0x30(%rsp)
lea    -0x1(%r15),%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rax,8),%r12
mov    $0x1,%ecx
xor    %esi,%esi
mov    %r13,0x50(%rsp)
mov    %r13,%rbp
jmp    2b89 <radbg+0x1a69>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    0x68(%rsp),%rsi
add    0x50(%rsp),%rbp
cmp    0x38(%rsp),%rcx
je     2c70 <radbg+0x1b50>
cmpl   $0x0,0xc(%rsp)
jle    2b70 <radbg+0x1a50>
mov    %rbp,0x48(%rsp)
mov    %rcx,0x20(%rsp)
cmpq   $0x3,0x70(%rsp)
mov    %rsi,0x60(%rsp)
jae    2bb0 <radbg+0x1a90>
xor    %r15d,%r15d
jmp    2c1a <radbg+0x1afa>
nopl   0x0(%rax)
mov    %rsi,%rdi
xor    %r15d,%r15d
mov    0x88(%rsp),%r13
mov    0x80(%rsp),%rbp
mov    0xa8(%rsp),%rcx
mov    0xb8(%rsp),%rsi
mov    0xc0(%rsp),%rbx
xchg   %ax,%ax
movsd  (%r10,%rdi,1),%xmm0
movsd  %xmm0,(%r14,%rdi,1)
movsd  (%r9,%rdi,1),%xmm0
movsd  %xmm0,(%rbx,%rdi,1)
movsd  (%rsi,%rdi,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,1)
movsd  (%r11,%rdi,1),%xmm0
movsd  %xmm0,(%r8,%rdi,1)
add    $0x4,%r15
add    %rcx,%rdi
cmp    %r15,%r13
jne    2be0 <radbg+0x1ac0>
cmpq   $0x0,0x90(%rsp)
mov    0x18(%rsp),%r13
mov    0x20(%rsp),%rcx
mov    0x60(%rsp),%rsi
mov    0x48(%rsp),%rbp
je     2b70 <radbg+0x1a50>
add    %rbp,%r15
imul   %r12,%r15
mov    0x90(%rsp),%rdi
nopl   0x0(%rax)
movsd  0x0(%r13,%r15,1),%xmm0
mov    0x10(%rsp),%rbx
movsd  %xmm0,(%rbx,%r15,1)
add    %r12,%r15
add    $0xffffffffffffffff,%rdi
jne    2c50 <radbg+0x1b30>
jmp    2b70 <radbg+0x1a50>
mov    0xb4(%rsp),%ecx
cmp    0xc(%rsp),%ecx
jle    2e09 <radbg+0x1ce9>
cmpl   $0x2,0x40(%rsp)
mov    0x28(%rsp),%rdi
jl     2f67 <radbg+0x1e47>
movslq 0xc(%rsp),%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rbp
mov    %rcx,0x70(%rsp)
add    %rcx,%rbp
mov    %rbp,0x20(%rsp)
mov    %rax,%r14
shl    $0x20,%r14
mov    0x18(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x48(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x90(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x68(%rsp)
movl   $0xffffffff,0x50(%rsp)
ff
mov    $0x1,%esi
movabs $0x200000000,%r8
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%rbx
jmp    2d49 <radbg+0x1c29>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rsi
add    $0x1,%rsi
add    %edi,0x50(%rsp)
mov    0x20(%rsp),%rcx
add    0x70(%rsp),%rcx
mov    %rcx,0x20(%rsp)
mov    0x68(%rsp),%rcx
add    %rcx,0x48(%rsp)
add    %rcx,0x90(%rsp)
cmp    0x38(%rsp),%rsi
je     2f67 <radbg+0x1e47>
mov    %rsi,0x60(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    2d10 <radbg+0x1bf0>
movslq 0x50(%rsp),%rcx
lea    (%rdx,%rcx,8),%rbp
mov    0x90(%rsp),%rcx
mov    0x48(%rsp),%rsi
mov    0x20(%rsp),%r9
xor    %r15d,%r15d
jmp    2d9d <radbg+0x1c7d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
add    %r14,%r9
add    %r12,%rsi
add    %r12,%rcx
cmp    0x30(%rsp),%r15
mov    0x28(%rsp),%rdi
je     2d10 <radbg+0x1bf0>
cmp    $0x3,%edi
jl     2d80 <radbg+0x1c60>
mov    $0x2,%edi
mov    %r9,%r13
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rdi,8),%xmm0
mov    %r13,%r11
movsd  (%rsi,%rdi,8),%xmm1
mulsd  0x0(%rbp,%rdi,8),%xmm1
sar    $0x1d,%r11
mulsd  (%r10,%r11,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r11,1)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  (%r10,%r11,1),%xmm0
movsd  -0x8(%rbp,%rdi,8),%xmm1
mulsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    $0x2,%rdi
add    %r8,%r13
cmp    %rax,%rdi
jl     2db0 <radbg+0x1c90>
jmp    2d80 <radbg+0x1c60>
cmpl   $0x2,0x40(%rsp)
mov    0x28(%rsp),%rsi
jl     2f67 <radbg+0x1e47>
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
imul   %esi,%ecx
mov    %rcx,0x68(%rsp)
add    $0x1,%ecx
mov    %ecx,0x20(%rsp)
imul   %rax,%rdi
mov    0x18(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x60(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x48(%rsp)
shl    $0x3,%rdi
mov    %rdi,0x50(%rsp)
movl   $0xffffffff,0x90(%rsp)
ff ff ff ff
mov    $0x1,%r13d
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%r14
mov    0x10(%rsp),%rbx
jmp    2eb6 <radbg+0x1d96>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x28(%rsp),%rsi
add    %esi,0x90(%rsp)
mov    0x20(%rsp),%ecx
add    0x68(%rsp),%ecx
mov    %ecx,0x20(%rsp)
mov    0x50(%rsp),%rcx
add    %rcx,0x60(%rsp)
add    %rcx,0x48(%rsp)
cmp    0x38(%rsp),%r13
je     2f67 <radbg+0x1e47>
cmp    $0x3,%esi
jl     2e80 <radbg+0x1d60>
movslq 0x90(%rsp),%r8
mov    $0x2,%ebp
mov    0x48(%rsp),%rsi
mov    0x60(%rsp),%rcx
mov    0x20(%rsp),%r12d
jmp    2ef8 <radbg+0x1dd8>
nopl   0x0(%rax)
add    $0x2,%rbp
add    $0x2,%r12d
add    $0x10,%rcx
add    $0x10,%rsi
mov    %r10,%r8
cmp    %rax,%rbp
jge    2e80 <radbg+0x1d60>
lea    0x2(%r8),%r10
cmpl   $0x0,0xc(%rsp)
jle    2ee0 <radbg+0x1dc0>
mov    $0x2,%edi
mov    0x30(%rsp),%r11
mov    %r12d,%r15d
movsd  0x8(%rdx,%r8,8),%xmm0
movsd  (%rcx,%rdi,8),%xmm1
mulsd  (%rdx,%r10,8),%xmm1
movslq %r15d,%r15
mulsd  (%r9,%r15,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r15,8)
movsd  (%rdx,%r10,8),%xmm0
mulsd  (%r9,%r15,8),%xmm0
movsd  0x8(%rdx,%r8,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
add    %r14d,%r15d
add    %rax,%rdi
add    $0xffffffffffffffff,%r11
jne    2f10 <radbg+0x1df0>
jmp    2ee0 <radbg+0x1dc0>
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) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca i32
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%39 = load i32, i32* %9
%40 = sitofp i32 %39 to double
%41 = fdiv double 0x401921FB54442D1C, %40
store double %41, double* %35
%42 = load double, double* %35
%43 = call double @cos(double %42)
store double %43, double* %34
%44 = load double, double* %35
%45 = call double @sin(double %44)
store double %45, double* %36
%46 = load i32, i32* %8
%47 = sub nsw i32 %46, 1
%48 = sdiv i32 %47, 2
store i32 %48, i32* %33
%49 = load i32, i32* %9
%50 = add nsw i32 %49, 1
%51 = sdiv i32 %50, 2
store i32 %51, i32* %16
%52 = load i32, i32* %8
%53 = load i32, i32* %10
%54 = icmp sge i32 %52, %53
br i1 %54, label %55, label %93
55: ; preds = %7
store i32 0, i32* %19
br label %56
56: ; preds = %89, %55
%57 = load i32, i32* %19
%58 = load i32, i32* %10
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %92
60: ; preds = %56
store i32 0, i32* %17
br label %61
61: ; preds = %85, %60
%62 = load i32, i32* %17
%63 = load i32, i32* %8
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %88
65: ; preds = %61
%66 = load double*, double** %12
%67 = load i32, i32* %17
%68 = load i32, i32* %19
%69 = load i32, i32* %9
%70 = mul nsw i32 %68, %69
%71 = load i32, i32* %8
%72 = mul nsw i32 %70, %71
%73 = add nsw i32 %67, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %66, i64 %74
%76 = load double, double* %75
%77 = load double*, double** %13
%78 = load i32, i32* %17
%79 = load i32, i32* %19
%80 = load i32, i32* %8
%81 = mul nsw i32 %79, %80
%82 = add nsw i32 %78, %81
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %77, i64 %83
store double %76, double* %84
br label %85
85: ; preds = %65
%86 = load i32, i32* %17
%87 = add nsw i32 %86, 1
store i32 %87, i32* %17
br label %61
88: ; preds = %61
br label %89
89: ; preds = %88
%90 = load i32, i32* %19
%91 = add nsw i32 %90, 1
store i32 %91, i32* %19
br label %56
92: ; preds = %56
br label %131
93: ; preds = %7
store i32 0, i32* %17
br label %94
94: ; preds = %127, %93
%95 = load i32, i32* %17
%96 = load i32, i32* %8
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %130
98: ; preds = %94
store i32 0, i32* %19
br label %99
99: ; preds = %123, %98
%100 = load i32, i32* %19
%101 = load i32, i32* %10
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %126
103: ; preds = %99
%104 = load double*, double** %12
%105 = load i32, i32* %17
%106 = load i32, i32* %19
%107 = load i32, i32* %9
%108 = mul nsw i32 %106, %107
%109 = load i32, i32* %8
%110 = mul nsw i32 %108, %109
%111 = add nsw i32 %105, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %104, i64 %112
%114 = load double, double* %113
%115 = load double*, double** %13
%116 = load i32, i32* %17
%117 = load i32, i32* %19
%118 = load i32, i32* %8
%119 = mul nsw i32 %117, %118
%120 = add nsw i32 %116, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %115, i64 %121
store double %114, double* %122
br label %123
123: ; preds = %103
%124 = load i32, i32* %19
%125 = add nsw i32 %124, 1
store i32 %125, i32* %19
br label %99
126: ; preds = %99
br label %127
127: ; preds = %126
%128 = load i32, i32* %17
%129 = add nsw i32 %128, 1
store i32 %129, i32* %17
br label %94
130: ; preds = %94
br label %131
131: ; preds = %130, %92
store i32 1, i32* %18
br label %132
132: ; preds = %225, %131
%133 = load i32, i32* %18
%134 = load i32, i32* %16
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %228
136: ; preds = %132
%137 = load i32, i32* %9
%138 = load i32, i32* %18
%139 = sub nsw i32 %137, %138
store i32 %139, i32* %23
%140 = load i32, i32* %18
%141 = mul nsw i32 2, %140
store i32 %141, i32* %21
store i32 0, i32* %19
br label %142
142: ; preds = %221, %136
%143 = load i32, i32* %19
%144 = load i32, i32* %10
%145 = icmp slt i32 %143, %144
br i1 %145, label %146, label %224
146: ; preds = %142
%147 = load double*, double** %12
%148 = load i32, i32* %8
%149 = sub nsw i32 %148, 1
%150 = load i32, i32* %21
%151 = sub nsw i32 %150, 1
%152 = load i32, i32* %19
%153 = load i32, i32* %9
%154 = mul nsw i32 %152, %153
%155 = add nsw i32 %151, %154
%156 = load i32, i32* %8
%157 = mul nsw i32 %155, %156
%158 = add nsw i32 %149, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %147, i64 %159
%161 = load double, double* %160
%162 = load double*, double** %12
%163 = load i32, i32* %8
%164 = sub nsw i32 %163, 1
%165 = load i32, i32* %21
%166 = sub nsw i32 %165, 1
%167 = load i32, i32* %19
%168 = load i32, i32* %9
%169 = mul nsw i32 %167, %168
%170 = add nsw i32 %166, %169
%171 = load i32, i32* %8
%172 = mul nsw i32 %170, %171
%173 = add nsw i32 %164, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %162, i64 %174
%176 = load double, double* %175
%177 = fadd double %161, %176
%178 = load double*, double** %13
%179 = load i32, i32* %19
%180 = load i32, i32* %18
%181 = load i32, i32* %10
%182 = mul nsw i32 %180, %181
%183 = add nsw i32 %179, %182
%184 = load i32, i32* %8
%185 = mul nsw i32 %183, %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %178, i64 %186
store double %177, double* %187
%188 = load double*, double** %12
%189 = load i32, i32* %21
%190 = load i32, i32* %19
%191 = load i32, i32* %9
%192 = mul nsw i32 %190, %191
%193 = add nsw i32 %189, %192
%194 = load i32, i32* %8
%195 = mul nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %188, i64 %196
%198 = load double, double* %197
%199 = load double*, double** %12
%200 = load i32, i32* %21
%201 = load i32, i32* %19
%202 = load i32, i32* %9
%203 = mul nsw i32 %201, %202
%204 = add nsw i32 %200, %203
%205 = load i32, i32* %8
%206 = mul nsw i32 %204, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %199, i64 %207
%209 = load double, double* %208
%210 = fadd double %198, %209
%211 = load double*, double** %13
%212 = load i32, i32* %19
%213 = load i32, i32* %23
%214 = load i32, i32* %10
%215 = mul nsw i32 %213, %214
%216 = add nsw i32 %212, %215
%217 = load i32, i32* %8
%218 = mul nsw i32 %216, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %211, i64 %219
store double %210, double* %220
br label %221
221: ; preds = %146
%222 = load i32, i32* %19
%223 = add nsw i32 %222, 1
store i32 %223, i32* %19
br label %142
224: ; preds = %142
br label %225
225: ; preds = %224
%226 = load i32, i32* %18
%227 = add nsw i32 %226, 1
store i32 %227, i32* %18
br label %132
228: ; preds = %132
%229 = load i32, i32* %8
%230 = icmp ne i32 %229, 1
br i1 %230, label %231, label %652
231: ; preds = %228
%232 = load i32, i32* %33
%233 = load i32, i32* %10
%234 = icmp sge i32 %232, %233
br i1 %234, label %235, label %443
235: ; preds = %231
store i32 1, i32* %18
br label %236
236: ; preds = %439, %235
%237 = load i32, i32* %18
%238 = load i32, i32* %16
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %442
240: ; preds = %236
%241 = load i32, i32* %9
%242 = load i32, i32* %18
%243 = sub nsw i32 %241, %242
store i32 %243, i32* %23
store i32 0, i32* %19
br label %244
244: ; preds = %435, %240
%245 = load i32, i32* %19
%246 = load i32, i32* %10
%247 = icmp slt i32 %245, %246
br i1 %247, label %248, label %438
248: ; preds = %244
store i32 2, i32* %17
br label %249
249: ; preds = %431, %248
%250 = load i32, i32* %17
%251 = load i32, i32* %8
%252 = icmp slt i32 %250, %251
br i1 %252, label %253, label %434
253: ; preds = %249
%254 = load i32, i32* %8
%255 = load i32, i32* %17
%256 = sub nsw i32 %254, %255
store i32 %256, i32* %22
%257 = load double*, double** %12
%258 = load i32, i32* %17
%259 = sub nsw i32 %258, 1
%260 = load i32, i32* %18
%261 = mul nsw i32 2, %260
%262 = load i32, i32* %19
%263 = load i32, i32* %9
%264 = mul nsw i32 %262, %263
%265 = add nsw i32 %261, %264
%266 = load i32, i32* %8
%267 = mul nsw i32 %265, %266
%268 = add nsw i32 %259, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %257, i64 %269
%271 = load double, double* %270
%272 = load double*, double** %12
%273 = load i32, i32* %22
%274 = sub nsw i32 %273, 1
%275 = load i32, i32* %18
%276 = mul nsw i32 2, %275
%277 = sub nsw i32 %276, 1
%278 = load i32, i32* %19
%279 = load i32, i32* %9
%280 = mul nsw i32 %278, %279
%281 = add nsw i32 %277, %280
%282 = load i32, i32* %8
%283 = mul nsw i32 %281, %282
%284 = add nsw i32 %274, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %272, i64 %285
%287 = load double, double* %286
%288 = fadd double %271, %287
%289 = load double*, double** %13
%290 = load i32, i32* %17
%291 = sub nsw i32 %290, 1
%292 = load i32, i32* %19
%293 = load i32, i32* %18
%294 = load i32, i32* %10
%295 = mul nsw i32 %293, %294
%296 = add nsw i32 %292, %295
%297 = load i32, i32* %8
%298 = mul nsw i32 %296, %297
%299 = add nsw i32 %291, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %289, i64 %300
store double %288, double* %301
%302 = load double*, double** %12
%303 = load i32, i32* %17
%304 = sub nsw i32 %303, 1
%305 = load i32, i32* %18
%306 = mul nsw i32 2, %305
%307 = load i32, i32* %19
%308 = load i32, i32* %9
%309 = mul nsw i32 %307, %308
%310 = add nsw i32 %306, %309
%311 = load i32, i32* %8
%312 = mul nsw i32 %310, %311
%313 = add nsw i32 %304, %312
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %302, i64 %314
%316 = load double, double* %315
%317 = load double*, double** %12
%318 = load i32, i32* %22
%319 = sub nsw i32 %318, 1
%320 = load i32, i32* %18
%321 = mul nsw i32 2, %320
%322 = sub nsw i32 %321, 1
%323 = load i32, i32* %19
%324 = load i32, i32* %9
%325 = mul nsw i32 %323, %324
%326 = add nsw i32 %322, %325
%327 = load i32, i32* %8
%328 = mul nsw i32 %326, %327
%329 = add nsw i32 %319, %328
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %317, i64 %330
%332 = load double, double* %331
%333 = fsub double %316, %332
%334 = load double*, double** %13
%335 = load i32, i32* %17
%336 = sub nsw i32 %335, 1
%337 = load i32, i32* %19
%338 = load i32, i32* %23
%339 = load i32, i32* %10
%340 = mul nsw i32 %338, %339
%341 = add nsw i32 %337, %340
%342 = load i32, i32* %8
%343 = mul nsw i32 %341, %342
%344 = add nsw i32 %336, %343
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %334, i64 %345
store double %333, double* %346
%347 = load double*, double** %12
%348 = load i32, i32* %17
%349 = load i32, i32* %18
%350 = mul nsw i32 2, %349
%351 = load i32, i32* %19
%352 = load i32, i32* %9
%353 = mul nsw i32 %351, %352
%354 = add nsw i32 %350, %353
%355 = load i32, i32* %8
%356 = mul nsw i32 %354, %355
%357 = add nsw i32 %348, %356
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %347, i64 %358
%360 = load double, double* %359
%361 = load double*, double** %12
%362 = load i32, i32* %22
%363 = load i32, i32* %18
%364 = mul nsw i32 2, %363
%365 = sub nsw i32 %364, 1
%366 = load i32, i32* %19
%367 = load i32, i32* %9
%368 = mul nsw i32 %366, %367
%369 = add nsw i32 %365, %368
%370 = load i32, i32* %8
%371 = mul nsw i32 %369, %370
%372 = add nsw i32 %362, %371
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %361, i64 %373
%375 = load double, double* %374
%376 = fsub double %360, %375
%377 = load double*, double** %13
%378 = load i32, i32* %17
%379 = load i32, i32* %19
%380 = load i32, i32* %18
%381 = load i32, i32* %10
%382 = mul nsw i32 %380, %381
%383 = add nsw i32 %379, %382
%384 = load i32, i32* %8
%385 = mul nsw i32 %383, %384
%386 = add nsw i32 %378, %385
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %377, i64 %387
store double %376, double* %388
%389 = load double*, double** %12
%390 = load i32, i32* %17
%391 = load i32, i32* %18
%392 = mul nsw i32 2, %391
%393 = load i32, i32* %19
%394 = load i32, i32* %9
%395 = mul nsw i32 %393, %394
%396 = add nsw i32 %392, %395
%397 = load i32, i32* %8
%398 = mul nsw i32 %396, %397
%399 = add nsw i32 %390, %398
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %389, i64 %400
%402 = load double, double* %401
%403 = load double*, double** %12
%404 = load i32, i32* %22
%405 = load i32, i32* %18
%406 = mul nsw i32 2, %405
%407 = sub nsw i32 %406, 1
%408 = load i32, i32* %19
%409 = load i32, i32* %9
%410 = mul nsw i32 %408, %409
%411 = add nsw i32 %407, %410
%412 = load i32, i32* %8
%413 = mul nsw i32 %411, %412
%414 = add nsw i32 %404, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %403, i64 %415
%417 = load double, double* %416
%418 = fadd double %402, %417
%419 = load double*, double** %13
%420 = load i32, i32* %17
%421 = load i32, i32* %19
%422 = load i32, i32* %23
%423 = load i32, i32* %10
%424 = mul nsw i32 %422, %423
%425 = add nsw i32 %421, %424
%426 = load i32, i32* %8
%427 = mul nsw i32 %425, %426
%428 = add nsw i32 %420, %427
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds double, double* %419, i64 %429
store double %418, double* %430
br label %431
431: ; preds = %253
%432 = load i32, i32* %17
%433 = add nsw i32 %432, 2
store i32 %433, i32* %17
br label %249
434: ; preds = %249
br label %435
435: ; preds = %434
%436 = load i32, i32* %19
%437 = add nsw i32 %436, 1
store i32 %437, i32* %19
br label %244
438: ; preds = %244
br label %439
439: ; preds = %438
%440 = load i32, i32* %18
%441 = add nsw i32 %440, 1
store i32 %441, i32* %18
br label %236
442: ; preds = %236
br label %651
443: ; preds = %231
store i32 1, i32* %18
br label %444
444: ; preds = %647, %443
%445 = load i32, i32* %18
%446 = load i32, i32* %16
%447 = icmp slt i32 %445, %446
br i1 %447, label %448, label %650
448: ; preds = %444
%449 = load i32, i32* %9
%450 = load i32, i32* %18
%451 = sub nsw i32 %449, %450
store i32 %451, i32* %23
store i32 2, i32* %17
br label %452
452: ; preds = %643, %448
%453 = load i32, i32* %17
%454 = load i32, i32* %8
%455 = icmp slt i32 %453, %454
br i1 %455, label %456, label %646
456: ; preds = %452
%457 = load i32, i32* %8
%458 = load i32, i32* %17
%459 = sub nsw i32 %457, %458
store i32 %459, i32* %22
store i32 0, i32* %19
br label %460
460: ; preds = %639, %456
%461 = load i32, i32* %19
%462 = load i32, i32* %10
%463 = icmp slt i32 %461, %462
br i1 %463, label %464, label %642
464: ; preds = %460
%465 = load double*, double** %12
%466 = load i32, i32* %17
%467 = sub nsw i32 %466, 1
%468 = load i32, i32* %18
%469 = mul nsw i32 2, %468
%470 = load i32, i32* %19
%471 = load i32, i32* %9
%472 = mul nsw i32 %470, %471
%473 = add nsw i32 %469, %472
%474 = load i32, i32* %8
%475 = mul nsw i32 %473, %474
%476 = add nsw i32 %467, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %465, i64 %477
%479 = load double, double* %478
%480 = load double*, double** %12
%481 = load i32, i32* %22
%482 = sub nsw i32 %481, 1
%483 = load i32, i32* %18
%484 = mul nsw i32 2, %483
%485 = sub nsw i32 %484, 1
%486 = load i32, i32* %19
%487 = load i32, i32* %9
%488 = mul nsw i32 %486, %487
%489 = add nsw i32 %485, %488
%490 = load i32, i32* %8
%491 = mul nsw i32 %489, %490
%492 = add nsw i32 %482, %491
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double, double* %480, i64 %493
%495 = load double, double* %494
%496 = fadd double %479, %495
%497 = load double*, double** %13
%498 = load i32, i32* %17
%499 = sub nsw i32 %498, 1
%500 = load i32, i32* %19
%501 = load i32, i32* %18
%502 = load i32, i32* %10
%503 = mul nsw i32 %501, %502
%504 = add nsw i32 %500, %503
%505 = load i32, i32* %8
%506 = mul nsw i32 %504, %505
%507 = add nsw i32 %499, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %497, i64 %508
store double %496, double* %509
%510 = load double*, double** %12
%511 = load i32, i32* %17
%512 = sub nsw i32 %511, 1
%513 = load i32, i32* %18
%514 = mul nsw i32 2, %513
%515 = load i32, i32* %19
%516 = load i32, i32* %9
%517 = mul nsw i32 %515, %516
%518 = add nsw i32 %514, %517
%519 = load i32, i32* %8
%520 = mul nsw i32 %518, %519
%521 = add nsw i32 %512, %520
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %510, i64 %522
%524 = load double, double* %523
%525 = load double*, double** %12
%526 = load i32, i32* %22
%527 = sub nsw i32 %526, 1
%528 = load i32, i32* %18
%529 = mul nsw i32 2, %528
%530 = sub nsw i32 %529, 1
%531 = load i32, i32* %19
%532 = load i32, i32* %9
%533 = mul nsw i32 %531, %532
%534 = add nsw i32 %530, %533
%535 = load i32, i32* %8
%536 = mul nsw i32 %534, %535
%537 = add nsw i32 %527, %536
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %525, i64 %538
%540 = load double, double* %539
%541 = fsub double %524, %540
%542 = load double*, double** %13
%543 = load i32, i32* %17
%544 = sub nsw i32 %543, 1
%545 = load i32, i32* %19
%546 = load i32, i32* %23
%547 = load i32, i32* %10
%548 = mul nsw i32 %546, %547
%549 = add nsw i32 %545, %548
%550 = load i32, i32* %8
%551 = mul nsw i32 %549, %550
%552 = add nsw i32 %544, %551
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %542, i64 %553
store double %541, double* %554
%555 = load double*, double** %12
%556 = load i32, i32* %17
%557 = load i32, i32* %18
%558 = mul nsw i32 2, %557
%559 = load i32, i32* %19
%560 = load i32, i32* %9
%561 = mul nsw i32 %559, %560
%562 = add nsw i32 %558, %561
%563 = load i32, i32* %8
%564 = mul nsw i32 %562, %563
%565 = add nsw i32 %556, %564
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %555, i64 %566
%568 = load double, double* %567
%569 = load double*, double** %12
%570 = load i32, i32* %22
%571 = load i32, i32* %18
%572 = mul nsw i32 2, %571
%573 = sub nsw i32 %572, 1
%574 = load i32, i32* %19
%575 = load i32, i32* %9
%576 = mul nsw i32 %574, %575
%577 = add nsw i32 %573, %576
%578 = load i32, i32* %8
%579 = mul nsw i32 %577, %578
%580 = add nsw i32 %570, %579
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %569, i64 %581
%583 = load double, double* %582
%584 = fsub double %568, %583
%585 = load double*, double** %13
%586 = load i32, i32* %17
%587 = load i32, i32* %19
%588 = load i32, i32* %18
%589 = load i32, i32* %10
%590 = mul nsw i32 %588, %589
%591 = add nsw i32 %587, %590
%592 = load i32, i32* %8
%593 = mul nsw i32 %591, %592
%594 = add nsw i32 %586, %593
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double, double* %585, i64 %595
store double %584, double* %596
%597 = load double*, double** %12
%598 = load i32, i32* %17
%599 = load i32, i32* %18
%600 = mul nsw i32 2, %599
%601 = load i32, i32* %19
%602 = load i32, i32* %9
%603 = mul nsw i32 %601, %602
%604 = add nsw i32 %600, %603
%605 = load i32, i32* %8
%606 = mul nsw i32 %604, %605
%607 = add nsw i32 %598, %606
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds double, double* %597, i64 %608
%610 = load double, double* %609
%611 = load double*, double** %12
%612 = load i32, i32* %22
%613 = load i32, i32* %18
%614 = mul nsw i32 2, %613
%615 = sub nsw i32 %614, 1
%616 = load i32, i32* %19
%617 = load i32, i32* %9
%618 = mul nsw i32 %616, %617
%619 = add nsw i32 %615, %618
%620 = load i32, i32* %8
%621 = mul nsw i32 %619, %620
%622 = add nsw i32 %612, %621
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds double, double* %611, i64 %623
%625 = load double, double* %624
%626 = fadd double %610, %625
%627 = load double*, double** %13
%628 = load i32, i32* %17
%629 = load i32, i32* %19
%630 = load i32, i32* %23
%631 = load i32, i32* %10
%632 = mul nsw i32 %630, %631
%633 = add nsw i32 %629, %632
%634 = load i32, i32* %8
%635 = mul nsw i32 %633, %634
%636 = add nsw i32 %628, %635
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %627, i64 %637
store double %626, double* %638
br label %639
639: ; preds = %464
%640 = load i32, i32* %19
%641 = add nsw i32 %640, 1
store i32 %641, i32* %19
br label %460
642: ; preds = %460
br label %643
643: ; preds = %642
%644 = load i32, i32* %17
%645 = add nsw i32 %644, 2
store i32 %645, i32* %17
br label %452
646: ; preds = %452
br label %647
647: ; preds = %646
%648 = load i32, i32* %18
%649 = add nsw i32 %648, 1
store i32 %649, i32* %18
br label %444
650: ; preds = %444
br label %651
651: ; preds = %650, %442
br label %652
652: ; preds = %651, %228
store double 1.000000e+00, double* %30
store double 0.000000e+00, double* %28
store i32 1, i32* %20
br label %653
653: ; preds = %805, %652
%654 = load i32, i32* %20
%655 = load i32, i32* %16
%656 = icmp slt i32 %654, %655
br i1 %656, label %657, label %808
657: ; preds = %653
%658 = load i32, i32* %9
%659 = load i32, i32* %20
%660 = sub nsw i32 %658, %659
store i32 %660, i32* %24
%661 = load double, double* %34
%662 = load double, double* %30
%663 = load double, double* %36
%664 = load double, double* %28
%665 = fmul double %663, %664
%666 = fneg double %665
%667 = call double @llvm.fmuladd.f64(double %661, double %662, double %666)
store double %667, double* %37
%668 = load double, double* %34
%669 = load double, double* %28
%670 = load double, double* %36
%671 = load double, double* %30
%672 = fmul double %670, %671
%673 = call double @llvm.fmuladd.f64(double %668, double %669, double %672)
store double %673, double* %28
%674 = load double, double* %37
store double %674, double* %30
store i32 0, i32* %25
br label %675
675: ; preds = %722, %657
%676 = load i32, i32* %25
%677 = load i32, i32* %11
%678 = icmp slt i32 %676, %677
br i1 %678, label %679, label %725
679: ; preds = %675
%680 = load double*, double** %13
%681 = load i32, i32* %25
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %680, i64 %682
%684 = load double, double* %683
%685 = load double, double* %30
%686 = load double*, double** %13
%687 = load i32, i32* %25
%688 = load i32, i32* %11
%689 = add nsw i32 %687, %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double, double* %686, i64 %690
%692 = load double, double* %691
%693 = call double @llvm.fmuladd.f64(double %685, double %692, double %684)
%694 = load double*, double** %12
%695 = load i32, i32* %25
%696 = load i32, i32* %20
%697 = load i32, i32* %11
%698 = mul nsw i32 %696, %697
%699 = add nsw i32 %695, %698
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %694, i64 %700
store double %693, double* %701
%702 = load double, double* %28
%703 = load double*, double** %13
%704 = load i32, i32* %25
%705 = load i32, i32* %9
%706 = sub nsw i32 %705, 1
%707 = load i32, i32* %11
%708 = mul nsw i32 %706, %707
%709 = add nsw i32 %704, %708
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %703, i64 %710
%712 = load double, double* %711
%713 = fmul double %702, %712
%714 = load double*, double** %12
%715 = load i32, i32* %25
%716 = load i32, i32* %24
%717 = load i32, i32* %11
%718 = mul nsw i32 %716, %717
%719 = add nsw i32 %715, %718
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds double, double* %714, i64 %720
store double %713, double* %721
br label %722
722: ; preds = %679
%723 = load i32, i32* %25
%724 = add nsw i32 %723, 1
store i32 %724, i32* %25
br label %675
725: ; preds = %675
%726 = load double, double* %30
store double %726, double* %27
%727 = load double, double* %28
store double %727, double* %32
%728 = load double, double* %30
store double %728, double* %31
%729 = load double, double* %28
store double %729, double* %29
store i32 2, i32* %18
br label %730
730: ; preds = %801, %725
%731 = load i32, i32* %18
%732 = load i32, i32* %16
%733 = icmp slt i32 %731, %732
br i1 %733, label %734, label %804
734: ; preds = %730
%735 = load i32, i32* %9
%736 = load i32, i32* %18
%737 = sub nsw i32 %735, %736
store i32 %737, i32* %23
%738 = load double, double* %27
%739 = load double, double* %31
%740 = load double, double* %32
%741 = load double, double* %29
%742 = fmul double %740, %741
%743 = fneg double %742
%744 = call double @llvm.fmuladd.f64(double %738, double %739, double %743)
store double %744, double* %38
%745 = load double, double* %27
%746 = load double, double* %29
%747 = load double, double* %32
%748 = load double, double* %31
%749 = fmul double %747, %748
%750 = call double @llvm.fmuladd.f64(double %745, double %746, double %749)
store double %750, double* %29
%751 = load double, double* %38
store double %751, double* %31
store i32 0, i32* %25
br label %752
752: ; preds = %797, %734
%753 = load i32, i32* %25
%754 = load i32, i32* %11
%755 = icmp slt i32 %753, %754
br i1 %755, label %756, label %800
756: ; preds = %752
%757 = load double, double* %31
%758 = load double*, double** %13
%759 = load i32, i32* %25
%760 = load i32, i32* %18
%761 = load i32, i32* %11
%762 = mul nsw i32 %760, %761
%763 = add nsw i32 %759, %762
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds double, double* %758, i64 %764
%766 = load double, double* %765
%767 = load double*, double** %12
%768 = load i32, i32* %25
%769 = load i32, i32* %20
%770 = load i32, i32* %11
%771 = mul nsw i32 %769, %770
%772 = add nsw i32 %768, %771
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds double, double* %767, i64 %773
%775 = load double, double* %774
%776 = call double @llvm.fmuladd.f64(double %757, double %766, double %775)
store double %776, double* %774
%777 = load double, double* %29
%778 = load double*, double** %13
%779 = load i32, i32* %25
%780 = load i32, i32* %23
%781 = load i32, i32* %11
%782 = mul nsw i32 %780, %781
%783 = add nsw i32 %779, %782
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds double, double* %778, i64 %784
%786 = load double, double* %785
%787 = load double*, double** %12
%788 = load i32, i32* %25
%789 = load i32, i32* %24
%790 = load i32, i32* %11
%791 = mul nsw i32 %789, %790
%792 = add nsw i32 %788, %791
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds double, double* %787, i64 %793
%795 = load double, double* %794
%796 = call double @llvm.fmuladd.f64(double %777, double %786, double %795)
store double %796, double* %794
br label %797
797: ; preds = %756
%798 = load i32, i32* %25
%799 = add nsw i32 %798, 1
store i32 %799, i32* %25
br label %752
800: ; preds = %752
br label %801
801: ; preds = %800
%802 = load i32, i32* %18
%803 = add nsw i32 %802, 1
store i32 %803, i32* %18
br label %730
804: ; preds = %730
br label %805
805: ; preds = %804
%806 = load i32, i32* %20
%807 = add nsw i32 %806, 1
store i32 %807, i32* %20
br label %653
808: ; preds = %653
store i32 1, i32* %18
br label %809
809: ; preds = %838, %808
%810 = load i32, i32* %18
%811 = load i32, i32* %16
%812 = icmp slt i32 %810, %811
br i1 %812, label %813, label %841
813: ; preds = %809
store i32 0, i32* %25
br label %814
814: ; preds = %834, %813
%815 = load i32, i32* %25
%816 = load i32, i32* %11
%817 = icmp slt i32 %815, %816
br i1 %817, label %818, label %837
818: ; preds = %814
%819 = load double*, double** %13
%820 = load i32, i32* %25
%821 = load i32, i32* %18
%822 = load i32, i32* %11
%823 = mul nsw i32 %821, %822
%824 = add nsw i32 %820, %823
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds double, double* %819, i64 %825
%827 = load double, double* %826
%828 = load double*, double** %13
%829 = load i32, i32* %25
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds double, double* %828, i64 %830
%832 = load double, double* %831
%833 = fadd double %832, %827
store double %833, double* %831
br label %834
834: ; preds = %818
%835 = load i32, i32* %25
%836 = add nsw i32 %835, 1
store i32 %836, i32* %25
br label %814
837: ; preds = %814
br label %838
838: ; preds = %837
%839 = load i32, i32* %18
%840 = add nsw i32 %839, 1
store i32 %840, i32* %18
br label %809
841: ; preds = %809
store i32 1, i32* %18
br label %842
842: ; preds = %925, %841
%843 = load i32, i32* %18
%844 = load i32, i32* %16
%845 = icmp slt i32 %843, %844
br i1 %845, label %846, label %928
846: ; preds = %842
%847 = load i32, i32* %9
%848 = load i32, i32* %18
%849 = sub nsw i32 %847, %848
store i32 %849, i32* %23
store i32 0, i32* %19
br label %850
850: ; preds = %921, %846
%851 = load i32, i32* %19
%852 = load i32, i32* %10
%853 = icmp slt i32 %851, %852
br i1 %853, label %854, label %924
854: ; preds = %850
%855 = load double*, double** %12
%856 = load i32, i32* %19
%857 = load i32, i32* %18
%858 = load i32, i32* %10
%859 = mul nsw i32 %857, %858
%860 = add nsw i32 %856, %859
%861 = load i32, i32* %8
%862 = mul nsw i32 %860, %861
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds double, double* %855, i64 %863
%865 = load double, double* %864
%866 = load double*, double** %12
%867 = load i32, i32* %19
%868 = load i32, i32* %23
%869 = load i32, i32* %10
%870 = mul nsw i32 %868, %869
%871 = add nsw i32 %867, %870
%872 = load i32, i32* %8
%873 = mul nsw i32 %871, %872
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %866, i64 %874
%876 = load double, double* %875
%877 = fsub double %865, %876
%878 = load double*, double** %13
%879 = load i32, i32* %19
%880 = load i32, i32* %18
%881 = load i32, i32* %10
%882 = mul nsw i32 %880, %881
%883 = add nsw i32 %879, %882
%884 = load i32, i32* %8
%885 = mul nsw i32 %883, %884
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %878, i64 %886
store double %877, double* %887
%888 = load double*, double** %12
%889 = load i32, i32* %19
%890 = load i32, i32* %18
%891 = load i32, i32* %10
%892 = mul nsw i32 %890, %891
%893 = add nsw i32 %889, %892
%894 = load i32, i32* %8
%895 = mul nsw i32 %893, %894
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds double, double* %888, i64 %896
%898 = load double, double* %897
%899 = load double*, double** %12
%900 = load i32, i32* %19
%901 = load i32, i32* %23
%902 = load i32, i32* %10
%903 = mul nsw i32 %901, %902
%904 = add nsw i32 %900, %903
%905 = load i32, i32* %8
%906 = mul nsw i32 %904, %905
%907 = sext i32 %906 to i64
%908 = getelementptr inbounds double, double* %899, i64 %907
%909 = load double, double* %908
%910 = fadd double %898, %909
%911 = load double*, double** %13
%912 = load i32, i32* %19
%913 = load i32, i32* %23
%914 = load i32, i32* %10
%915 = mul nsw i32 %913, %914
%916 = add nsw i32 %912, %915
%917 = load i32, i32* %8
%918 = mul nsw i32 %916, %917
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds double, double* %911, i64 %919
store double %910, double* %920
br label %921
921: ; preds = %854
%922 = load i32, i32* %19
%923 = add nsw i32 %922, 1
store i32 %923, i32* %19
br label %850
924: ; preds = %850
br label %925
925: ; preds = %924
%926 = load i32, i32* %18
%927 = add nsw i32 %926, 1
store i32 %927, i32* %18
br label %842
928: ; preds = %842
%929 = load i32, i32* %8
%930 = icmp eq i32 %929, 1
br i1 %930, label %931, label %932
931: ; preds = %928
br label %1669
932: ; preds = %928
%933 = load i32, i32* %33
%934 = load i32, i32* %10
%935 = icmp sge i32 %933, %934
br i1 %935, label %936, label %1129
936: ; preds = %932
store i32 1, i32* %18
br label %937
937: ; preds = %1125, %936
%938 = load i32, i32* %18
%939 = load i32, i32* %16
%940 = icmp slt i32 %938, %939
br i1 %940, label %941, label %1128
941: ; preds = %937
%942 = load i32, i32* %9
%943 = load i32, i32* %18
%944 = sub nsw i32 %942, %943
store i32 %944, i32* %23
store i32 0, i32* %19
br label %945
945: ; preds = %1121, %941
%946 = load i32, i32* %19
%947 = load i32, i32* %10
%948 = icmp slt i32 %946, %947
br i1 %948, label %949, label %1124
949: ; preds = %945
store i32 2, i32* %17
br label %950
950: ; preds = %1117, %949
%951 = load i32, i32* %17
%952 = load i32, i32* %8
%953 = icmp slt i32 %951, %952
br i1 %953, label %954, label %1120
954: ; preds = %950
%955 = load double*, double** %12
%956 = load i32, i32* %17
%957 = sub nsw i32 %956, 1
%958 = load i32, i32* %19
%959 = load i32, i32* %18
%960 = load i32, i32* %10
%961 = mul nsw i32 %959, %960
%962 = add nsw i32 %958, %961
%963 = load i32, i32* %8
%964 = mul nsw i32 %962, %963
%965 = add nsw i32 %957, %964
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds double, double* %955, i64 %966
%968 = load double, double* %967
%969 = load double*, double** %12
%970 = load i32, i32* %17
%971 = load i32, i32* %19
%972 = load i32, i32* %23
%973 = load i32, i32* %10
%974 = mul nsw i32 %972, %973
%975 = add nsw i32 %971, %974
%976 = load i32, i32* %8
%977 = mul nsw i32 %975, %976
%978 = add nsw i32 %970, %977
%979 = sext i32 %978 to i64
%980 = getelementptr inbounds double, double* %969, i64 %979
%981 = load double, double* %980
%982 = fsub double %968, %981
%983 = load double*, double** %13
%984 = load i32, i32* %17
%985 = sub nsw i32 %984, 1
%986 = load i32, i32* %19
%987 = load i32, i32* %18
%988 = load i32, i32* %10
%989 = mul nsw i32 %987, %988
%990 = add nsw i32 %986, %989
%991 = load i32, i32* %8
%992 = mul nsw i32 %990, %991
%993 = add nsw i32 %985, %992
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %983, i64 %994
store double %982, double* %995
%996 = load double*, double** %12
%997 = load i32, i32* %17
%998 = sub nsw i32 %997, 1
%999 = load i32, i32* %19
%1000 = load i32, i32* %18
%1001 = load i32, i32* %10
%1002 = mul nsw i32 %1000, %1001
%1003 = add nsw i32 %999, %1002
%1004 = load i32, i32* %8
%1005 = mul nsw i32 %1003, %1004
%1006 = add nsw i32 %998, %1005
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds double, double* %996, i64 %1007
%1009 = load double, double* %1008
%1010 = load double*, double** %12
%1011 = load i32, i32* %17
%1012 = load i32, i32* %19
%1013 = load i32, i32* %23
%1014 = load i32, i32* %10
%1015 = mul nsw i32 %1013, %1014
%1016 = add nsw i32 %1012, %1015
%1017 = load i32, i32* %8
%1018 = mul nsw i32 %1016, %1017
%1019 = add nsw i32 %1011, %1018
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds double, double* %1010, i64 %1020
%1022 = load double, double* %1021
%1023 = fadd double %1009, %1022
%1024 = load double*, double** %13
%1025 = load i32, i32* %17
%1026 = sub nsw i32 %1025, 1
%1027 = load i32, i32* %19
%1028 = load i32, i32* %23
%1029 = load i32, i32* %10
%1030 = mul nsw i32 %1028, %1029
%1031 = add nsw i32 %1027, %1030
%1032 = load i32, i32* %8
%1033 = mul nsw i32 %1031, %1032
%1034 = add nsw i32 %1026, %1033
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds double, double* %1024, i64 %1035
store double %1023, double* %1036
%1037 = load double*, double** %12
%1038 = load i32, i32* %17
%1039 = load i32, i32* %19
%1040 = load i32, i32* %18
%1041 = load i32, i32* %10
%1042 = mul nsw i32 %1040, %1041
%1043 = add nsw i32 %1039, %1042
%1044 = load i32, i32* %8
%1045 = mul nsw i32 %1043, %1044
%1046 = add nsw i32 %1038, %1045
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds double, double* %1037, i64 %1047
%1049 = load double, double* %1048
%1050 = load double*, double** %12
%1051 = load i32, i32* %17
%1052 = sub nsw i32 %1051, 1
%1053 = load i32, i32* %19
%1054 = load i32, i32* %23
%1055 = load i32, i32* %10
%1056 = mul nsw i32 %1054, %1055
%1057 = add nsw i32 %1053, %1056
%1058 = load i32, i32* %8
%1059 = mul nsw i32 %1057, %1058
%1060 = add nsw i32 %1052, %1059
%1061 = sext i32 %1060 to i64
%1062 = getelementptr inbounds double, double* %1050, i64 %1061
%1063 = load double, double* %1062
%1064 = fadd double %1049, %1063
%1065 = load double*, double** %13
%1066 = load i32, i32* %17
%1067 = load i32, i32* %19
%1068 = load i32, i32* %18
%1069 = load i32, i32* %10
%1070 = mul nsw i32 %1068, %1069
%1071 = add nsw i32 %1067, %1070
%1072 = load i32, i32* %8
%1073 = mul nsw i32 %1071, %1072
%1074 = add nsw i32 %1066, %1073
%1075 = sext i32 %1074 to i64
%1076 = getelementptr inbounds double, double* %1065, i64 %1075
store double %1064, double* %1076
%1077 = load double*, double** %12
%1078 = load i32, i32* %17
%1079 = load i32, i32* %19
%1080 = load i32, i32* %18
%1081 = load i32, i32* %10
%1082 = mul nsw i32 %1080, %1081
%1083 = add nsw i32 %1079, %1082
%1084 = load i32, i32* %8
%1085 = mul nsw i32 %1083, %1084
%1086 = add nsw i32 %1078, %1085
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds double, double* %1077, i64 %1087
%1089 = load double, double* %1088
%1090 = load double*, double** %12
%1091 = load i32, i32* %17
%1092 = sub nsw i32 %1091, 1
%1093 = load i32, i32* %19
%1094 = load i32, i32* %23
%1095 = load i32, i32* %10
%1096 = mul nsw i32 %1094, %1095
%1097 = add nsw i32 %1093, %1096
%1098 = load i32, i32* %8
%1099 = mul nsw i32 %1097, %1098
%1100 = add nsw i32 %1092, %1099
%1101 = sext i32 %1100 to i64
%1102 = getelementptr inbounds double, double* %1090, i64 %1101
%1103 = load double, double* %1102
%1104 = fsub double %1089, %1103
%1105 = load double*, double** %13
%1106 = load i32, i32* %17
%1107 = load i32, i32* %19
%1108 = load i32, i32* %23
%1109 = load i32, i32* %10
%1110 = mul nsw i32 %1108, %1109
%1111 = add nsw i32 %1107, %1110
%1112 = load i32, i32* %8
%1113 = mul nsw i32 %1111, %1112
%1114 = add nsw i32 %1106, %1113
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds double, double* %1105, i64 %1115
store double %1104, double* %1116
br label %1117
1117: ; preds = %954
%1118 = load i32, i32* %17
%1119 = add nsw i32 %1118, 2
store i32 %1119, i32* %17
br label %950
1120: ; preds = %950
br label %1121
1121: ; preds = %1120
%1122 = load i32, i32* %19
%1123 = add nsw i32 %1122, 1
store i32 %1123, i32* %19
br label %945
1124: ; preds = %945
br label %1125
1125: ; preds = %1124
%1126 = load i32, i32* %18
%1127 = add nsw i32 %1126, 1
store i32 %1127, i32* %18
br label %937
1128: ; preds = %937
br label %1322
1129: ; preds = %932
store i32 1, i32* %18
br label %1130
1130: ; preds = %1318, %1129
%1131 = load i32, i32* %18
%1132 = load i32, i32* %16
%1133 = icmp slt i32 %1131, %1132
br i1 %1133, label %1134, label %1321
1134: ; preds = %1130
%1135 = load i32, i32* %9
%1136 = load i32, i32* %18
%1137 = sub nsw i32 %1135, %1136
store i32 %1137, i32* %23
store i32 2, i32* %17
br label %1138
1138: ; preds = %1314, %1134
%1139 = load i32, i32* %17
%1140 = load i32, i32* %8
%1141 = icmp slt i32 %1139, %1140
br i1 %1141, label %1142, label %1317
1142: ; preds = %1138
store i32 0, i32* %19
br label %1143
1143: ; preds = %1310, %1142
%1144 = load i32, i32* %19
%1145 = load i32, i32* %10
%1146 = icmp slt i32 %1144, %1145
br i1 %1146, label %1147, label %1313
1147: ; preds = %1143
%1148 = load double*, double** %12
%1149 = load i32, i32* %17
%1150 = sub nsw i32 %1149, 1
%1151 = load i32, i32* %19
%1152 = load i32, i32* %18
%1153 = load i32, i32* %10
%1154 = mul nsw i32 %1152, %1153
%1155 = add nsw i32 %1151, %1154
%1156 = load i32, i32* %8
%1157 = mul nsw i32 %1155, %1156
%1158 = add nsw i32 %1150, %1157
%1159 = sext i32 %1158 to i64
%1160 = getelementptr inbounds double, double* %1148, i64 %1159
%1161 = load double, double* %1160
%1162 = load double*, double** %12
%1163 = load i32, i32* %17
%1164 = load i32, i32* %19
%1165 = load i32, i32* %23
%1166 = load i32, i32* %10
%1167 = mul nsw i32 %1165, %1166
%1168 = add nsw i32 %1164, %1167
%1169 = load i32, i32* %8
%1170 = mul nsw i32 %1168, %1169
%1171 = add nsw i32 %1163, %1170
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds double, double* %1162, i64 %1172
%1174 = load double, double* %1173
%1175 = fsub double %1161, %1174
%1176 = load double*, double** %13
%1177 = load i32, i32* %17
%1178 = sub nsw i32 %1177, 1
%1179 = load i32, i32* %19
%1180 = load i32, i32* %18
%1181 = load i32, i32* %10
%1182 = mul nsw i32 %1180, %1181
%1183 = add nsw i32 %1179, %1182
%1184 = load i32, i32* %8
%1185 = mul nsw i32 %1183, %1184
%1186 = add nsw i32 %1178, %1185
%1187 = sext i32 %1186 to i64
%1188 = getelementptr inbounds double, double* %1176, i64 %1187
store double %1175, double* %1188
%1189 = load double*, double** %12
%1190 = load i32, i32* %17
%1191 = sub nsw i32 %1190, 1
%1192 = load i32, i32* %19
%1193 = load i32, i32* %18
%1194 = load i32, i32* %10
%1195 = mul nsw i32 %1193, %1194
%1196 = add nsw i32 %1192, %1195
%1197 = load i32, i32* %8
%1198 = mul nsw i32 %1196, %1197
%1199 = add nsw i32 %1191, %1198
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds double, double* %1189, i64 %1200
%1202 = load double, double* %1201
%1203 = load double*, double** %12
%1204 = load i32, i32* %17
%1205 = load i32, i32* %19
%1206 = load i32, i32* %23
%1207 = load i32, i32* %10
%1208 = mul nsw i32 %1206, %1207
%1209 = add nsw i32 %1205, %1208
%1210 = load i32, i32* %8
%1211 = mul nsw i32 %1209, %1210
%1212 = add nsw i32 %1204, %1211
%1213 = sext i32 %1212 to i64
%1214 = getelementptr inbounds double, double* %1203, i64 %1213
%1215 = load double, double* %1214
%1216 = fadd double %1202, %1215
%1217 = load double*, double** %13
%1218 = load i32, i32* %17
%1219 = sub nsw i32 %1218, 1
%1220 = load i32, i32* %19
%1221 = load i32, i32* %23
%1222 = load i32, i32* %10
%1223 = mul nsw i32 %1221, %1222
%1224 = add nsw i32 %1220, %1223
%1225 = load i32, i32* %8
%1226 = mul nsw i32 %1224, %1225
%1227 = add nsw i32 %1219, %1226
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds double, double* %1217, i64 %1228
store double %1216, double* %1229
%1230 = load double*, double** %12
%1231 = load i32, i32* %17
%1232 = load i32, i32* %19
%1233 = load i32, i32* %18
%1234 = load i32, i32* %10
%1235 = mul nsw i32 %1233, %1234
%1236 = add nsw i32 %1232, %1235
%1237 = load i32, i32* %8
%1238 = mul nsw i32 %1236, %1237
%1239 = add nsw i32 %1231, %1238
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds double, double* %1230, i64 %1240
%1242 = load double, double* %1241
%1243 = load double*, double** %12
%1244 = load i32, i32* %17
%1245 = sub nsw i32 %1244, 1
%1246 = load i32, i32* %19
%1247 = load i32, i32* %23
%1248 = load i32, i32* %10
%1249 = mul nsw i32 %1247, %1248
%1250 = add nsw i32 %1246, %1249
%1251 = load i32, i32* %8
%1252 = mul nsw i32 %1250, %1251
%1253 = add nsw i32 %1245, %1252
%1254 = sext i32 %1253 to i64
%1255 = getelementptr inbounds double, double* %1243, i64 %1254
%1256 = load double, double* %1255
%1257 = fadd double %1242, %1256
%1258 = load double*, double** %13
%1259 = load i32, i32* %17
%1260 = load i32, i32* %19
%1261 = load i32, i32* %18
%1262 = load i32, i32* %10
%1263 = mul nsw i32 %1261, %1262
%1264 = add nsw i32 %1260, %1263
%1265 = load i32, i32* %8
%1266 = mul nsw i32 %1264, %1265
%1267 = add nsw i32 %1259, %1266
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds double, double* %1258, i64 %1268
store double %1257, double* %1269
%1270 = load double*, double** %12
%1271 = load i32, i32* %17
%1272 = load i32, i32* %19
%1273 = load i32, i32* %18
%1274 = load i32, i32* %10
%1275 = mul nsw i32 %1273, %1274
%1276 = add nsw i32 %1272, %1275
%1277 = load i32, i32* %8
%1278 = mul nsw i32 %1276, %1277
%1279 = add nsw i32 %1271, %1278
%1280 = sext i32 %1279 to i64
%1281 = getelementptr inbounds double, double* %1270, i64 %1280
%1282 = load double, double* %1281
%1283 = load double*, double** %12
%1284 = load i32, i32* %17
%1285 = sub nsw i32 %1284, 1
%1286 = load i32, i32* %19
%1287 = load i32, i32* %23
%1288 = load i32, i32* %10
%1289 = mul nsw i32 %1287, %1288
%1290 = add nsw i32 %1286, %1289
%1291 = load i32, i32* %8
%1292 = mul nsw i32 %1290, %1291
%1293 = add nsw i32 %1285, %1292
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds double, double* %1283, i64 %1294
%1296 = load double, double* %1295
%1297 = fsub double %1282, %1296
%1298 = load double*, double** %13
%1299 = load i32, i32* %17
%1300 = load i32, i32* %19
%1301 = load i32, i32* %23
%1302 = load i32, i32* %10
%1303 = mul nsw i32 %1301, %1302
%1304 = add nsw i32 %1300, %1303
%1305 = load i32, i32* %8
%1306 = mul nsw i32 %1304, %1305
%1307 = add nsw i32 %1299, %1306
%1308 = sext i32 %1307 to i64
%1309 = getelementptr inbounds double, double* %1298, i64 %1308
store double %1297, double* %1309
br label %1310
1310: ; preds = %1147
%1311 = load i32, i32* %19
%1312 = add nsw i32 %1311, 1
store i32 %1312, i32* %19
br label %1143
1313: ; preds = %1143
br label %1314
1314: ; preds = %1313
%1315 = load i32, i32* %17
%1316 = add nsw i32 %1315, 2
store i32 %1316, i32* %17
br label %1138
1317: ; preds = %1138
br label %1318
1318: ; preds = %1317
%1319 = load i32, i32* %18
%1320 = add nsw i32 %1319, 1
store i32 %1320, i32* %18
br label %1130
1321: ; preds = %1130
br label %1322
1322: ; preds = %1321, %1128
store i32 0, i32* %25
br label %1323
1323: ; preds = %1337, %1322
%1324 = load i32, i32* %25
%1325 = load i32, i32* %11
%1326 = icmp slt i32 %1324, %1325
br i1 %1326, label %1327, label %1340
1327: ; preds = %1323
%1328 = load double*, double** %13
%1329 = load i32, i32* %25
%1330 = sext i32 %1329 to i64
%1331 = getelementptr inbounds double, double* %1328, i64 %1330
%1332 = load double, double* %1331
%1333 = load double*, double** %12
%1334 = load i32, i32* %25
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds double, double* %1333, i64 %1335
store double %1332, double* %1336
br label %1337
1337: ; preds = %1327
%1338 = load i32, i32* %25
%1339 = add nsw i32 %1338, 1
store i32 %1339, i32* %25
br label %1323
1340: ; preds = %1323
store i32 1, i32* %18
br label %1341
1341: ; preds = %1376, %1340
%1342 = load i32, i32* %18
%1343 = load i32, i32* %9
%1344 = icmp slt i32 %1342, %1343
br i1 %1344, label %1345, label %1379
1345: ; preds = %1341
store i32 0, i32* %19
br label %1346
1346: ; preds = %1372, %1345
%1347 = load i32, i32* %19
%1348 = load i32, i32* %10
%1349 = icmp slt i32 %1347, %1348
br i1 %1349, label %1350, label %1375
1350: ; preds = %1346
%1351 = load double*, double** %13
%1352 = load i32, i32* %19
%1353 = load i32, i32* %18
%1354 = load i32, i32* %10
%1355 = mul nsw i32 %1353, %1354
%1356 = add nsw i32 %1352, %1355
%1357 = load i32, i32* %8
%1358 = mul nsw i32 %1356, %1357
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds double, double* %1351, i64 %1359
%1361 = load double, double* %1360
%1362 = load double*, double** %12
%1363 = load i32, i32* %19
%1364 = load i32, i32* %18
%1365 = load i32, i32* %10
%1366 = mul nsw i32 %1364, %1365
%1367 = add nsw i32 %1363, %1366
%1368 = load i32, i32* %8
%1369 = mul nsw i32 %1367, %1368
%1370 = sext i32 %1369 to i64
%1371 = getelementptr inbounds double, double* %1362, i64 %1370
store double %1361, double* %1371
br label %1372
1372: ; preds = %1350
%1373 = load i32, i32* %19
%1374 = add nsw i32 %1373, 1
store i32 %1374, i32* %19
br label %1346
1375: ; preds = %1346
br label %1376
1376: ; preds = %1375
%1377 = load i32, i32* %18
%1378 = add nsw i32 %1377, 1
store i32 %1378, i32* %18
br label %1341
1379: ; preds = %1341
%1380 = load i32, i32* %33
%1381 = load i32, i32* %10
%1382 = icmp sle i32 %1380, %1381
br i1 %1382, label %1383, label %1526
1383: ; preds = %1379
%1384 = load i32, i32* %8
%1385 = sub nsw i32 0, %1384
store i32 %1385, i32* %26
store i32 1, i32* %18
br label %1386
1386: ; preds = %1522, %1383
%1387 = load i32, i32* %18
%1388 = load i32, i32* %9
%1389 = icmp slt i32 %1387, %1388
br i1 %1389, label %1390, label %1525
1390: ; preds = %1386
%1391 = load i32, i32* %8
%1392 = load i32, i32* %26
%1393 = add nsw i32 %1392, %1391
store i32 %1393, i32* %26
%1394 = load i32, i32* %26
%1395 = sub nsw i32 %1394, 1
store i32 %1395, i32* %15
store i32 2, i32* %17
br label %1396
1396: ; preds = %1518, %1390
%1397 = load i32, i32* %17
%1398 = load i32, i32* %8
%1399 = icmp slt i32 %1397, %1398
br i1 %1399, label %1400, label %1521
1400: ; preds = %1396
%1401 = load i32, i32* %15
%1402 = add nsw i32 %1401, 2
store i32 %1402, i32* %15
store i32 0, i32* %19
br label %1403
1403: ; preds = %1514, %1400
%1404 = load i32, i32* %19
%1405 = load i32, i32* %10
%1406 = icmp slt i32 %1404, %1405
br i1 %1406, label %1407, label %1517
1407: ; preds = %1403
%1408 = load double*, double** %14
%1409 = load i32, i32* %15
%1410 = sub nsw i32 %1409, 1
%1411 = sext i32 %1410 to i64
%1412 = getelementptr inbounds double, double* %1408, i64 %1411
%1413 = load double, double* %1412
%1414 = load double*, double** %13
%1415 = load i32, i32* %17
%1416 = sub nsw i32 %1415, 1
%1417 = load i32, i32* %19
%1418 = load i32, i32* %18
%1419 = load i32, i32* %10
%1420 = mul nsw i32 %1418, %1419
%1421 = add nsw i32 %1417, %1420
%1422 = load i32, i32* %8
%1423 = mul nsw i32 %1421, %1422
%1424 = add nsw i32 %1416, %1423
%1425 = sext i32 %1424 to i64
%1426 = getelementptr inbounds double, double* %1414, i64 %1425
%1427 = load double, double* %1426
%1428 = load double*, double** %14
%1429 = load i32, i32* %15
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds double, double* %1428, i64 %1430
%1432 = load double, double* %1431
%1433 = load double*, double** %13
%1434 = load i32, i32* %17
%1435 = load i32, i32* %19
%1436 = load i32, i32* %18
%1437 = load i32, i32* %10
%1438 = mul nsw i32 %1436, %1437
%1439 = add nsw i32 %1435, %1438
%1440 = load i32, i32* %8
%1441 = mul nsw i32 %1439, %1440
%1442 = add nsw i32 %1434, %1441
%1443 = sext i32 %1442 to i64
%1444 = getelementptr inbounds double, double* %1433, i64 %1443
%1445 = load double, double* %1444
%1446 = fmul double %1432, %1445
%1447 = fneg double %1446
%1448 = call double @llvm.fmuladd.f64(double %1413, double %1427, double %1447)
%1449 = load double*, double** %12
%1450 = load i32, i32* %17
%1451 = sub nsw i32 %1450, 1
%1452 = load i32, i32* %19
%1453 = load i32, i32* %18
%1454 = load i32, i32* %10
%1455 = mul nsw i32 %1453, %1454
%1456 = add nsw i32 %1452, %1455
%1457 = load i32, i32* %8
%1458 = mul nsw i32 %1456, %1457
%1459 = add nsw i32 %1451, %1458
%1460 = sext i32 %1459 to i64
%1461 = getelementptr inbounds double, double* %1449, i64 %1460
store double %1448, double* %1461
%1462 = load double*, double** %14
%1463 = load i32, i32* %15
%1464 = sub nsw i32 %1463, 1
%1465 = sext i32 %1464 to i64
%1466 = getelementptr inbounds double, double* %1462, i64 %1465
%1467 = load double, double* %1466
%1468 = load double*, double** %13
%1469 = load i32, i32* %17
%1470 = load i32, i32* %19
%1471 = load i32, i32* %18
%1472 = load i32, i32* %10
%1473 = mul nsw i32 %1471, %1472
%1474 = add nsw i32 %1470, %1473
%1475 = load i32, i32* %8
%1476 = mul nsw i32 %1474, %1475
%1477 = add nsw i32 %1469, %1476
%1478 = sext i32 %1477 to i64
%1479 = getelementptr inbounds double, double* %1468, i64 %1478
%1480 = load double, double* %1479
%1481 = load double*, double** %14
%1482 = load i32, i32* %15
%1483 = sext i32 %1482 to i64
%1484 = getelementptr inbounds double, double* %1481, i64 %1483
%1485 = load double, double* %1484
%1486 = load double*, double** %13
%1487 = load i32, i32* %17
%1488 = sub nsw i32 %1487, 1
%1489 = load i32, i32* %19
%1490 = load i32, i32* %18
%1491 = load i32, i32* %10
%1492 = mul nsw i32 %1490, %1491
%1493 = add nsw i32 %1489, %1492
%1494 = load i32, i32* %8
%1495 = mul nsw i32 %1493, %1494
%1496 = add nsw i32 %1488, %1495
%1497 = sext i32 %1496 to i64
%1498 = getelementptr inbounds double, double* %1486, i64 %1497
%1499 = load double, double* %1498
%1500 = fmul double %1485, %1499
%1501 = call double @llvm.fmuladd.f64(double %1467, double %1480, double %1500)
%1502 = load double*, double** %12
%1503 = load i32, i32* %17
%1504 = load i32, i32* %19
%1505 = load i32, i32* %18
%1506 = load i32, i32* %10
%1507 = mul nsw i32 %1505, %1506
%1508 = add nsw i32 %1504, %1507
%1509 = load i32, i32* %8
%1510 = mul nsw i32 %1508, %1509
%1511 = add nsw i32 %1503, %1510
%1512 = sext i32 %1511 to i64
%1513 = getelementptr inbounds double, double* %1502, i64 %1512
store double %1501, double* %1513
br label %1514
1514: ; preds = %1407
%1515 = load i32, i32* %19
%1516 = add nsw i32 %1515, 1
store i32 %1516, i32* %19
br label %1403
1517: ; preds = %1403
br label %1518
1518: ; preds = %1517
%1519 = load i32, i32* %17
%1520 = add nsw i32 %1519, 2
store i32 %1520, i32* %17
br label %1396
1521: ; preds = %1396
br label %1522
1522: ; preds = %1521
%1523 = load i32, i32* %18
%1524 = add nsw i32 %1523, 1
store i32 %1524, i32* %18
br label %1386
1525: ; preds = %1386
br label %1669
1526: ; preds = %1379
%1527 = load i32, i32* %8
%1528 = sub nsw i32 0, %1527
store i32 %1528, i32* %26
store i32 1, i32* %18
br label %1529
1529: ; preds = %1665, %1526
%1530 = load i32, i32* %18
%1531 = load i32, i32* %9
%1532 = icmp slt i32 %1530, %1531
br i1 %1532, label %1533, label %1668
1533: ; preds = %1529
%1534 = load i32, i32* %8
%1535 = load i32, i32* %26
%1536 = add nsw i32 %1535, %1534
store i32 %1536, i32* %26
store i32 0, i32* %19
br label %1537
1537: ; preds = %1661, %1533
%1538 = load i32, i32* %19
%1539 = load i32, i32* %10
%1540 = icmp slt i32 %1538, %1539
br i1 %1540, label %1541, label %1664
1541: ; preds = %1537
%1542 = load i32, i32* %26
%1543 = sub nsw i32 %1542, 1
store i32 %1543, i32* %15
store i32 2, i32* %17
br label %1544
1544: ; preds = %1657, %1541
%1545 = load i32, i32* %17
%1546 = load i32, i32* %8
%1547 = icmp slt i32 %1545, %1546
br i1 %1547, label %1548, label %1660
1548: ; preds = %1544
%1549 = load i32, i32* %15
%1550 = add nsw i32 %1549, 2
store i32 %1550, i32* %15
%1551 = load double*, double** %14
%1552 = load i32, i32* %15
%1553 = sub nsw i32 %1552, 1
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds double, double* %1551, i64 %1554
%1556 = load double, double* %1555
%1557 = load double*, double** %13
%1558 = load i32, i32* %17
%1559 = sub nsw i32 %1558, 1
%1560 = load i32, i32* %19
%1561 = load i32, i32* %18
%1562 = load i32, i32* %10
%1563 = mul nsw i32 %1561, %1562
%1564 = add nsw i32 %1560, %1563
%1565 = load i32, i32* %8
%1566 = mul nsw i32 %1564, %1565
%1567 = add nsw i32 %1559, %1566
%1568 = sext i32 %1567 to i64
%1569 = getelementptr inbounds double, double* %1557, i64 %1568
%1570 = load double, double* %1569
%1571 = load double*, double** %14
%1572 = load i32, i32* %15
%1573 = sext i32 %1572 to i64
%1574 = getelementptr inbounds double, double* %1571, i64 %1573
%1575 = load double, double* %1574
%1576 = load double*, double** %13
%1577 = load i32, i32* %17
%1578 = load i32, i32* %19
%1579 = load i32, i32* %18
%1580 = load i32, i32* %10
%1581 = mul nsw i32 %1579, %1580
%1582 = add nsw i32 %1578, %1581
%1583 = load i32, i32* %8
%1584 = mul nsw i32 %1582, %1583
%1585 = add nsw i32 %1577, %1584
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds double, double* %1576, i64 %1586
%1588 = load double, double* %1587
%1589 = fmul double %1575, %1588
%1590 = fneg double %1589
%1591 = call double @llvm.fmuladd.f64(double %1556, double %1570, double %1590)
%1592 = load double*, double** %12
%1593 = load i32, i32* %17
%1594 = sub nsw i32 %1593, 1
%1595 = load i32, i32* %19
%1596 = load i32, i32* %18
%1597 = load i32, i32* %10
%1598 = mul nsw i32 %1596, %1597
%1599 = add nsw i32 %1595, %1598
%1600 = load i32, i32* %8
%1601 = mul nsw i32 %1599, %1600
%1602 = add nsw i32 %1594, %1601
%1603 = sext i32 %1602 to i64
%1604 = getelementptr inbounds double, double* %1592, i64 %1603
store double %1591, double* %1604
%1605 = load double*, double** %14
%1606 = load i32, i32* %15
%1607 = sub nsw i32 %1606, 1
%1608 = sext i32 %1607 to i64
%1609 = getelementptr inbounds double, double* %1605, i64 %1608
%1610 = load double, double* %1609
%1611 = load double*, double** %13
%1612 = load i32, i32* %17
%1613 = load i32, i32* %19
%1614 = load i32, i32* %18
%1615 = load i32, i32* %10
%1616 = mul nsw i32 %1614, %1615
%1617 = add nsw i32 %1613, %1616
%1618 = load i32, i32* %8
%1619 = mul nsw i32 %1617, %1618
%1620 = add nsw i32 %1612, %1619
%1621 = sext i32 %1620 to i64
%1622 = getelementptr inbounds double, double* %1611, i64 %1621
%1623 = load double, double* %1622
%1624 = load double*, double** %14
%1625 = load i32, i32* %15
%1626 = sext i32 %1625 to i64
%1627 = getelementptr inbounds double, double* %1624, i64 %1626
%1628 = load double, double* %1627
%1629 = load double*, double** %13
%1630 = load i32, i32* %17
%1631 = sub nsw i32 %1630, 1
%1632 = load i32, i32* %19
%1633 = load i32, i32* %18
%1634 = load i32, i32* %10
%1635 = mul nsw i32 %1633, %1634
%1636 = add nsw i32 %1632, %1635
%1637 = load i32, i32* %8
%1638 = mul nsw i32 %1636, %1637
%1639 = add nsw i32 %1631, %1638
%1640 = sext i32 %1639 to i64
%1641 = getelementptr inbounds double, double* %1629, i64 %1640
%1642 = load double, double* %1641
%1643 = fmul double %1628, %1642
%1644 = call double @llvm.fmuladd.f64(double %1610, double %1623, double %1643)
%1645 = load double*, double** %12
%1646 = load i32, i32* %17
%1647 = load i32, i32* %19
%1648 = load i32, i32* %18
%1649 = load i32, i32* %10
%1650 = mul nsw i32 %1648, %1649
%1651 = add nsw i32 %1647, %1650
%1652 = load i32, i32* %8
%1653 = mul nsw i32 %1651, %1652
%1654 = add nsw i32 %1646, %1653
%1655 = sext i32 %1654 to i64
%1656 = getelementptr inbounds double, double* %1645, i64 %1655
store double %1644, double* %1656
br label %1657
1657: ; preds = %1548
%1658 = load i32, i32* %17
%1659 = add nsw i32 %1658, 2
store i32 %1659, i32* %17
br label %1544
1660: ; preds = %1544
br label %1661
1661: ; preds = %1660
%1662 = load i32, i32* %19
%1663 = add nsw i32 %1662, 1
store i32 %1663, i32* %19
br label %1537
1664: ; preds = %1537
br label %1665
1665: ; preds = %1664
%1666 = load i32, i32* %18
%1667 = add nsw i32 %1666, 1
store i32 %1667, i32* %18
br label %1529
1668: ; preds = %1529
br label %1669
1669: ; preds = %931, %1668, %1525
ret void
}

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