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


x86 assembly (clang, -O0):
<radfg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    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    -0x8(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
cmpl   $0x1,-0x4(%rbp)
je     1a4d <radfg+0x92d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11ed <radfg+0xcd>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11b9 <radfg+0x99>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    126c <radfg+0x14c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1259 <radfg+0x139>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1207 <radfg+0xe7>
jmp    125e <radfg+0x13e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f4 <radfg+0xd4>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1441 <radfg+0x321>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    143c <radfg+0x31c>
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    1429 <radfg+0x309>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1416 <radfg+0x2f6>
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    12c8 <radfg+0x1a8>
jmp    141b <radfg+0x2fb>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ac <radfg+0x18c>
jmp    142e <radfg+0x30e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1287 <radfg+0x167>
jmp    160a <radfg+0x4ea>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1605 <radfg+0x4e5>
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    15f2 <radfg+0x4d2>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15df <radfg+0x4bf>
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    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
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    1488 <radfg+0x368>
jmp    15e4 <radfg+0x4c4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146c <radfg+0x34c>
jmp    15f7 <radfg+0x4d7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1450 <radfg+0x330>
jmp    160a <radfg+0x4ea>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     182f <radfg+0x70f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    182a <radfg+0x70a>
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    1817 <radfg+0x6f7>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1804 <radfg+0x6e4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -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
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    164c <radfg+0x52c>
jmp    1809 <radfg+0x6e9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1639 <radfg+0x519>
jmp    181c <radfg+0x6fc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    161d <radfg+0x4fd>
jmp    1a48 <radfg+0x928>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a43 <radfg+0x923>
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    1a30 <radfg+0x910>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a1d <radfg+0x8fd>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -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
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1865 <radfg+0x745>
jmp    1a22 <radfg+0x902>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1852 <radfg+0x732>
jmp    1a35 <radfg+0x915>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1836 <radfg+0x716>
jmp    1a48 <radfg+0x928>
jmp    1a8d <radfg+0x96d>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a88 <radfg+0x968>
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    1a54 <radfg+0x934>
jmp    1a8d <radfg+0x96d>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b85 <radfg+0xa65>
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    1b72 <radfg+0xa52>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ab0 <radfg+0x990>
jmp    1b77 <radfg+0xa57>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a94 <radfg+0x974>
movsd  0x147b(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e49 <radfg+0xd29>
mov    -0x8(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1cc8 <radfg+0xba8>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c32 <radfg+0xb12>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e36 <radfg+0xd16>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e23 <radfg+0xd03>
movsd  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d85 <radfg+0xc65>
jmp    1e28 <radfg+0xd08>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1cfa <radfg+0xbda>
jmp    1e3b <radfg+0xd1b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ba1 <radfg+0xa81>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1eba <radfg+0xd9a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ea7 <radfg+0xd87>
mov    -0x18(%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    1e63 <radfg+0xd43>
jmp    1eac <radfg+0xd8c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e50 <radfg+0xd30>
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1f46 <radfg+0xe26>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1f41 <radfg+0xe21>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f2e <radfg+0xe0e>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ee0 <radfg+0xdc0>
jmp    1f33 <radfg+0xe13>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ecd <radfg+0xdad>
jmp    1fc6 <radfg+0xea6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1fc1 <radfg+0xea1>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fae <radfg+0xe8e>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f60 <radfg+0xe40>
jmp    1fb3 <radfg+0xe93>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f4d <radfg+0xe2d>
jmp    1fc6 <radfg+0xea6>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    209a <radfg+0xf7a>
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    2087 <radfg+0xf67>
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    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -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  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ff2 <radfg+0xed2>
jmp    208c <radfg+0xf6c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1fcd <radfg+0xead>
cmpl   $0x1,-0x4(%rbp)
jne    20a9 <radfg+0xf89>
jmp    2517 <radfg+0x13f7>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     22e6 <radfg+0x11c6>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    22e1 <radfg+0x11c1>
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    22ce <radfg+0x11ae>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    22bb <radfg+0x119b>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -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  (%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
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    20f4 <radfg+0xfd4>
jmp    22c0 <radfg+0x11a0>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20e1 <radfg+0xfc1>
jmp    22d3 <radfg+0x11b3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20bc <radfg+0xf9c>
jmp    2517 <radfg+0x13f7>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2512 <radfg+0x13f2>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    24ff <radfg+0x13df>
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    24ec <radfg+0x13cc>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -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  (%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
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    232e <radfg+0x120e>
jmp    24f1 <radfg+0x13d1>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2312 <radfg+0x11f2>
jmp    2504 <radfg+0x13e4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    22ed <radfg+0x11cd>
jmp    2517 <radfg+0x13f7>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radfg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x8(%rsp)
mov    %r8,%rbx
mov    %ecx,%r12d
mov    %edx,%r15d
mov    %esi,%r14d
mov    %edi,%ebp
mov    %rbp,0x30(%rsp)
cvtsi2sd %esi,%xmm1
movsd  0x2eab(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x88(%rsp)
call   1040 <cos@plt>
movapd %xmm0,0x110(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
lea    0x1(%r14),%eax
shr    $0x1f,%eax
add    %r14d,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,0x64(%rsp)
lea    -0x1(%rbp),%eax
shr    $0x1f,%eax
add    %ebp,%eax
add    $0xffffffff,%eax
sar    %eax
mov    %eax,0x9c(%rsp)
cmp    $0x1,%ebp
mov    %rbx,0x88(%rsp)
mov    %r15d,0x4(%rsp)
mov    %r14,0x58(%rsp)
mov    %r12d,0x68(%rsp)
jne    129c <radfg+0x17c>
test   %r12d,%r12d
movapd 0x110(%rsp),%xmm11
jle    1458 <radfg+0x338>
mov    0x68(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x4,%ecx
jb     1209 <radfg+0xe9>
mov    0x8(%rsp),%rbp
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    134c <radfg+0x22c>
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    134c <radfg+0x22c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1244 <radfg+0x124>
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1230 <radfg+0x110>
cmp    $0x3,%rdx
jb     1458 <radfg+0x338>
mov    0x8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1260 <radfg+0x140>
jmp    1458 <radfg+0x338>
test   %r12d,%r12d
mov    0x8(%rsp),%rdx
movapd 0x110(%rsp),%xmm11
jle    22c8 <radfg+0x11a8>
mov    %r12d,%eax
cmp    $0x4,%r12d
jb     12d7 <radfg+0x1b7>
lea    (%rbx,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1372 <radfg+0x252>
lea    (%rdx,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1372 <radfg+0x252>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rsi
and    $0x3,%rsi
je     1304 <radfg+0x1e4>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12f0 <radfg+0x1d0>
cmp    $0x3,%rdi
jb     22c8 <radfg+0x11a8>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1310 <radfg+0x1f0>
jmp    22c8 <radfg+0x11a8>
mov    %eax,%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    139e <radfg+0x27e>
xor    %edi,%edi
jmp    140d <radfg+0x2ed>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdi
jae    2219 <radfg+0x10f9>
xor    %edi,%edi
jmp    227c <radfg+0x115c>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x0(%rbp,%rdi,8),%xmm1
movups 0x10(%rbp,%rdi,8),%xmm2
movups %xmm1,(%rbx,%rdi,8)
movups %xmm2,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm1
movups 0x30(%rbp,%rdi,8),%xmm2
movups %xmm1,0x20(%rbx,%rdi,8)
movups %xmm2,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm1
movups 0x50(%rbp,%rdi,8),%xmm2
movups %xmm1,0x40(%rbx,%rdi,8)
movups %xmm2,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm1
movupd 0x70(%rbp,%rdi,8),%xmm2
movupd %xmm1,0x60(%rbx,%rdi,8)
movupd %xmm2,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13b0 <radfg+0x290>
test   %rdx,%rdx
je     144f <radfg+0x32f>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm1
movupd (%rdi,%rbp,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rbp,1)
movupd %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1430 <radfg+0x310>
cmp    %rax,%rcx
jne    120b <radfg+0xeb>
mov    0x58(%rsp),%rax
cmp    $0x3,%eax
jl     2a9e <radfg+0x197e>
mov    %r15d,%ecx
mov    0x30(%rsp),%r13
movslq %r13d,%r15
mov    %eax,%esi
movslq %ecx,%rax
mov    0x64(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%r9d
cmovge %edx,%r9d
mov    %ecx,%r8d
mov    %rsi,0xc0(%rsp)
lea    -0x1(%rsi),%rcx
imul   %r15,%rax
mov    %rcx,0xa8(%rsp)
imul   %rax,%rcx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rcx,8),%rsi
lea    0x0(,%rax,8),%r10
mov    %r10,%r11
neg    %r11
shl    $0x3,%r15
lea    (%rbx,%rcx,8),%rdx
lea    (%rdi,%rax,8),%rcx
lea    (%rbx,%rax,8),%rbp
mov    $0x1,%r14d
mov    0x68(%rsp),%r12d
jmp    14f5 <radfg+0x3d5>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r11,%rsi
add    %r11,%rdx
add    %r10,%rcx
add    %r10,%rbp
cmp    %r9,%r14
je     153a <radfg+0x41a>
cmpl   $0x0,0x4(%rsp)
jle    14e0 <radfg+0x3c0>
mov    %r8,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,1),%xmm1
addsd  (%rsi,%rax,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,1)
movsd  (%rsi,%rax,1),%xmm1
subsd  (%rcx,%rax,1),%xmm1
movsd  %xmm1,(%rdx,%rax,1)
add    %r15,%rax
add    $0xffffffffffffffff,%rdi
jne    1510 <radfg+0x3f0>
jmp    14e0 <radfg+0x3c0>
mov    0x58(%rsp),%rax
cmp    $0x3,%eax
jl     1d67 <radfg+0xc47>
movapd 0x2abf(%rip),%xmm9
xorpd  %xmm0,%xmm9
add    $0xffffffff,%eax
imul   %r12d,%eax
movslq %r12d,%r10
mov    0x64(%rsp),%ecx
cmp    $0x4,%ecx
mov    $0x3,%r15d
cmovge %ecx,%r15d
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x170(%rsp)
movslq %eax,%r8
mov    %r12d,%r9d
mov    0xa8(%rsp),%rdi
imul   %r10,%rdi
mov    0xc0(%rsp),%r14
lea    -0x2(%r14),%rbp
imul   %r10,%rbp
lea    (%r8,%r9,1),%rax
lea    (%rbx,%rax,8),%rax
mov    %rax,0x150(%rsp)
unpcklpd %xmm11,%xmm11
unpcklpd %xmm0,%xmm10
mov    %r9d,%esi
and    $0xfffffffe,%esi
lea    -0x2(%rsi),%rax
mov    %rax,0x138(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x130(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
lea    0x0(,%r10,8),%r11
lea    -0x1(%r14),%rdx
imul   %r10,%rdx
mov    %r11,%rax
neg    %rax
mov    %rax,0x80(%rsp)
mov    %r10,%rax
shl    $0x4,%rax
add    %rbx,%rax
mov    %rax,0x160(%rsp)
lea    -0x2(%r14),%rax
imul   %r10,%rax
lea    (%rbx,%rax,8),%rax
mov    %rax,0x158(%rsp)
movsd  0x29c9(%rip),%xmm2
movapd 0x29c8(%rip),%xmm8
lea    (%r10,%r9,1),%rax
mov    %rdi,0xa8(%rsp)
lea    (%rdi,%r9,1),%rcx
mov    %rcx,0x168(%rsp)
lea    (%r10,%r10,1),%rcx
mov    %rcx,0xb8(%rsp)
lea    (%r9,%r10,2),%rcx
mov    %rcx,0x110(%rsp)
mov    %rbp,0xa0(%rsp)
lea    0x0(%rbp,%r9,1),%rcx
mov    %rcx,0x180(%rsp)
lea    (%rbx,%r9,8),%rcx
mov    %rcx,0x148(%rsp)
lea    (%rbx,%r10,8),%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,0xe0(%rsp)
lea    (%rbx,%rax,8),%rax
mov    %rax,0x140(%rsp)
mov    %r8,0xd8(%rsp)
lea    (%rbx,%r8,8),%rax
mov    %rax,0xc8(%rsp)
mov    0x8(%rsp),%r8
lea    0x10(%r8,%r10,8),%rax
lea    0x10(%r8,%rdx,8),%rbp
lea    (%r8,%r10,8),%rcx
mov    %rdx,0xf0(%rsp)
lea    (%r8,%rdx,8),%r14
mov    $0x1,%edx
mov    %rdx,0xb0(%rsp)
xor    %edx,%edx
mov    %r10,0xe8(%rsp)
mov    %r10,0x10(%rsp)
mov    %r11,0x48(%rsp)
mov    %r15,0x70(%rsp)
mov    %rsi,0x108(%rsp)
jmp    177f <radfg+0x65f>
nopl   0x0(%rax)
mov    0xb0(%rsp),%r13
add    $0x1,%r13
mov    0x178(%rsp),%rdx
add    $0x1,%rdx
mov    0x100(%rsp),%rax
add    %r11,%rax
mov    0xf8(%rsp),%rbp
add    %rdi,%rbp
mov    0x10(%rsp),%r10
sub    %r10,0xf0(%rsp)
add    %r10,0xe8(%rsp)
add    %r11,%rcx
add    %rdi,%r14
mov    %r13,0xb0(%rsp)
cmp    0x170(%rsp),%r13
je     1fe0 <radfg+0xec0>
mov    %rbp,0xf8(%rsp)
mov    %rax,0x100(%rsp)
mov    %rdx,0x178(%rsp)
mov    %rdx,%rax
imul   %r10,%rax
lea    (%rax,%r10,1),%rdx
mov    0xe0(%rsp),%rsi
add    %rax,%rsi
mov    0xa8(%rsp),%rdi
sub    %rax,%rdi
mov    0x168(%rsp),%rbp
sub    %rax,%rbp
lea    (%r8,%rdx,8),%rax
mov    %rax,0x38(%rsp)
lea    (%r8,%rsi,8),%rax
mov    %rax,0x28(%rsp)
lea    (%r8,%rdi,8),%rax
mov    %rax,0x40(%rsp)
lea    (%r8,%rbp,8),%rax
mov    %rax,0x50(%rsp)
movapd %xmm2,%xmm3
unpckhpd %xmm10,%xmm3
movapd %xmm9,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
mulpd  %xmm11,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
test   %r12d,%r12d
jle    189d <radfg+0x77d>
cmp    $0x1,%r12d
jne    1b30 <radfg+0xa10>
xor    %r13d,%r13d
mov    0xf0(%rsp),%rax
add    %r13,%rax
lea    (%r8,%rax,8),%r15
mov    0xd8(%rsp),%rax
add    %r13,%rax
lea    (%rbx,%rax,8),%r11
mov    0xe8(%rsp),%rax
add    %r13,%rax
lea    (%r8,%rax,8),%rbp
lea    (%r10,%r13,1),%rax
lea    (%rbx,%rax,8),%rax
lea    (%rbx,%r13,8),%rdx
mov    %r9,%rsi
sub    %r13,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rdi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%rdi,8),%xmm3
movsd  %xmm3,0x0(%rbp,%rdi,8)
movsd  (%r11,%rdi,8),%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%r15,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1870 <radfg+0x750>
cmpl   $0x5,0x58(%rsp)
mov    0x48(%rsp),%r11
mov    0x70(%rsp),%r15
mov    0x80(%rsp),%rdi
jl     1720 <radfg+0x600>
xorpd  %xmm8,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x50(%rsp),%rax
cmp    %rax,0x38(%rsp)
setb   %al
mov    0x40(%rsp),%rdx
cmp    0x28(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0x90(%rsp)
mov    $0x2,%eax
mov    0x158(%rsp),%rdx
mov    0x160(%rsp),%r13
xor    %r10d,%r10d
movapd %xmm2,%xmm6
jmp    1927 <radfg+0x807>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%r10
add    %r11,%r13
add    %rdi,%rdx
cmp    %r15,%rax
je     1720 <radfg+0x600>
movapd %xmm6,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm4,%xmm7
unpcklpd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
test   %r12d,%r12d
jle    1910 <radfg+0x7f0>
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
cmp    $0x1,%r12d
jne    1960 <radfg+0x840>
xor    %ebp,%ebp
jmp    1af0 <radfg+0x9d0>
nopl   (%rax)
mov    %r10,%rsi
imul   0x10(%rsp),%rsi
mov    0xb8(%rsp),%rdi
lea    (%rdi,%rsi,1),%r11
mov    0x110(%rsp),%rdi
lea    (%rdi,%rsi,1),%r8
mov    0xa0(%rsp),%rbp
sub    %rsi,%rbp
mov    0x180(%rsp),%rdi
sub    %rsi,%rdi
lea    (%rbx,%r11,8),%r11
lea    (%rbx,%r8,8),%rsi
lea    (%rbx,%rbp,8),%rbp
lea    (%rbx,%rdi,8),%r8
mov    0x38(%rsp),%rdi
cmp    %rsi,%rdi
setb   %r15b
mov    0x28(%rsp),%rbx
cmp    %rbx,%r11
setb   %r12b
and    %r15b,%r12b
or     0x90(%rsp),%r12b
cmp    %r8,%rdi
setb   %r15b
cmp    %rbx,%rbp
setb   0x20(%rsp)
mov    0x40(%rsp),%rdi
cmp    %rsi,%rdi
setb   %bl
mov    0x50(%rsp),%rsi
cmp    %rsi,%r11
setb   0x18(%rsp)
cmp    %r8,%rdi
setb   %r11b
cmp    %rsi,%rbp
setb   %dil
test   %r12b,%r12b
jne    1abc <radfg+0x99c>
and    0x20(%rsp),%r15b
mov    0x8(%rsp),%r8
jne    1acd <radfg+0x9ad>
and    0x18(%rsp),%bl
mov    0x88(%rsp),%rbx
mov    0x68(%rsp),%r12d
jne    1ab8 <radfg+0x998>
mov    $0x0,%ebp
and    %dil,%r11b
mov    0x48(%rsp),%r11
mov    0x70(%rsp),%r15
mov    0x108(%rsp),%rsi
mov    0x80(%rsp),%rdi
jne    1af0 <radfg+0x9d0>
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
movupd (%rcx,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rcx,%rbp,8)
movupd (%rdx,%rbp,8),%xmm0
movupd (%r14,%rbp,8),%xmm1
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    1a70 <radfg+0x950>
mov    %rsi,%rbp
cmp    %r9,%rsi
jne    1af0 <radfg+0x9d0>
jmp    1910 <radfg+0x7f0>
xor    %ebp,%ebp
jmp    1adc <radfg+0x9bc>
xor    %ebp,%ebp
mov    0x88(%rsp),%rbx
mov    0x8(%rsp),%r8
jmp    1ad7 <radfg+0x9b7>
xor    %ebp,%ebp
mov    0x88(%rsp),%rbx
mov    0x68(%rsp),%r12d
mov    0x48(%rsp),%r11
mov    0x70(%rsp),%r15
mov    0x80(%rsp),%rdi
xchg   %ax,%ax
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r9
jne    1af0 <radfg+0x9d0>
jmp    1910 <radfg+0x7f0>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
mov    0x50(%rsp),%r10
cmp    %r10,%rax
setb   0x20(%rsp)
mov    0x28(%rsp),%r15
mov    0x40(%rsp),%r11
cmp    %r15,%r11
setb   0x18(%rsp)
mov    0x148(%rsp),%rbp
cmp    %rbp,%rax
setb   0x90(%rsp)
cmp    %rbx,%r15
seta   0x7f(%rsp)
mov    0x140(%rsp),%rdx
cmp    %rdx,%rax
setb   0x7e(%rsp)
mov    0xd0(%rsp),%rsi
cmp    %r15,%rsi
setb   0x7d(%rsp)
mov    0x150(%rsp),%rdi
cmp    %rdi,%rax
setb   %al
mov    0xc8(%rsp),%r13
cmp    %r15,%r13
setb   0x7c(%rsp)
cmp    %rbp,%r11
setb   %bpl
cmp    %rbx,%r10
seta   0x7b(%rsp)
cmp    %rdx,%r11
setb   %r15b
cmp    %r10,%rsi
setb   0x7a(%rsp)
cmp    %rdi,%r11
setb   %dil
cmp    %r10,%r13
setb   %sil
mov    0x18(%rsp),%dl
test   %dl,0x20(%rsp)
jne    1d5a <radfg+0xc3a>
mov    0x7f(%rsp),%dl
and    %dl,0x90(%rsp)
mov    0x10(%rsp),%r10
jne    1821 <radfg+0x701>
mov    0x7d(%rsp),%dl
and    %dl,0x7e(%rsp)
jne    1821 <radfg+0x701>
and    0x7c(%rsp),%al
jne    1821 <radfg+0x701>
and    0x7b(%rsp),%bpl
jne    1821 <radfg+0x701>
and    0x7a(%rsp),%r15b
jne    1821 <radfg+0x701>
mov    $0x0,%r13d
and    %sil,%dil
jne    1824 <radfg+0x704>
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
cmpq   $0x0,0x138(%rsp)
mov    0x100(%rsp),%r11
mov    0xf8(%rsp),%rbp
je     1cde <radfg+0xbbe>
mov    0x128(%rsp),%rdx
xor    %eax,%eax
mov    0xd0(%rsp),%rsi
mov    0xc8(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm3
movupd (%rsi,%rax,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,-0x10(%r11,%rax,8)
movupd (%rdi,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,-0x10(%rbp,%rax,8)
movupd 0x10(%rbx,%rax,8),%xmm3
movupd 0x10(%rsi,%rax,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%r11,%rax,8)
movupd 0x10(%rdi,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,0x0(%rbp,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rdx
jne    1c80 <radfg+0xb60>
jmp    1ce0 <radfg+0xbc0>
xor    %eax,%eax
testb  $0x1,0x130(%rsp)
01
mov    0x108(%rsp),%rbp
je     1d49 <radfg+0xc29>
mov    0xc0(%rsp),%rdx
mov    0xb0(%rsp),%rsi
sub    %rsi,%rdx
imul   %r10,%rsi
imul   %r10,%rdx
movupd (%rbx,%rax,8),%xmm3
lea    (%rax,%r10,1),%rdi
movupd (%rbx,%rdi,8),%xmm6
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
add    %rax,%rsi
movupd %xmm5,(%r8,%rsi,8)
mov    0xd8(%rsp),%rsi
add    %rax,%rsi
movupd (%rbx,%rsi,8),%xmm3
mulpd  %xmm4,%xmm3
add    %rax,%rdx
movupd %xmm3,(%r8,%rdx,8)
mov    %rbp,%r13
cmp    %r9,%rbp
jne    1824 <radfg+0x704>
jmp    189d <radfg+0x77d>
xor    %r13d,%r13d
mov    0x10(%rsp),%r10
jmp    1824 <radfg+0x704>
movl   $0x0,0x28(%rsp)
mov    0x4(%rsp),%r15d
cmp    %r15d,%r13d
jl     2ab4 <radfg+0x1994>
test   %r15d,%r15d
jle    2bad <radfg+0x1a8d>
mov    0x58(%rsp),%rax
mov    %eax,%r15d
imul   %r13d,%r15d
movslq %r13d,%rax
mov    0x4(%rsp),%ecx
mov    %r13d,%edi
lea    (%rbx,%rdi,8),%rdx
mov    %rdx,0x38(%rsp)
mov    %edi,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x40(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x50(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
movabs $0x7ffffffffffffffc,%rbp
ff ff 7f
or     $0x2,%rbp
mov    %rdx,%rsi
mov    %rdx,0x48(%rsp)
and    %rdx,%rbp
mov    %rbp,0x70(%rsp)
mov    %edi,%r11d
and    $0x3,%r11d
mov    0x8(%rsp),%r12
lea    0x30(%r12),%r8
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,8),%r10
lea    0x30(%rbx),%rax
mov    %rax,0x80(%rsp)
lea    0x18(%rbx),%rax
mov    %rax,0x68(%rsp)
xor    %r14d,%r14d
xor    %r9d,%r9d
mov    %r11,0x10(%rsp)
jmp    1e36 <radfg+0xd16>
xchg   %ax,%ax
add    $0x1,%r9
add    %r10,%r8
add    %r15d,%r14d
add    %r10,%r12
cmp    %rcx,%r9
je     2bad <radfg+0x1a8d>
test   %r13d,%r13d
jle    1e20 <radfg+0xd00>
movslq %r14d,%rax
mov    %rax,0x20(%rsp)
cmp    $0x4,%r13d
jae    1e50 <radfg+0xd30>
xor    %ebp,%ebp
jmp    1f50 <radfg+0xe30>
mov    %r15d,%r11d
mov    %r15d,%eax
imul   %r9d,%eax
mov    %r9,%rbp
imul   0x18(%rsp),%rbp
lea    (%rdi,%rbp,1),%rdx
cltq
lea    (%rbx,%rax,8),%rsi
mov    0x8(%rsp),%r15
lea    (%r15,%rdx,8),%rdx
cmp    %rdx,%rsi
jae    1e9c <radfg+0xd7c>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
lea    (%r15,%rbp,8),%rdx
cmp    %rax,%rdx
jae    1e9c <radfg+0xd7c>
xor    %ebp,%ebp
mov    %r11d,%r15d
mov    0x10(%rsp),%r11
jmp    1f50 <radfg+0xe30>
cmpq   $0x0,0x50(%rsp)
je     1efe <radfg+0xdde>
mov    0x80(%rsp),%rax
mov    0x20(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0x70(%rsp),%rsi
xor    %r13d,%r13d
mov    %r11d,%r15d
movups -0x30(%r8,%r13,8),%xmm0
movups -0x20(%r8,%r13,8),%xmm1
movups %xmm0,-0x30(%rax,%r13,8)
movups %xmm1,-0x20(%rax,%r13,8)
movupd -0x10(%r8,%r13,8),%xmm0
movupd (%r8,%r13,8),%xmm1
movupd %xmm0,-0x10(%rax,%r13,8)
movupd %xmm1,(%rax,%r13,8)
add    $0x8,%r13
add    $0xfffffffffffffffe,%rsi
jne    1ec0 <radfg+0xda0>
jmp    1f04 <radfg+0xde4>
xor    %r13d,%r13d
mov    %r11d,%r15d
testb  $0x1,0x48(%rsp)
mov    0x10(%rsp),%r11
je     1f3a <radfg+0xe1a>
mov    %r15d,%eax
imul   %r9d,%eax
cltq
add    %r13,%rbp
mov    0x8(%rsp),%rdx
movupd (%rdx,%rbp,8),%xmm0
movupd 0x10(%rdx,%rbp,8),%xmm1
add    %r13,%rax
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mov    0x40(%rsp),%rax
mov    %rax,%rbp
cmp    %rdi,%rax
mov    0x30(%rsp),%r13
je     1e20 <radfg+0xd00>
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %r11,%r11
je     1f85 <radfg+0xe65>
mov    0x20(%rsp),%rdx
lea    (%rbx,%rdx,8),%rsi
mov    %r11,%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1f70 <radfg+0xe50>
cmp    $0x3,%rax
jb     1e20 <radfg+0xd00>
mov    0x68(%rsp),%rax
mov    0x20(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
nopl   (%rax)
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rbp,8)
movsd  0x8(%r12,%rbp,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rbp,8)
movsd  0x10(%r12,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbp,8)
movsd  0x18(%r12,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1fa0 <radfg+0xe80>
jmp    1e20 <radfg+0xd00>
mov    0x64(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r13d
cmovge %eax,%r13d
lea    (%r8,%r9,8),%rax
mov    %rax,0x20(%rsp)
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x18(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0x28(%rsp)
and    %rax,%rdx
mov    %rdx,0x40(%rsp)
mov    %r9,%r12
neg    %r12
lea    (%rbx,%r10,8),%rdi
add    $0x30,%rdi
lea    (%rbx,%r10,8),%rdx
add    $0x8,%rdx
mov    $0x1,%ecx
xor    %r10d,%r10d
mov    0x4(%rsp),%r15d
jmp    2077 <radfg+0xf57>
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x1,%r10
add    %r11,%rdi
add    %r11,%rdx
cmp    %r13,%rcx
je     220e <radfg+0x10ee>
cmpl   $0x0,0x68(%rsp)
jle    2060 <radfg+0xf40>
mov    %rcx,%r14
mov    0x10(%rsp),%r11
imul   %r11,%r14
cmpl   $0x4,0x68(%rsp)
jb     20bf <radfg+0xf9f>
mov    %r10,%rax
imul   %r11,%rax
mov    0xe0(%rsp),%rsi
lea    (%rsi,%rax,1),%rbp
lea    (%rbx,%rbp,8),%rbp
cmp    %r8,%rbp
jbe    2133 <radfg+0x1013>
add    %r11,%rax
lea    (%rbx,%rax,8),%rax
cmp    0x20(%rsp),%rax
jae    2133 <radfg+0x1013>
xor    %eax,%eax
mov    0x48(%rsp),%r11
mov    %rax,%rbp
test   $0x1,%r9b
je     20eb <radfg+0xfcb>
add    %rax,%r14
movsd  (%rbx,%r14,8),%xmm0
addsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %r12,%rax
je     2060 <radfg+0xf40>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbp,8),%xmm0
addsd  (%r8,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
movsd  (%rdx,%rbp,8),%xmm0
addsd  0x8(%r8,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r8,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r9
jne    2100 <radfg+0xfe0>
jmp    2060 <radfg+0xf40>
cmpq   $0x0,0x38(%rsp)
je     21b1 <radfg+0x1091>
mov    0x40(%rsp),%r8
xor    %ebp,%ebp
mov    0x8(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rbp,8),%xmm0
movupd -0x20(%rdi,%rbp,8),%xmm1
movupd (%rax,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rax,%rbp,8),%xmm1
movupd 0x30(%rax,%rbp,8),%xmm3
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
movupd -0x10(%rdi,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdi,%rbp,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rax,%rbp,8)
movupd %xmm1,0x30(%rax,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%r8
jne    2150 <radfg+0x1030>
jmp    21b8 <radfg+0x1098>
xor    %ebp,%ebp
mov    0x8(%rsp),%rax
testb  $0x1,0x28(%rsp)
mov    %rax,%r8
mov    0x48(%rsp),%r11
je     21f8 <radfg+0x10d8>
lea    (%r14,%rbp,1),%rax
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd (%r8,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r8,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rbp,8)
movupd %xmm0,0x10(%r8,%rbp,8)
mov    0x18(%rsp),%rsi
mov    %rsi,%rax
cmp    %r9,%rsi
je     2060 <radfg+0xf40>
jmp    20c6 <radfg+0xfa6>
mov    $0x1,%al
mov    %eax,0x28(%rsp)
jmp    2aa6 <radfg+0x1986>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nop
movups (%rbx,%rdi,8),%xmm1
movups 0x10(%rbx,%rdi,8),%xmm2
movups %xmm1,(%rdx,%rdi,8)
movups %xmm2,0x10(%rdx,%rdi,8)
movups 0x20(%rbx,%rdi,8),%xmm1
movups 0x30(%rbx,%rdi,8),%xmm2
movups %xmm1,0x20(%rdx,%rdi,8)
movups %xmm2,0x30(%rdx,%rdi,8)
movups 0x40(%rbx,%rdi,8),%xmm1
movups 0x50(%rbx,%rdi,8),%xmm2
movups %xmm1,0x40(%rdx,%rdi,8)
movups %xmm2,0x50(%rdx,%rdi,8)
movupd 0x60(%rbx,%rdi,8),%xmm1
movupd 0x70(%rbx,%rdi,8),%xmm2
movupd %xmm1,0x60(%rdx,%rdi,8)
movupd %xmm2,0x70(%rdx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2220 <radfg+0x1100>
test   %r8,%r8
je     22bf <radfg+0x119f>
lea    (%rdx,%rdi,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm1
movupd (%rdi,%rbp,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rbp,1)
movupd %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    22a0 <radfg+0x1180>
cmp    %rax,%rcx
jne    12d9 <radfg+0x1b9>
cmp    $0x2,%r14d
jl     27b9 <radfg+0x1699>
movslq 0x30(%rsp),%rax
movslq 0x4(%rsp),%rbp
mov    %ebp,%r15d
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %rcx,0x40(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x90(%rsp)
lea    0x2(%rbp),%rcx
imul   %rax,%rcx
mov    0x8(%rsp),%r12
lea    (%r12,%rcx,8),%rdx
mov    %rdx,0xa0(%rsp)
mov    %rbp,%rdx
imul   %rax,%rdx
lea    0x0(,%rdx,8),%rsi
mov    %rsi,0x48(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
mov    %rsi,0xb8(%rsp)
lea    (%rbx,%rcx,8),%rsi
lea    0x1(%rbp),%rcx
imul   %rax,%rcx
lea    (%r12,%rcx,8),%rdi
lea    (%rbx,%rcx,8),%r8
lea    0x3(%rbp),%rcx
imul   %rax,%rcx
lea    (%r12,%rcx,8),%r9
lea    (%rbx,%rcx,8),%r10
lea    (%rbx,%rdx,8),%r11
lea    (%r12,%rdx,8),%r14
mov    0x1c0(%rsp),%rdx
mov    0x58(%rsp),%ecx
mov    %rcx,0x38(%rsp)
mov    %r15,0x20(%rsp)
lea    -0x1(%r15),%rcx
mov    %rcx,0x80(%rsp)
lea    0x0(,%rax,8),%r15
mov    $0x1,%r12d
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
mov    %rbp,0x50(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r15,0x70(%rsp)
jmp    23dd <radfg+0x12bd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x10(%rsp),%rcx
add    0x48(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0x18(%rsp),%rcx
add    0x50(%rsp),%rcx
mov    %rcx,0x18(%rsp)
cmp    0x38(%rsp),%r12
je     24aa <radfg+0x138a>
cmpl   $0x0,0x4(%rsp)
jle    23b0 <radfg+0x1290>
mov    %r12,0x28(%rsp)
cmpq   $0x3,0x80(%rsp)
jae    2400 <radfg+0x12e0>
xor    %ebp,%ebp
jmp    245a <radfg+0x133a>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
xor    %ebp,%ebp
mov    0x90(%rsp),%r13
mov    0xa0(%rsp),%r12
mov    0xb8(%rsp),%r15
nop
movsd  (%r11,%rcx,1),%xmm1
movsd  %xmm1,(%r14,%rcx,1)
movsd  (%r8,%rcx,1),%xmm1
movsd  %xmm1,(%rdi,%rcx,1)
movsd  (%rsi,%rcx,1),%xmm1
movsd  %xmm1,(%r12,%rcx,1)
movsd  (%r10,%rcx,1),%xmm1
movsd  %xmm1,(%r9,%rcx,1)
add    $0x4,%rbp
add    %r15,%rcx
cmp    %rbp,%r13
jne    2420 <radfg+0x1300>
cmpq   $0x0,0x40(%rsp)
mov    0x8(%rsp),%r13
mov    0x70(%rsp),%r15
mov    0x28(%rsp),%r12
je     23b0 <radfg+0x1290>
add    0x18(%rsp),%rbp
imul   %r15,%rbp
mov    0x40(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rbp,1),%xmm1
movsd  %xmm1,0x0(%r13,%rbp,1)
add    %r15,%rbp
add    $0xffffffffffffffff,%rcx
jne    2490 <radfg+0x1370>
jmp    23b0 <radfg+0x1290>
mov    0x9c(%rsp),%ecx
cmp    0x4(%rsp),%ecx
jle    263d <radfg+0x151d>
cmpl   $0x2,0x58(%rsp)
jl     27b9 <radfg+0x1699>
movslq 0x4(%rsp),%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rdi
mov    %rcx,0x80(%rsp)
add    %rcx,%rdi
mov    %rdi,0x18(%rsp)
mov    %rax,%r14
shl    $0x20,%r14
lea    (%rbx,%rsi,8),%rcx
mov    %rcx,0x40(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x50(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x48(%rsp)
movl   $0xffffffff,0x10(%rsp)
ff
mov    $0x1,%esi
movabs $0x200000000,%r10
mov    0x8(%rsp),%r9
jmp    2581 <radfg+0x1461>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%rsi
add    $0x1,%rsi
mov    0x10(%rsp),%ecx
add    0x30(%rsp),%ecx
mov    %ecx,0x10(%rsp)
mov    0x18(%rsp),%rcx
add    0x80(%rsp),%rcx
mov    %rcx,0x18(%rsp)
mov    0x48(%rsp),%rcx
add    %rcx,0x40(%rsp)
add    %rcx,0x50(%rsp)
cmp    0x38(%rsp),%rsi
je     27b9 <radfg+0x1699>
mov    %rsi,0x28(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    2540 <radfg+0x1420>
movslq 0x10(%rsp),%rcx
lea    (%rdx,%rcx,8),%rcx
mov    0x50(%rsp),%rbp
mov    0x40(%rsp),%rsi
mov    0x18(%rsp),%r8
xor    %r12d,%r12d
jmp    25c8 <radfg+0x14a8>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %r14,%r8
add    %r15,%rsi
add    %r15,%rbp
cmp    0x20(%rsp),%r12
je     2540 <radfg+0x1420>
cmpl   $0x3,0x30(%rsp)
jl     25b0 <radfg+0x1490>
mov    $0x2,%r13d
mov    %r8,%r11
nopl   0x0(%rax,%rax,1)
mov    %r11,%rdi
sar    $0x1d,%rdi
movsd  (%rcx,%r13,8),%xmm1
mulsd  (%rsi,%r13,8),%xmm1
movsd  -0x8(%rcx,%r13,8),%xmm2
mulsd  (%rbx,%rdi,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r9,%rdi,1)
movsd  (%rbx,%rdi,1),%xmm1
mulsd  (%rcx,%r13,8),%xmm1
movsd  -0x8(%rcx,%r13,8),%xmm2
mulsd  (%rsi,%r13,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%r13,8)
add    $0x2,%r13
add    %r10,%r11
cmp    %rax,%r13
jl     25e0 <radfg+0x14c0>
jmp    25b0 <radfg+0x1490>
cmpl   $0x2,0x58(%rsp)
jl     27b9 <radfg+0x1699>
mov    0x4(%rsp),%ecx
movslq %ecx,%rsi
imul   0x30(%rsp),%ecx
mov    %rcx,0x70(%rsp)
add    $0x1,%ecx
mov    %ecx,0x18(%rsp)
imul   %rax,%rsi
lea    (%rbx,%rsi,8),%rcx
mov    %rcx,0x40(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0x50(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x48(%rsp)
movl   $0xffffffff,0x10(%rsp)
ff
mov    $0x1,%esi
mov    0x4(%rsp),%r15d
mov    0x30(%rsp),%r14
mov    0x8(%rsp),%r13
jmp    26eb <radfg+0x15cb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rsi
add    $0x1,%rsi
mov    0x10(%rsp),%ecx
add    0x30(%rsp),%ecx
mov    %ecx,0x10(%rsp)
mov    0x18(%rsp),%ecx
add    0x70(%rsp),%ecx
mov    %ecx,0x18(%rsp)
mov    0x48(%rsp),%rcx
add    %rcx,0x40(%rsp)
add    %rcx,0x50(%rsp)
cmp    0x38(%rsp),%rsi
je     27b9 <radfg+0x1699>
mov    %rsi,0x28(%rsp)
cmpl   $0x3,0x30(%rsp)
jl     26b0 <radfg+0x1590>
movslq 0x10(%rsp),%rbp
mov    $0x2,%esi
mov    0x50(%rsp),%rcx
mov    0x40(%rsp),%rdi
mov    0x18(%rsp),%r11d
jmp    273c <radfg+0x161c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rsi
add    $0x2,%r11d
add    $0x10,%rdi
add    $0x10,%rcx
mov    %r10,%rbp
cmp    %rax,%rsi
jge    26b0 <radfg+0x1590>
lea    0x2(%rbp),%r10
test   %r15d,%r15d
jle    2720 <radfg+0x1600>
mov    $0x2,%r9d
mov    0x20(%rsp),%r12
mov    %r11d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%rdx,%rbp,8),%xmm1
movsd  (%rdx,%r10,8),%xmm2
mulsd  (%rdi,%r9,8),%xmm2
movslq %r8d,%r8
mulsd  (%rbx,%r8,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%r8,8)
movsd  (%rbx,%r8,8),%xmm1
mulsd  (%rdx,%r10,8),%xmm1
movsd  0x8(%rdx,%rbp,8),%xmm2
mulsd  (%rdi,%r9,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%r9,8)
add    %r14d,%r8d
add    %rax,%r9
add    $0xffffffffffffffff,%r12
jne    2760 <radfg+0x1640>
jmp    2720 <radfg+0x1600>
mov    0x4(%rsp),%r15d
cmp    %r15d,0x9c(%rsp)
jge    293c <radfg+0x181c>
mov    0x58(%rsp),%rcx
cmp    $0x3,%ecx
jl     2a9e <radfg+0x197e>
movslq 0x30(%rsp),%rax
mov    %ecx,%edx
movslq %r15d,%rsi
mov    0x64(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edi
cmovge %ecx,%edi
mov    %rdi,0x10(%rsp)
mov    %r15d,%r10d
add    $0xffffffffffffffff,%rdx
imul   %rax,%rsi
imul   %rsi,%rdx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x38(%rsp)
neg    %rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%rax,8),%rcx
lea    (%rbx,%rdx,8),%rdx
add    $0x10,%rdx
mov    %rdx,0x18(%rsp)
lea    (%rdi,%rsi,8),%r8
add    $0x10,%r8
lea    (%rbx,%rsi,8),%r13
add    $0x10,%r13
mov    $0x1,%esi
jmp    2889 <radfg+0x1769>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
mov    0x28(%rsp),%rdx
add    %rdx,0x20(%rsp)
add    %rdx,0x18(%rsp)
mov    0x38(%rsp),%rdx
add    %rdx,%r8
add    %rdx,%r13
cmp    0x10(%rsp),%rsi
je     1458 <radfg+0x338>
cmpl   $0x3,0x30(%rsp)
jl     2860 <radfg+0x1740>
mov    $0x2,%ebp
mov    %r13,%rdi
mov    %r8,%r12
mov    0x18(%rsp),%r14
mov    0x20(%rsp),%r11
jmp    28c9 <radfg+0x17a9>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rbp
add    $0x10,%r11
add    $0x10,%r14
add    $0x10,%r12
add    $0x10,%rdi
cmp    %rax,%rbp
jge    2860 <radfg+0x1740>
test   %r15d,%r15d
jle    28b0 <radfg+0x1790>
mov    %r10,%rdx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%r12,%r9,1),%xmm1
addsd  -0x8(%r11,%r9,1),%xmm1
movsd  %xmm1,-0x8(%rdi,%r9,1)
movsd  (%r12,%r9,1),%xmm1
subsd  (%r11,%r9,1),%xmm1
movsd  %xmm1,-0x8(%r14,%r9,1)
movsd  (%r12,%r9,1),%xmm1
addsd  (%r11,%r9,1),%xmm1
movsd  %xmm1,(%rdi,%r9,1)
movsd  -0x8(%r11,%r9,1),%xmm1
subsd  -0x8(%r12,%r9,1),%xmm1
movsd  %xmm1,(%r14,%r9,1)
add    %rcx,%r9
add    $0xffffffffffffffff,%rdx
jne    28e0 <radfg+0x17c0>
jmp    28b0 <radfg+0x1790>
mov    0x58(%rsp),%rcx
cmp    $0x3,%ecx
jl     2a9e <radfg+0x197e>
movslq 0x30(%rsp),%rax
mov    %ecx,%esi
movslq %r15d,%rdi
mov    0x64(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x18(%rsp)
mov    %r15d,%edx
add    $0xffffffffffffffff,%rsi
imul   %rax,%rdi
imul   %rdi,%rsi
mov    0x8(%rsp),%rbp
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%rdi,8),%rcx
mov    %rcx,0x10(%rsp)
neg    %rcx
mov    %rcx,0x38(%rsp)
lea    0x0(,%rax,8),%rcx
lea    (%rbx,%rsi,8),%r8
lea    0x0(,%rdi,8),%r12
add    %rbp,%r12
lea    (%rbx,%rdi,8),%r13
mov    $0x1,%esi
jmp    29f7 <radfg+0x18d7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
mov    0x38(%rsp),%rdi
add    %rdi,0x20(%rsp)
add    %rdi,%r8
mov    0x10(%rsp),%rdi
add    %rdi,%r12
add    %rdi,%r13
cmp    0x18(%rsp),%rsi
je     1458 <radfg+0x338>
test   %r15d,%r15d
jle    29d0 <radfg+0x18b0>
mov    %r13,%rdi
mov    %r12,%rbp
mov    %r8,%r14
mov    0x20(%rsp),%r11
xor    %r10d,%r10d
jmp    2a25 <radfg+0x1905>
nop
add    $0x1,%r10
add    %rcx,%r11
add    %rcx,%r14
add    %rcx,%rbp
add    %rcx,%rdi
cmp    %rdx,%r10
je     29d0 <radfg+0x18b0>
cmpl   $0x3,0x30(%rsp)
jl     2a10 <radfg+0x18f0>
mov    $0x2,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbp,%r9,8),%xmm1
addsd  -0x8(%r11,%r9,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%r9,8)
movsd  0x0(%rbp,%r9,8),%xmm1
subsd  (%r11,%r9,8),%xmm1
movsd  %xmm1,-0x8(%r14,%r9,8)
movsd  0x0(%rbp,%r9,8),%xmm1
addsd  (%r11,%r9,8),%xmm1
movsd  %xmm1,(%rdi,%r9,8)
movsd  -0x8(%r11,%r9,8),%xmm1
subsd  -0x8(%rbp,%r9,8),%xmm1
movsd  %xmm1,(%r14,%r9,8)
add    $0x2,%r9
cmp    %rax,%r9
jl     2a40 <radfg+0x1920>
jmp    2a10 <radfg+0x18f0>
movl   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r13
cmp    %r15d,%r13d
jge    1d7d <radfg+0xc5d>
test   %r13d,%r13d
jle    2bad <radfg+0x1a8d>
mov    0x58(%rsp),%r9
imul   %r13d,%r9d
mov    %r13d,%ecx
mov    0x4(%rsp),%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
mov    %rcx,%r14
shl    $0x4,%r14
lea    (%r9,%r9,1),%r15d
xor    %eax,%eax
mov    0x8(%rsp),%r10
jmp    2b01 <radfg+0x19e1>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x8,%r10
cmp    %rcx,%rax
je     2bad <radfg+0x1a8d>
cmpl   $0x0,0x4(%rsp)
jle    2af0 <radfg+0x19d0>
cmpl   $0x1,0x4(%rsp)
jne    2b20 <radfg+0x1a00>
xor    %ebp,%ebp
jmp    2b7b <radfg+0x1a5b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
mov    %r10,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm0
movslq %esi,%rsi
lea    (%rax,%rsi,1),%rbx
mov    0x88(%rsp),%rdx
movsd  %xmm0,(%rdx,%rbx,8)
movsd  (%rdi,%rcx,8),%xmm0
lea    (%r9,%rsi,1),%ebx
movslq %ebx,%rbx
add    %rax,%rbx
mov    0x88(%rsp),%rdx
movsd  %xmm0,(%rdx,%rbx,8)
mov    0x88(%rsp),%rbx
add    $0x2,%rbp
add    %r14,%rdi
add    %r15d,%esi
cmp    %rbp,%r11
jne    2b30 <radfg+0x1a10>
test   $0x1,%r8b
je     2af0 <radfg+0x19d0>
mov    %rbp,%rsi
imul   %rcx,%rsi
add    %rax,%rsi
mov    0x8(%rsp),%rdx
movsd  (%rdx,%rsi,8),%xmm0
imul   %r9d,%ebp
movslq %ebp,%rsi
add    %rax,%rsi
movsd  %xmm0,(%rbx,%rsi,8)
jmp    2af0 <radfg+0x19d0>
cmpb   $0x0,0x28(%rsp)
je     2c9c <radfg+0x1b7c>
mov    0x30(%rsp),%rsi
movslq %esi,%rbp
mov    0x58(%rsp),%r8
movslq %r8d,%rcx
mov    0x64(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %rdx,0x18(%rsp)
mov    0x4(%rsp),%eax
movslq %eax,%r14
mov    %eax,%eax
mov    %rax,0x10(%rsp)
lea    -0x1(%rcx),%rdi
imul   %rbp,%r14
imul   %r14,%rdi
shl    $0x3,%rdi
shl    $0x3,%r14
lea    0x0(,%rbp,8),%rdx
imul   %rbp,%rcx
shl    $0x4,%rbp
mov    %rbp,0x20(%rsp)
lea    (%rbx,%rbp,1),%r10
shl    $0x3,%rcx
lea    (%rsi,%rsi,1),%r11d
lea    (%rsi,%rsi,1),%r13d
add    $0xffffffff,%r13d
mov    %r8d,%ebp
imul   %esi,%ebp
mov    $0x1,%eax
mov    %r14,%rsi
jmp    2c59 <radfg+0x1b39>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
sub    %r14,%rdi
add    0x20(%rsp),%r10
add    %r11d,%r13d
add    %r14,%rsi
cmp    0x18(%rsp),%rax
je     2c9c <radfg+0x1b7c>
cmpl   $0x0,0x4(%rsp)
jle    2c40 <radfg+0x1b20>
mov    0x10(%rsp),%r8
mov    %r13d,%r9d
mov    %r10,%r12
mov    0x8(%rsp),%r15
movsd  (%r15,%rsi,1),%xmm0
movslq %r9d,%r9
movsd  %xmm0,(%rbx,%r9,8)
movsd  (%r15,%rdi,1),%xmm0
movsd  %xmm0,(%r12)
add    %rdx,%r15
add    %rcx,%r12
add    %ebp,%r9d
add    $0xffffffffffffffff,%r8
jne    2c70 <radfg+0x1b50>
jmp    2c40 <radfg+0x1b20>
cmpl   $0x1,0x30(%rsp)
je     30f7 <radfg+0x1fd7>
mov    0x9c(%rsp),%eax
cmp    0x4(%rsp),%eax
jge    2eed <radfg+0x1dcd>
cmpb   $0x0,0x28(%rsp)
je     30f7 <radfg+0x1fd7>
mov    0x30(%rsp),%r8
movslq %r8d,%rdi
mov    0x58(%rsp),%rsi
movslq %esi,%rcx
mov    0x4(%rsp),%r9d
movslq %r9d,%rdx
mov    0x64(%rsp),%ebp
cmp    $0x3,%ebp
mov    $0x2,%eax
cmovge %ebp,%eax
mov    %rax,0x48(%rsp)
mov    %r9d,%eax
mov    %rax,0x10(%rsp)
lea    (%r8,%r8,1),%eax
mov    %eax,0x70(%rsp)
imul   %r8d,%esi
mov    %rsi,0x58(%rsp)
lea    (%r8,%r8,1),%eax
add    $0xfffffffd,%eax
mov    %eax,0x40(%rsp)
mov    %rdi,%rax
shl    $0x4,%rax
mov    %rax,0x80(%rsp)
add    %rbx,%rax
add    $0x10,%rax
mov    %rax,0x68(%rsp)
mov    %rcx,%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    $0xffffffffffffffff,%rcx
imul   %rdi,%rdx
imul   %rdx,%rcx
mov    0x8(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x50(%rsp)
lea    0x0(,%rdx,8),%rcx
mov    %rcx,0x90(%rsp)
neg    %rcx
mov    %rcx,0xa0(%rsp)
mov    %rdi,0x20(%rsp)
lea    0x0(,%rdi,8),%rcx
lea    (%rax,%rdx,8),%rax
add    $0x10,%rax
mov    %rax,0x38(%rsp)
mov    $0x1,%edx
mov    %r8d,%eax
mov    %r8d,0x18(%rsp)
mov    0x58(%rsp),%rdi
jmp    2df1 <radfg+0x1cd1>
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
mov    0x70(%rsp),%eax
add    %eax,0x18(%rsp)
add    %eax,0x40(%rsp)
mov    0x68(%rsp),%rax
add    0x80(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    0xa0(%rsp),%rax
add    %rax,0x50(%rsp)
mov    0x38(%rsp),%rax
add    0x90(%rsp),%rax
mov    %rax,0x38(%rsp)
cmp    0x48(%rsp),%rdx
je     30f7 <radfg+0x1fd7>
mov    %rdx,0x28(%rsp)
cmpl   $0x3,0x30(%rsp)
jl     2da0 <radfg+0x1c80>
mov    $0x2,%r14d
mov    0x38(%rsp),%r15
mov    0x50(%rsp),%r8
mov    0x68(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x40(%rsp),%r11d
jmp    2e41 <radfg+0x1d21>
xchg   %ax,%ax
add    $0x2,%r14
add    $0xfffffffe,%r11d
addq   $0x10,0x8(%rsp)
add    $0x10,%r8
add    $0x10,%r15
cmp    0x20(%rsp),%r14
jge    2da0 <radfg+0x1c80>
cmpl   $0x0,0x4(%rsp)
jle    2e20 <radfg+0x1d00>
mov    0x20(%rsp),%rbp
sub    %r14,%rbp
mov    0x10(%rsp),%rdx
xor    %r12d,%r12d
mov    0x8(%rsp),%r13
mov    %r11d,%r10d
mov    0x18(%rsp),%eax
mov    %eax,%r9d
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%r12,1),%xmm0
addsd  -0x8(%r8,%r12,1),%xmm0
movsd  %xmm0,-0x8(%r13)
movsd  -0x8(%r15,%r12,1),%xmm0
subsd  -0x8(%r8,%r12,1),%xmm0
movslq %r10d,%r10
movsd  %xmm0,(%rbx,%r10,8)
movsd  (%r15,%r12,1),%xmm0
addsd  (%r8,%r12,1),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r8,%r12,1),%xmm0
subsd  (%r15,%r12,1),%xmm0
movslq %r9d,%r9
lea    0x0(%rbp,%r9,1),%rbx
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    0x88(%rsp),%rbx
add    %edi,%r9d
add    %edi,%r10d
add    %rsi,%r13
add    %rcx,%r12
add    $0xffffffffffffffff,%rdx
jne    2e70 <radfg+0x1d50>
jmp    2e20 <radfg+0x1d00>
cmpb   $0x0,0x28(%rsp)
je     30f7 <radfg+0x1fd7>
mov    0x30(%rsp),%r9
movslq %r9d,%rax
mov    0x58(%rsp),%r11
movslq %r11d,%rsi
mov    0x4(%rsp),%ecx
movslq %ecx,%rbp
mov    0x64(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%edi
cmovge %edx,%edi
mov    %rdi,0x28(%rsp)
mov    %ecx,%edx
mov    %rax,%rcx
shl    $0x4,%rcx
mov    %rcx,0x40(%rsp)
add    %rbx,%rcx
mov    %rcx,0x20(%rsp)
mov    %rsi,%rcx
imul   %rax,%rcx
shl    $0x3,%rcx
add    $0xffffffffffffffff,%rsi
imul   %rax,%rbp
imul   %rbp,%rsi
mov    0x8(%rsp),%r10
lea    (%r10,%rsi,8),%rsi
mov    %rsi,0x10(%rsp)
lea    0x0(,%rbp,8),%rsi
mov    %rsi,0x50(%rsp)
neg    %rsi
mov    %rsi,0x48(%rsp)
lea    0x0(,%rax,8),%r8
lea    (%r10,%rbp,8),%rsi
mov    %rsi,0x8(%rsp)
lea    (%r9,%r9,1),%esi
mov    %esi,0x70(%rsp)
lea    (%r9,%r9,1),%esi
add    $0xfffffffd,%esi
mov    %esi,0x68(%rsp)
imul   %r9d,%r11d
mov    %r11,0x58(%rsp)
lea    -0x10(%rbx),%rsi
mov    %rsi,0x88(%rsp)
mov    $0x1,%edi
mov    %r9d,%esi
mov    %r9d,0x38(%rsp)
jmp    3008 <radfg+0x1ee8>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
add    $0x1,%rdi
mov    0x20(%rsp),%rsi
add    0x40(%rsp),%rsi
mov    %rsi,0x20(%rsp)
mov    0x48(%rsp),%rsi
add    %rsi,0x10(%rsp)
mov    0x8(%rsp),%rsi
add    0x50(%rsp),%rsi
mov    %rsi,0x8(%rsp)
mov    0x70(%rsp),%esi
add    %esi,0x68(%rsp)
add    %esi,0x38(%rsp)
cmp    0x28(%rsp),%rdi
je     30f7 <radfg+0x1fd7>
mov    %rdi,0x18(%rsp)
cmpl   $0x0,0x4(%rsp)
jle    2fc0 <radfg+0x1ea0>
mov    0x38(%rsp),%r10d
mov    0x68(%rsp),%esi
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%r12
mov    0x20(%rsp),%r14
xor    %r15d,%r15d
jmp    3060 <radfg+0x1f40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
add    %rcx,%r14
add    %r8,%r12
add    %r8,%r13
mov    0x58(%rsp),%rbp
add    %ebp,%esi
add    %ebp,%r10d
cmp    %rdx,%r15
je     2fc0 <radfg+0x1ea0>
cmpl   $0x3,0x30(%rsp)
jl     3040 <radfg+0x1f20>
movslq %r10d,%rbp
add    %rax,%rbp
mov    %rcx,%rdi
mov    %rdx,%rcx
mov    0x88(%rsp),%rdx
lea    (%rdx,%rbp,8),%rbp
mov    %rcx,%rdx
mov    %rdi,%rcx
mov    $0x2,%r11d
mov    %esi,%r9d
xchg   %ax,%ax
movsd  -0x8(%r13,%r11,8),%xmm0
addsd  -0x8(%r12,%r11,8),%xmm0
movsd  %xmm0,-0x8(%r14,%r11,8)
movsd  -0x8(%r13,%r11,8),%xmm0
subsd  -0x8(%r12,%r11,8),%xmm0
movslq %r9d,%r9
movsd  %xmm0,(%rbx,%r9,8)
movsd  0x0(%r13,%r11,8),%xmm0
addsd  (%r12,%r11,8),%xmm0
movsd  %xmm0,(%r14,%r11,8)
movsd  (%r12,%r11,8),%xmm0
subsd  0x0(%r13,%r11,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x2,%r11
add    $0xfffffffe,%r9d
add    $0xfffffffffffffff0,%rbp
cmp    %rax,%r11
jl     3090 <radfg+0x1f70>
jmp    3040 <radfg+0x1f20>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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