#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 */
float cos(float);
float sin(float);
void radfg(int ido, int ip, int l1, int idl1, float cc[], float ch[],
           const float wa[]) {
  static const float twopi = 6.28318530717959;
  int idij, ipph, i, j, k, l, j2, ic, jc, lc, ik, is, nbd;
  float 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    $0x80,%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)
cvtsi2ssl -0x8(%rbp),%xmm1
movss  0x1eb0(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
call   1040 <cos@plt>
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x78(%rbp)
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     1a2a <radfg+0x90a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11de <radfg+0xbe>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11aa <radfg+0x8a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    125d <radfg+0x13d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124a <radfg+0x12a>
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
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f8 <radfg+0xd8>
jmp    124f <radfg+0x12f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e5 <radfg+0xc5>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1428 <radfg+0x308>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1423 <radfg+0x303>
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    1410 <radfg+0x2f0>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13fd <radfg+0x2dd>
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%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
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %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
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%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
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b9 <radfg+0x199>
jmp    1402 <radfg+0x2e2>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    129d <radfg+0x17d>
jmp    1415 <radfg+0x2f5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1278 <radfg+0x158>
jmp    15e7 <radfg+0x4c7>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15e2 <radfg+0x4c2>
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    15cf <radfg+0x4af>
mov    -0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15bc <radfg+0x49c>
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
movss  (%rax,%rcx,4),%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
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%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
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %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
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%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
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    146f <radfg+0x34f>
jmp    15c1 <radfg+0x4a1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1453 <radfg+0x333>
jmp    15d4 <radfg+0x4b4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1437 <radfg+0x317>
jmp    15e7 <radfg+0x4c7>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     180c <radfg+0x6ec>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1807 <radfg+0x6e7>
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    17f4 <radfg+0x6d4>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17e1 <radfg+0x6c1>
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1629 <radfg+0x509>
jmp    17e6 <radfg+0x6c6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1616 <radfg+0x4f6>
jmp    17f9 <radfg+0x6d9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15fa <radfg+0x4da>
jmp    1a25 <radfg+0x905>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a20 <radfg+0x900>
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    1a0d <radfg+0x8ed>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19fa <radfg+0x8da>
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1842 <radfg+0x722>
jmp    19ff <radfg+0x8df>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    182f <radfg+0x70f>
jmp    1a12 <radfg+0x8f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1813 <radfg+0x6f3>
jmp    1a25 <radfg+0x905>
jmp    1a6a <radfg+0x94a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a65 <radfg+0x945>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a31 <radfg+0x911>
jmp    1a6a <radfg+0x94a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b62 <radfg+0xa42>
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    1b4f <radfg+0xa2f>
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a8d <radfg+0x96d>
jmp    1b54 <radfg+0xa34>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a71 <radfg+0x951>
movss  0x149a(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1df1 <radfg+0xcd1>
mov    -0x8(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c89 <radfg+0xb69>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%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
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1bf3 <radfg+0xad3>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1dde <radfg+0xcbe>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dcb <radfg+0xcab>
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d2d <radfg+0xc0d>
jmp    1dd0 <radfg+0xcb0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1cb8 <radfg+0xb98>
jmp    1de3 <radfg+0xcc3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1b7e <radfg+0xa5e>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e62 <radfg+0xd42>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e4f <radfg+0xd2f>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e0b <radfg+0xceb>
jmp    1e54 <radfg+0xd34>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1df8 <radfg+0xcd8>
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1eee <radfg+0xdce>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ee9 <radfg+0xdc9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ed6 <radfg+0xdb6>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e88 <radfg+0xd68>
jmp    1edb <radfg+0xdbb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e75 <radfg+0xd55>
jmp    1f6e <radfg+0xe4e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f69 <radfg+0xe49>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1f56 <radfg+0xe36>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f08 <radfg+0xde8>
jmp    1f5b <radfg+0xe3b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ef5 <radfg+0xdd5>
jmp    1f6e <radfg+0xe4e>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2042 <radfg+0xf22>
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    202f <radfg+0xf0f>
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
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f9a <radfg+0xe7a>
jmp    2034 <radfg+0xf14>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1f75 <radfg+0xe55>
cmpl   $0x1,-0x4(%rbp)
jne    2051 <radfg+0xf31>
jmp    24bf <radfg+0x139f>
mov    -0x54(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     228e <radfg+0x116e>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2289 <radfg+0x1169>
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    2276 <radfg+0x1156>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2263 <radfg+0x1143>
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    209c <radfg+0xf7c>
jmp    2268 <radfg+0x1148>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2089 <radfg+0xf69>
jmp    227b <radfg+0x115b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2064 <radfg+0xf44>
jmp    24bf <radfg+0x139f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    24ba <radfg+0x139a>
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    24a7 <radfg+0x1387>
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    2494 <radfg+0x1374>
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
addss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
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
movss  (%rax,%rcx,4),%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
subss  (%rax,%rcx,4),%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    22d6 <radfg+0x11b6>
jmp    2499 <radfg+0x1379>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    22ba <radfg+0x119a>
jmp    24ac <radfg+0x138c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2295 <radfg+0x1175>
jmp    24bf <radfg+0x139f>
add    $0x80,%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    %esi,%ebx
cvtsi2ss %esi,%xmm1
mov    %r9,0x8(%rsp)
mov    %r8,0x50(%rsp)
mov    %ecx,%r14d
mov    %edx,%r13d
mov    %edi,%r12d
movss  0x2eae(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x48(%rsp)
call   1040 <cos@plt>
movaps %xmm0,0x110(%rsp)
movss  0x48(%rsp),%xmm0
call   1030 <sin@plt>
lea    0x1(%rbx),%eax
shr    $0x1f,%eax
add    %ebx,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,0x6c(%rsp)
lea    -0x1(%r12),%eax
shr    $0x1f,%eax
add    %r12d,%eax
add    $0xffffffff,%eax
sar    %eax
mov    %eax,0xa4(%rsp)
cmp    $0x1,%r12d
mov    %rbx,0x60(%rsp)
mov    %r13d,0x14(%rsp)
mov    %r12,0x48(%rsp)
mov    %r14d,0x98(%rsp)
jne    128c <radfg+0x16c>
test   %r14d,%r14d
mov    0x50(%rsp),%rbx
movaps 0x110(%rsp),%xmm11
jle    1474 <radfg+0x354>
mov    %r14d,%eax
cmp    $0x8,%r14d
jb     11fc <radfg+0xdc>
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    136c <radfg+0x24c>
lea    (%rbx,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    136c <radfg+0x24c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1234 <radfg+0x114>
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1220 <radfg+0x100>
cmp    $0x3,%rdx
jb     1474 <radfg+0x354>
mov    0x8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbx,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x8(%rbx,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1250 <radfg+0x130>
jmp    1474 <radfg+0x354>
test   %r14d,%r14d
mov    0x50(%rsp),%rdx
mov    0x8(%rsp),%rsi
movaps 0x110(%rsp),%xmm11
jle    21bc <radfg+0x109c>
mov    %r14d,%eax
cmp    $0x8,%r14d
jb     12d0 <radfg+0x1b0>
mov    0x50(%rsp),%rbx
lea    (%rbx,%rax,4),%rcx
cmp    %rsi,%rcx
jbe    1392 <radfg+0x272>
lea    (%rsi,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    1392 <radfg+0x272>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1307 <radfg+0x1e7>
mov    0x50(%rsp),%rdi
mov    0x8(%rsp),%rbp
xchg   %ax,%ax
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    12f0 <radfg+0x1d0>
jmp    1311 <radfg+0x1f1>
mov    0x50(%rsp),%rdi
mov    0x8(%rsp),%rbp
cmp    $0x3,%rdx
mov    %rdi,%rdx
mov    0x60(%rsp),%rbx
jb     21bc <radfg+0x109c>
mov    %rbp,%rsi
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rsi,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x8(%rsi,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1330 <radfg+0x210>
jmp    21bc <radfg+0x109c>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    13bc <radfg+0x29c>
xor    %edi,%edi
jmp    1429 <radfg+0x309>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    2105 <radfg+0xfe5>
xor    %edi,%edi
jmp    2169 <radfg+0x1049>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
mov    0x8(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdi,4),%xmm1
movups 0x10(%rbp,%rdi,4),%xmm2
movups %xmm1,(%rbx,%rdi,4)
movups %xmm2,0x10(%rbx,%rdi,4)
movups 0x20(%rbp,%rdi,4),%xmm1
movups 0x30(%rbp,%rdi,4),%xmm2
movups %xmm1,0x20(%rbx,%rdi,4)
movups %xmm2,0x30(%rbx,%rdi,4)
movups 0x40(%rbp,%rdi,4),%xmm1
movups 0x50(%rbp,%rdi,4),%xmm2
movups %xmm1,0x40(%rbx,%rdi,4)
movups %xmm2,0x50(%rbx,%rdi,4)
movups 0x60(%rbp,%rdi,4),%xmm1
movups 0x70(%rbp,%rdi,4),%xmm2
movups %xmm1,0x60(%rbx,%rdi,4)
movups %xmm2,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13d0 <radfg+0x2b0>
test   %rdx,%rdx
je     146b <radfg+0x34b>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
mov    0x8(%rsp),%rbp
lea    0x10(,%rdi,4),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups %xmm1,-0x10(%rsi,%rbp,1)
movups %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1450 <radfg+0x330>
cmp    %rax,%rcx
jne    11fe <radfg+0xde>
mov    0x60(%rsp),%rax
cmp    $0x3,%eax
jl     153a <radfg+0x41a>
movslq %r12d,%r12
mov    %eax,%edx
mov    0x14(%rsp),%r13d
movslq %r13d,%rax
mov    0x6c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%r9d
cmovge %ecx,%r9d
mov    %r13d,%r8d
mov    %rdx,0xc0(%rsp)
lea    -0x1(%rdx),%rcx
imul   %r12,%rax
mov    %rcx,0xb0(%rsp)
imul   %rax,%rcx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rcx,4),%rsi
lea    0x0(,%rax,4),%r10
mov    %r10,%r11
neg    %r11
shl    $0x2,%r12
lea    (%rbx,%rcx,4),%rdx
lea    (%rdi,%rax,4),%rcx
lea    (%rbx,%rax,4),%rbp
mov    $0x1,%r15d
jmp    1505 <radfg+0x3e5>
xchg   %ax,%ax
add    $0x1,%r15
add    %r11,%rsi
add    %r11,%rdx
add    %r10,%rcx
add    %r10,%rbp
cmp    %r9,%r15
je     1547 <radfg+0x427>
test   %r13d,%r13d
jle    14f0 <radfg+0x3d0>
mov    %r8,%rdi
xor    %eax,%eax
nop
movss  (%rcx,%rax,1),%xmm1
addss  (%rsi,%rax,1),%xmm1
movss  %xmm1,0x0(%rbp,%rax,1)
movss  (%rsi,%rax,1),%xmm1
subss  (%rcx,%rax,1),%xmm1
movss  %xmm1,(%rdx,%rax,1)
add    %r12,%rax
add    $0xffffffffffffffff,%rdi
jne    1510 <radfg+0x3f0>
jmp    14f0 <radfg+0x3d0>
movl   $0x0,0x28(%rsp)
jmp    2006 <radfg+0xee6>
mov    0x60(%rsp),%rax
cmp    $0x3,%eax
jl     297e <radfg+0x185e>
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
xorps  0x2aab(%rip),%xmm0
add    $0xffffffff,%eax
imul   %r14d,%eax
movslq %r14d,%rdx
movslq %eax,%r8
mov    0x6c(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%r10d
cmovge %eax,%r10d
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %rcx,0x168(%rsp)
mov    %rbx,%rcx
mov    %rdx,%rbx
mov    %r14d,%r11d
mov    0xb0(%rsp),%rsi
imul   %rdx,%rsi
mov    0xc0(%rsp),%r15
lea    -0x2(%r15),%rbp
imul   %rdx,%rbp
lea    (%r8,%r11,1),%rax
lea    (%rcx,%rax,4),%rax
mov    %rax,0x148(%rsp)
shufps $0x0,%xmm11,%xmm11
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x108(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x130(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x128(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x120(%rsp)
lea    0x0(,%rdx,4),%r9
lea    -0x1(%r15),%rdx
imul   %rbx,%rdx
mov    %r9,%r12
neg    %r12
lea    -0x2(%r15),%rax
imul   %rbx,%rax
lea    (%rcx,%rax,4),%rax
mov    %rax,0x158(%rsp)
movss  0x29c6(%rip),%xmm2
movaps 0x29ca(%rip),%xmm8
lea    (%rbx,%r11,1),%rax
mov    %rsi,0xb0(%rsp)
add    %r11,%rsi
mov    %rsi,0x160(%rsp)
lea    (%rbx,%rbx,1),%rsi
mov    %rsi,0x110(%rsp)
lea    (%r11,%rbx,2),%rsi
mov    %rsi,0x180(%rsp)
mov    %rbp,0xa8(%rsp)
lea    0x0(%rbp,%r11,1),%rsi
mov    %rsi,0x178(%rsp)
lea    (%rcx,%r11,4),%rsi
mov    %rsi,0x140(%rsp)
lea    (%rcx,%rbx,4),%rsi
mov    %rsi,0xc8(%rsp)
mov    %rax,0xe0(%rsp)
lea    (%rcx,%rax,4),%rax
mov    %rax,0x138(%rsp)
mov    %r8,0xd8(%rsp)
lea    (%rcx,%r8,4),%rax
mov    %rax,0xd0(%rsp)
mov    0x8(%rsp),%rdi
lea    0x10(%rdi,%rbx,4),%rax
lea    0x10(%rdi,%rdx,4),%rsi
lea    (%rcx,%rbx,8),%rcx
mov    %rcx,0x150(%rsp)
lea    (%rdi,%rbx,4),%rcx
mov    %rdx,0xf0(%rsp)
lea    (%rdi,%rdx,4),%r15
mov    $0x1,%edx
mov    %rdx,0xb8(%rsp)
xor    %ebp,%ebp
mov    %rbx,0xe8(%rsp)
mov    %rbx,0x78(%rsp)
mov    %r10,0x90(%rsp)
mov    %r9,0x58(%rsp)
mov    %r12,0x70(%rsp)
jmp    178a <radfg+0x66a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xb8(%rsp),%rdx
add    $0x1,%rdx
mov    0x170(%rsp),%rbp
add    $0x1,%rbp
mov    0x100(%rsp),%rax
add    %r9,%rax
mov    0xf8(%rsp),%rsi
add    %r12,%rsi
sub    %rbx,0xf0(%rsp)
add    %rbx,0xe8(%rsp)
add    %r9,%rcx
add    %r12,%r15
mov    %rdx,0xb8(%rsp)
cmp    0x168(%rsp),%rdx
je     1dac <radfg+0xc8c>
mov    %rsi,0xf8(%rsp)
mov    %rax,0x100(%rsp)
mov    %rbp,0x170(%rsp)
mov    %rbp,%rax
imul   %rbx,%rax
lea    (%rax,%rbx,1),%r8
mov    0xe0(%rsp),%rdx
lea    (%rdx,%rax,1),%rsi
mov    0xb0(%rsp),%rbp
sub    %rax,%rbp
mov    0x160(%rsp),%rdx
sub    %rax,%rdx
lea    (%rdi,%r8,4),%rax
mov    %rax,0x20(%rsp)
lea    (%rdi,%rsi,4),%rax
mov    %rax,0x30(%rsp)
lea    (%rdi,%rbp,4),%rax
mov    %rax,0x28(%rsp)
lea    (%rdi,%rdx,4),%rax
mov    %rax,0x38(%rsp)
movaps %xmm9,%xmm3
shufps $0x11,%xmm2,%xmm3
shufps $0xe2,%xmm2,%xmm3
movaps %xmm0,%xmm4
unpcklps %xmm2,%xmm4
mulps  %xmm3,%xmm4
mulps  %xmm11,%xmm2
addps  %xmm4,%xmm2
movaps %xmm2,%xmm4
shufps $0x55,%xmm2,%xmm4
test   %r14d,%r14d
jle    18ae <radfg+0x78e>
cmp    $0x4,%r14d
jae    1b40 <radfg+0xa20>
xor    %r9d,%r9d
mov    0xf0(%rsp),%rax
add    %r9,%rax
lea    (%rdi,%rax,4),%r8
mov    0xd8(%rsp),%rax
lea    (%rax,%r9,1),%rax
mov    0x50(%rsp),%rdx
lea    (%rdx,%rax,4),%r12
mov    0xe8(%rsp),%rax
add    %r9,%rax
lea    (%rdi,%rax,4),%r13
lea    (%rbx,%r9,1),%rax
lea    (%rdx,%rax,4),%rax
lea    (%rdx,%r9,4),%rdx
mov    %r11,%rsi
sub    %r9,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rbp,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rdx,%rbp,4),%xmm3
movss  %xmm3,0x0(%r13,%rbp,4)
movss  (%r12,%rbp,4),%xmm3
mulss  %xmm4,%xmm3
movss  %xmm3,(%r8,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1880 <radfg+0x760>
cmpl   $0x5,0x60(%rsp)
mov    0x58(%rsp),%r9
mov    0x70(%rsp),%r12
jl     1730 <radfg+0x610>
xorps  %xmm8,%xmm4
movaps %xmm2,%xmm10
shufps $0x0,%xmm2,%xmm10
mov    0x38(%rsp),%rax
cmp    %rax,0x20(%rsp)
setb   %al
mov    0x28(%rsp),%rdx
cmp    0x30(%rsp),%rdx
setb   %dl
and    %al,%dl
mov    %dl,0x88(%rsp)
mov    $0x2,%r8d
mov    0x158(%rsp),%rdx
mov    0x150(%rsp),%r13
xor    %eax,%eax
movaps %xmm2,%xmm6
jmp    1927 <radfg+0x807>
add    $0x1,%r8
add    $0x1,%rax
add    %r9,%r13
add    %r12,%rdx
cmp    %r10,%r8
je     1730 <radfg+0x610>
movaps %xmm2,%xmm3
shufps $0x11,%xmm6,%xmm3
shufps $0xe2,%xmm6,%xmm3
movaps %xmm4,%xmm7
unpcklps %xmm6,%xmm7
mulps  %xmm3,%xmm7
mulps  %xmm10,%xmm6
addps  %xmm7,%xmm6
test   %r14d,%r14d
jle    1910 <radfg+0x7f0>
movaps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm7
cmp    $0x4,%r14d
jae    1960 <radfg+0x840>
xor    %ebp,%ebp
jmp    1b00 <radfg+0x9e0>
nopl   0x0(%rax,%rax,1)
mov    %rax,%rsi
imul   %rbx,%rsi
mov    0x110(%rsp),%rdi
lea    (%rdi,%rsi,1),%r10
mov    0x180(%rsp),%rdi
lea    (%rdi,%rsi,1),%r9
mov    0xa8(%rsp),%rbp
sub    %rsi,%rbp
mov    0x178(%rsp),%rdi
sub    %rsi,%rdi
mov    0x50(%rsp),%rsi
lea    (%rsi,%r10,4),%rbx
mov    %rbx,0x40(%rsp)
lea    (%rsi,%r9,4),%r14
lea    (%rsi,%rbp,4),%r9
lea    (%rsi,%rdi,4),%rdi
mov    0x20(%rsp),%rsi
cmp    %r14,%rsi
setb   %bpl
mov    0x30(%rsp),%r10
cmp    %r10,%rbx
setb   %r12b
and    %bpl,%r12b
or     0x88(%rsp),%r12b
cmp    %rdi,%rsi
setb   %bl
cmp    %r10,%r9
setb   0x18(%rsp)
mov    0x28(%rsp),%rsi
cmp    %r14,%rsi
setb   %r10b
mov    0x38(%rsp),%rbp
cmp    %rbp,0x40(%rsp)
setb   %r14b
cmp    %rdi,%rsi
setb   %sil
cmp    %rbp,%r9
setb   %r9b
test   %r12b,%r12b
jne    1ab2 <radfg+0x992>
and    0x18(%rsp),%bl
mov    0x8(%rsp),%rdi
mov    0x70(%rsp),%r12
jne    1ada <radfg+0x9ba>
and    %r14b,%r10b
mov    0x98(%rsp),%r14d
jne    1aae <radfg+0x98e>
mov    $0x0,%ebp
and    %r9b,%sil
mov    0x78(%rsp),%rbx
mov    0x58(%rsp),%r9
mov    0x90(%rsp),%r10
jne    1b00 <radfg+0x9e0>
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
xor    %esi,%esi
mov    0x108(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%r13,%rsi,4),%xmm1
mulps  %xmm3,%xmm1
movups (%rcx,%rsi,4),%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%rcx,%rsi,4)
movups (%rdx,%rsi,4),%xmm1
movups (%r15,%rsi,4),%xmm5
mulps  %xmm7,%xmm1
addps  %xmm5,%xmm1
movups %xmm1,(%r15,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1a70 <radfg+0x950>
mov    %rbp,%rsi
cmp    %r11,%rbp
jne    1b00 <radfg+0x9e0>
jmp    1910 <radfg+0x7f0>
xor    %ebp,%ebp
jmp    1ae4 <radfg+0x9c4>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdi
mov    0x98(%rsp),%r14d
mov    0x78(%rsp),%rbx
mov    0x58(%rsp),%r9
mov    0x90(%rsp),%r10
mov    0x70(%rsp),%r12
jmp    1b00 <radfg+0x9e0>
xor    %ebp,%ebp
mov    0x98(%rsp),%r14d
mov    0x78(%rsp),%rbx
mov    0x58(%rsp),%r9
mov    0x90(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%rbp,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%rcx,%rbp,4),%xmm1
movss  %xmm1,(%rcx,%rbp,4)
movss  (%rdx,%rbp,4),%xmm1
mulss  %xmm7,%xmm1
addss  (%r15,%rbp,4),%xmm1
movss  %xmm1,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1b00 <radfg+0x9e0>
jmp    1910 <radfg+0x7f0>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    0x38(%rsp),%r10
cmp    %r10,%rax
setb   0x40(%rsp)
mov    0x30(%rsp),%r9
mov    0x28(%rsp),%r12
cmp    %r9,%r12
setb   0x18(%rsp)
mov    0x140(%rsp),%rbp
cmp    %rbp,%rax
setb   %bl
mov    0x50(%rsp),%rdi
cmp    %rdi,%r9
seta   0x88(%rsp)
mov    0x138(%rsp),%r13
cmp    %r13,%rax
setb   0x87(%rsp)
mov    0xc8(%rsp),%rdx
cmp    %r9,%rdx
setb   0x86(%rsp)
mov    0x148(%rsp),%rsi
cmp    %rsi,%rax
setb   %al
mov    0xd0(%rsp),%r8
cmp    %r9,%r8
setb   %r9b
cmp    %rbp,%r12
setb   %bpl
cmp    %rdi,%r10
seta   %dil
cmp    %r13,%r12
setb   %r13b
cmp    %r10,%rdx
setb   0x85(%rsp)
cmp    %rsi,%r12
setb   %r12b
cmp    %r10,%r8
setb   %sil
mov    0x18(%rsp),%dl
test   %dl,0x40(%rsp)
jne    1d92 <radfg+0xc72>
mov    %edi,%r8d
and    0x88(%rsp),%bl
mov    0x8(%rsp),%rdi
mov    0x78(%rsp),%rbx
mov    0x90(%rsp),%r10
jne    1829 <radfg+0x709>
mov    0x86(%rsp),%dl
and    %dl,0x87(%rsp)
jne    1829 <radfg+0x709>
and    %r9b,%al
jne    1829 <radfg+0x709>
and    %r8b,%bpl
jne    1829 <radfg+0x709>
and    0x85(%rsp),%r13b
jne    1829 <radfg+0x709>
mov    $0x0,%r9d
and    %sil,%r12b
jne    182c <radfg+0x70c>
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
cmpq   $0x0,0x130(%rsp)
mov    0xd0(%rsp),%r8
mov    0x100(%rsp),%r9
mov    0xf8(%rsp),%r12
je     1d80 <radfg+0xc60>
mov    0x120(%rsp),%rdx
xor    %eax,%eax
mov    0x50(%rsp),%rsi
mov    0xc8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm3
movups 0x0(%rbp,%rax,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,-0x10(%r9,%rax,4)
movups (%r8,%rax,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,-0x10(%r12,%rax,4)
movups 0x10(%rsi,%rax,4),%xmm3
movups 0x10(%rbp,%rax,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,(%r9,%rax,4)
movups 0x10(%r8,%rax,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,(%r12,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1cb0 <radfg+0xb90>
testb  $0x1,0x128(%rsp)
01
je     1d67 <radfg+0xc47>
mov    0xc0(%rsp),%rdx
mov    0xb8(%rsp),%rsi
sub    %rsi,%rdx
imul   %rbx,%rsi
imul   %rbx,%rdx
mov    0x50(%rsp),%rdi
movups (%rdi,%rax,4),%xmm3
lea    (%rax,%rbx,1),%rbp
movups (%rdi,%rbp,4),%xmm6
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
add    %rax,%rsi
mov    0x8(%rsp),%rbp
movups %xmm5,0x0(%rbp,%rsi,4)
mov    0xd8(%rsp),%rsi
add    %rax,%rsi
movups (%rdi,%rsi,4),%xmm3
mov    0x8(%rsp),%rdi
mulps  %xmm4,%xmm3
add    %rax,%rdx
movups %xmm3,(%rdi,%rdx,4)
mov    0x108(%rsp),%rax
mov    %rax,%r9
cmp    %r11,%rax
jne    182c <radfg+0x70c>
jmp    18ae <radfg+0x78e>
xor    %eax,%eax
testb  $0x1,0x128(%rsp)
01
jne    1d0a <radfg+0xbea>
jmp    1d67 <radfg+0xc47>
xor    %r9d,%r9d
mov    0x8(%rsp),%rdi
mov    0x78(%rsp),%rbx
mov    0x90(%rsp),%r10
jmp    182c <radfg+0x70c>
mov    0x6c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r13d
cmovge %eax,%r13d
lea    (%rdi,%r11,4),%rax
mov    %rax,0x18(%rsp)
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0x28(%rsp)
and    %rax,%rdx
mov    %rdx,0x38(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x40(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rbx,4),%rsi
add    $0x30,%rsi
mov    %rbx,%r10
lea    (%rax,%rbx,4),%rbp
add    $0x4,%rbp
mov    $0x1,%edx
xor    %r15d,%r15d
mov    0x48(%rsp),%r12
jmp    1e57 <radfg+0xd37>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
add    $0x1,%r15
add    %r9,%rsi
add    %r9,%rbp
cmp    %r13,%rdx
je     2000 <radfg+0xee0>
test   %r14d,%r14d
jle    1e40 <radfg+0xd20>
mov    %rdx,%r8
imul   %r10,%r8
cmp    $0x8,%r14d
jae    1e70 <radfg+0xd50>
xor    %ecx,%ecx
jmp    1f90 <radfg+0xe70>
mov    %r10,%rbx
mov    %r15,%rax
imul   %r10,%rax
mov    0xe0(%rsp),%rcx
add    %rax,%rcx
mov    %rdi,%r9
mov    0x50(%rsp),%rdi
lea    (%rdi,%rcx,4),%rcx
cmp    %r9,%rcx
jbe    1eb5 <radfg+0xd95>
add    %rbx,%rax
lea    (%rdi,%rax,4),%rax
cmp    0x18(%rsp),%rax
jae    1eb5 <radfg+0xd95>
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    0x58(%rsp),%r9
jmp    1f90 <radfg+0xe70>
cmpq   $0x0,0x30(%rsp)
je     1f2d <radfg+0xe0d>
mov    0x38(%rsp),%r10
xor    %r9d,%r9d
mov    0x8(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%r9,4),%xmm0
movups -0x20(%rsi,%r9,4),%xmm1
movups (%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%r9,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rdi,%r9,4),%xmm1
movups 0x30(%rdi,%r9,4),%xmm3
movups %xmm2,(%rdi,%r9,4)
movups %xmm0,0x10(%rdi,%r9,4)
movups -0x10(%rsi,%r9,4),%xmm0
addps  %xmm1,%xmm0
movups (%rsi,%r9,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rdi,%r9,4)
movups %xmm1,0x30(%rdi,%r9,4)
add    $0x10,%r9
add    $0xfffffffffffffffe,%r10
jne    1ed0 <radfg+0xdb0>
jmp    1f35 <radfg+0xe15>
xor    %r9d,%r9d
mov    0x8(%rsp),%rdi
testb  $0x1,0x28(%rsp)
mov    0x78(%rsp),%r10
je     1f6f <radfg+0xe4f>
lea    (%r9,%r8,1),%rax
mov    0x50(%rsp),%rcx
movups (%rcx,%rax,4),%xmm0
movups 0x10(%rcx,%rax,4),%xmm1
movups (%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%r9,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdi,%r9,4)
movups %xmm0,0x10(%rdi,%r9,4)
mov    0x20(%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
mov    0x58(%rsp),%r9
je     1e40 <radfg+0xd20>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,%rax
test   $0x1,%r11b
je     1fb8 <radfg+0xe98>
add    %rcx,%r8
mov    0x50(%rsp),%rax
movss  (%rax,%r8,4),%xmm0
addss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x40(%rsp),%rcx
je     1e40 <radfg+0xd20>
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rbp,%rax,4),%xmm0
addss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  0x0(%rbp,%rax,4),%xmm0
addss  0x4(%rdi,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1fd0 <radfg+0xeb0>
jmp    1e40 <radfg+0xd20>
mov    $0x1,%al
mov    %eax,0x28(%rsp)
mov    0x14(%rsp),%r13d
cmp    %r13d,%r12d
jge    2994 <radfg+0x1874>
test   %r12d,%r12d
jle    2c0f <radfg+0x1aef>
mov    0x60(%rsp),%r10
mov    0x48(%rsp),%rax
imul   %eax,%r10d
mov    %eax,%ecx
mov    0x14(%rsp),%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    0x0(,%rcx,8),%r15
lea    (%r10,%r10,1),%r14d
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x50(%rsp),%rbx
jmp    2071 <radfg+0xf51>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    $0x4,%r9
cmp    %rcx,%rdx
je     2c0f <radfg+0x1aef>
cmpl   $0x0,0x14(%rsp)
jle    2060 <radfg+0xf40>
cmpl   $0x1,0x14(%rsp)
jne    2090 <radfg+0xf70>
xor    %eax,%eax
jmp    20d3 <radfg+0xfb3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
mov    %r9,%rdi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  (%rdi),%xmm0
movslq %esi,%rsi
lea    (%rdx,%rsi,1),%rbp
movss  %xmm0,(%rbx,%rbp,4)
movss  (%rdi,%rcx,4),%xmm0
lea    (%r10,%rsi,1),%ebp
movslq %ebp,%rbp
add    %rdx,%rbp
movss  %xmm0,(%rbx,%rbp,4)
add    $0x2,%rax
add    %r15,%rdi
add    %r14d,%esi
cmp    %rax,%r11
jne    20a0 <radfg+0xf80>
test   $0x1,%r8b
je     2060 <radfg+0xf40>
mov    %rax,%rsi
imul   %rcx,%rsi
add    %rdx,%rsi
mov    0x8(%rsp),%rdi
movss  (%rdi,%rsi,4),%xmm0
imul   %r10d,%eax
cltq
add    %rdx,%rax
mov    0x50(%rsp),%rsi
movss  %xmm0,(%rsi,%rax,4)
jmp    2060 <radfg+0xf40>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
mov    0x8(%rsp),%rbp
movups (%rbx,%rdi,4),%xmm1
movups 0x10(%rbx,%rdi,4),%xmm2
movups %xmm1,0x0(%rbp,%rdi,4)
movups %xmm2,0x10(%rbp,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm1
movups 0x30(%rbx,%rdi,4),%xmm2
movups %xmm1,0x20(%rbp,%rdi,4)
movups %xmm2,0x30(%rbp,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm1
movups 0x50(%rbx,%rdi,4),%xmm2
movups %xmm1,0x40(%rbp,%rdi,4)
movups %xmm2,0x50(%rbp,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm1
movups 0x70(%rbx,%rdi,4),%xmm2
movups %xmm1,0x60(%rbp,%rdi,4)
movups %xmm2,0x70(%rbp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2110 <radfg+0xff0>
test   %rdx,%rdx
je     21ab <radfg+0x108b>
mov    0x8(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups %xmm1,-0x10(%rsi,%rbp,1)
movups %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    2190 <radfg+0x1070>
cmp    %rax,%rcx
mov    %rbx,%rdx
mov    0x60(%rsp),%rbx
jne    12d2 <radfg+0x1b2>
cmp    $0x2,%ebx
mov    %rdx,%rbx
jl     266a <radfg+0x154a>
movslq 0x48(%rsp),%rax
movslq %r13d,%rbp
mov    %ebp,%r14d
mov    %r14d,%ecx
and    $0x3,%ecx
mov    %rcx,0x38(%rsp)
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x90(%rsp)
lea    0x2(%rbp),%rcx
imul   %rax,%rcx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rcx,4),%rdx
mov    %rdx,0xa8(%rsp)
mov    %rbp,%rdx
imul   %rax,%rdx
lea    0x0(,%rdx,4),%rsi
mov    %rsi,0x70(%rsp)
mov    %rax,%r12
shl    $0x4,%r12
lea    (%rbx,%rcx,4),%rcx
lea    0x1(%rbp),%rsi
imul   %rax,%rsi
lea    (%rdi,%rsi,4),%r10
lea    (%rbx,%rsi,4),%r15
lea    0x3(%rbp),%rsi
imul   %rax,%rsi
lea    (%rdi,%rsi,4),%r11
lea    (%rbx,%rsi,4),%r9
lea    (%rbx,%rdx,4),%r8
lea    (%rdi,%rdx,4),%r13
mov    0x1c0(%rsp),%rdx
mov    0x60(%rsp),%esi
mov    %rsi,0x28(%rsp)
mov    %r14,0x40(%rsp)
lea    -0x1(%r14),%rsi
mov    %rsi,0x88(%rsp)
lea    0x0(,%rax,4),%r14
mov    $0x1,%esi
xor    %edi,%edi
mov    %rdi,0x20(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r14,0x78(%rsp)
jmp    22d2 <radfg+0x11b2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x30(%rsp),%rsi
add    $0x1,%rsi
mov    0x20(%rsp),%rdi
add    0x70(%rsp),%rdi
mov    %rdi,0x20(%rsp)
mov    0x18(%rsp),%rdi
add    0x58(%rsp),%rdi
mov    %rdi,0x18(%rsp)
cmp    0x28(%rsp),%rsi
je     2388 <radfg+0x1268>
mov    %rsi,0x30(%rsp)
cmpl   $0x0,0x14(%rsp)
jle    22a0 <radfg+0x1180>
cmpq   $0x3,0x88(%rsp)
jae    22f0 <radfg+0x11d0>
xor    %esi,%esi
jmp    234c <radfg+0x122c>
nopl   (%rax)
mov    0x20(%rsp),%rbp
xor    %esi,%esi
mov    0x90(%rsp),%rdi
mov    0xa8(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movss  (%r8,%rbp,1),%xmm1
movss  %xmm1,0x0(%r13,%rbp,1)
movss  (%r15,%rbp,1),%xmm1
movss  %xmm1,(%r10,%rbp,1)
movss  (%rcx,%rbp,1),%xmm1
movss  %xmm1,(%r14,%rbp,1)
movss  (%r9,%rbp,1),%xmm1
movss  %xmm1,(%r11,%rbp,1)
add    $0x4,%rsi
add    %r12,%rbp
cmp    %rsi,%rdi
jne    2310 <radfg+0x11f0>
cmpq   $0x0,0x38(%rsp)
mov    0x8(%rsp),%rdi
mov    0x78(%rsp),%r14
je     22a0 <radfg+0x1180>
add    0x18(%rsp),%rsi
imul   %r14,%rsi
mov    0x38(%rsp),%rbp
movss  (%rbx,%rsi,1),%xmm1
movss  %xmm1,(%rdi,%rsi,1)
add    %r14,%rsi
add    $0xffffffffffffffff,%rbp
jne    2370 <radfg+0x1250>
jmp    22a0 <radfg+0x1180>
mov    0x14(%rsp),%r13d
cmp    %r13d,0xa4(%rsp)
jle    251c <radfg+0x13fc>
cmpl   $0x2,0x60(%rsp)
jl     266a <radfg+0x154a>
movslq %r13d,%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rdi
mov    %rcx,0x88(%rsp)
add    %rcx,%rdi
mov    %rdi,0x18(%rsp)
mov    %rax,%r12
shl    $0x20,%r12
lea    (%rbx,%rsi,4),%rcx
mov    %rcx,0x38(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x58(%rsp)
shl    $0x2,%rsi
mov    %rsi,0x70(%rsp)
movl   $0xffffffff,0x20(%rsp)
ff
mov    $0x1,%esi
movabs $0x200000000,%r9
mov    0x8(%rsp),%rdi
jmp    2466 <radfg+0x1346>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x30(%rsp),%rsi
add    $0x1,%rsi
mov    0x20(%rsp),%ecx
add    0x48(%rsp),%ecx
mov    %ecx,0x20(%rsp)
mov    0x18(%rsp),%rcx
add    0x88(%rsp),%rcx
mov    %rcx,0x18(%rsp)
mov    0x70(%rsp),%rcx
add    %rcx,0x38(%rsp)
add    %rcx,0x58(%rsp)
cmp    0x28(%rsp),%rsi
mov    0x14(%rsp),%r13d
je     266a <radfg+0x154a>
mov    %rsi,0x30(%rsp)
test   %r13d,%r13d
jle    2420 <radfg+0x1300>
movslq 0x20(%rsp),%rcx
lea    (%rdx,%rcx,4),%rcx
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%r15
mov    0x18(%rsp),%r10
xor    %r13d,%r13d
jmp    24a8 <radfg+0x1388>
nopl   (%rax)
add    $0x1,%r13
add    %r12,%r10
add    %r14,%r15
add    %r14,%rbp
cmp    0x40(%rsp),%r13
je     2420 <radfg+0x1300>
cmpl   $0x3,0x48(%rsp)
jl     2490 <radfg+0x1370>
mov    $0x2,%r8d
mov    %r10,%r11
nopl   0x0(%rax,%rax,1)
mov    %r11,%rsi
sar    $0x1e,%rsi
movss  (%rcx,%r8,4),%xmm1
mulss  (%r15,%r8,4),%xmm1
movss  -0x4(%rcx,%r8,4),%xmm2
mulss  (%rbx,%rsi,1),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rsi,1)
movss  (%rbx,%rsi,1),%xmm1
mulss  (%rcx,%r8,4),%xmm1
movss  -0x4(%rcx,%r8,4),%xmm2
mulss  (%r15,%r8,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,0x0(%rbp,%r8,4)
add    $0x2,%r8
add    %r9,%r11
cmp    %rax,%r8
jl     24c0 <radfg+0x13a0>
jmp    2490 <radfg+0x1370>
cmpl   $0x2,0x60(%rsp)
jl     266a <radfg+0x154a>
movslq %r13d,%rsi
mov    %r13d,%ecx
imul   0x48(%rsp),%ecx
mov    %rcx,0x70(%rsp)
add    $0x1,%ecx
mov    %ecx,0x18(%rsp)
imul   %rax,%rsi
lea    (%rbx,%rsi,4),%rcx
mov    %rcx,0x20(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x30(%rsp)
shl    $0x2,%rsi
mov    %rsi,0x58(%rsp)
movl   $0xffffffff,0x38(%rsp)
ff
mov    $0x1,%r12d
mov    0x48(%rsp),%rdi
mov    0x8(%rsp),%r14
jmp    25ae <radfg+0x148e>
nopl   0x0(%rax)
add    $0x1,%r12
add    %edi,0x38(%rsp)
mov    0x18(%rsp),%ecx
add    0x70(%rsp),%ecx
mov    %ecx,0x18(%rsp)
mov    0x58(%rsp),%rcx
add    %rcx,0x20(%rsp)
add    %rcx,0x30(%rsp)
cmp    0x28(%rsp),%r12
je     266a <radfg+0x154a>
cmp    $0x3,%edi
jl     2580 <radfg+0x1460>
movslq 0x38(%rsp),%r9
mov    $0x2,%ebp
mov    0x30(%rsp),%rsi
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%r11d
jmp    25ed <radfg+0x14cd>
xchg   %ax,%ax
add    $0x2,%rbp
add    $0x2,%r11d
add    $0x8,%rcx
add    $0x8,%rsi
mov    %r8,%r9
cmp    %rax,%rbp
mov    0x14(%rsp),%r13d
jge    2580 <radfg+0x1460>
lea    0x2(%r9),%r8
test   %r13d,%r13d
jle    25d0 <radfg+0x14b0>
mov    $0x2,%r15d
mov    0x40(%rsp),%r10
mov    %r11d,%r13d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%rdx,%r9,4),%xmm1
movss  (%rdx,%r8,4),%xmm2
mulss  (%rcx,%r15,4),%xmm2
movslq %r13d,%r13
mulss  (%rbx,%r13,4),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%r14,%r13,4)
movss  (%rbx,%r13,4),%xmm1
mulss  (%rdx,%r8,4),%xmm1
movss  0x4(%rdx,%r9,4),%xmm2
mulss  (%rcx,%r15,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%r15,4)
add    %edi,%r13d
add    %rax,%r15
add    $0xffffffffffffffff,%r10
jne    2610 <radfg+0x14f0>
jmp    25d0 <radfg+0x14b0>
cmp    %r13d,0xa4(%rsp)
jge    27fe <radfg+0x16de>
mov    0x60(%rsp),%rcx
cmp    $0x3,%ecx
mov    0x98(%rsp),%r14d
jl     297e <radfg+0x185e>
mov    0x48(%rsp),%r12
movslq %r12d,%rax
mov    %ecx,%edx
movslq %r13d,%rsi
mov    0x6c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edi
cmovge %ecx,%edi
mov    %rdi,0x30(%rsp)
mov    %r13d,%r10d
add    $0xffffffffffffffff,%rdx
imul   %rax,%rsi
imul   %rsi,%rdx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rdx,4),%rcx
add    $0x8,%rcx
mov    %rcx,0x40(%rsp)
lea    0x0(,%rsi,4),%rcx
mov    %rcx,0x28(%rsp)
neg    %rcx
mov    %rcx,0x38(%rsp)
lea    0x0(,%rax,4),%rcx
lea    (%rbx,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0x18(%rsp)
lea    0x8(%rdi,%rsi,4),%rdx
mov    %rdx,0x20(%rsp)
lea    (%rbx,%rsi,4),%r8
add    $0x8,%r8
mov    $0x1,%ebp
jmp    274b <radfg+0x162b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
mov    0x38(%rsp),%rdx
add    %rdx,0x40(%rsp)
add    %rdx,0x18(%rsp)
mov    0x28(%rsp),%rdx
add    %rdx,0x20(%rsp)
add    %rdx,%r8
cmp    0x30(%rsp),%rbp
je     1474 <radfg+0x354>
cmp    $0x3,%r12d
jl     2720 <radfg+0x1600>
mov    $0x2,%edi
mov    %r8,%rsi
mov    0x20(%rsp),%r13
mov    0x18(%rsp),%r15
mov    0x40(%rsp),%r11
jmp    2789 <radfg+0x1669>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rdi
add    $0x8,%r11
add    $0x8,%r15
add    $0x8,%r13
add    $0x8,%rsi
cmp    %rax,%rdi
jge    2720 <radfg+0x1600>
cmpl   $0x0,0x14(%rsp)
jle    2770 <radfg+0x1650>
mov    %r10,%rdx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%r13,%r9,1),%xmm1
addss  -0x4(%r11,%r9,1),%xmm1
movss  %xmm1,-0x4(%rsi,%r9,1)
movss  0x0(%r13,%r9,1),%xmm1
subss  (%r11,%r9,1),%xmm1
movss  %xmm1,-0x4(%r15,%r9,1)
movss  0x0(%r13,%r9,1),%xmm1
addss  (%r11,%r9,1),%xmm1
movss  %xmm1,(%rsi,%r9,1)
movss  -0x4(%r11,%r9,1),%xmm1
subss  -0x4(%r13,%r9,1),%xmm1
movss  %xmm1,(%r15,%r9,1)
add    %rcx,%r9
add    $0xffffffffffffffff,%rdx
jne    27a0 <radfg+0x1680>
jmp    2770 <radfg+0x1650>
mov    0x60(%rsp),%rcx
cmp    $0x3,%ecx
mov    0x98(%rsp),%r14d
jl     297e <radfg+0x185e>
mov    0x48(%rsp),%r12
movslq %r12d,%rax
mov    %ecx,%esi
movslq %r13d,%rdi
mov    0x6c(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %rdx,0x20(%rsp)
mov    %r13d,%edx
add    $0xffffffffffffffff,%rsi
imul   %rax,%rdi
imul   %rdi,%rsi
mov    0x8(%rsp),%rbp
lea    0x0(,%rsi,4),%rcx
add    %rbp,%rcx
mov    %rcx,0x40(%rsp)
lea    0x0(,%rdi,4),%rcx
mov    %rcx,0x30(%rsp)
neg    %rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%rax,4),%rcx
lea    (%rbx,%rsi,4),%rsi
mov    %rsi,0x18(%rsp)
lea    0x0(,%rdi,4),%r8
add    %rbp,%r8
lea    (%rbx,%rdi,4),%rdi
mov    $0x1,%ebp
jmp    28c9 <radfg+0x17a9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
mov    0x28(%rsp),%rsi
add    %rsi,0x40(%rsp)
add    %rsi,0x18(%rsp)
mov    0x30(%rsp),%rsi
add    %rsi,%r8
add    %rsi,%rdi
cmp    0x20(%rsp),%rbp
je     1474 <radfg+0x354>
cmpl   $0x0,0x14(%rsp)
jle    28a0 <radfg+0x1780>
mov    %rdi,%rsi
mov    %r8,%r13
mov    0x18(%rsp),%r15
mov    0x40(%rsp),%r11
xor    %r10d,%r10d
jmp    2905 <radfg+0x17e5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10
add    %rcx,%r11
add    %rcx,%r15
add    %rcx,%r13
add    %rcx,%rsi
cmp    %rdx,%r10
je     28a0 <radfg+0x1780>
cmp    $0x3,%r12d
jl     28f0 <radfg+0x17d0>
mov    $0x2,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r13,%r9,4),%xmm1
addss  -0x4(%r11,%r9,4),%xmm1
movss  %xmm1,-0x4(%rsi,%r9,4)
movss  0x0(%r13,%r9,4),%xmm1
subss  (%r11,%r9,4),%xmm1
movss  %xmm1,-0x4(%r15,%r9,4)
movss  0x0(%r13,%r9,4),%xmm1
addss  (%r11,%r9,4),%xmm1
movss  %xmm1,(%rsi,%r9,4)
movss  -0x4(%r11,%r9,4),%xmm1
subss  -0x4(%r13,%r9,4),%xmm1
movss  %xmm1,(%r15,%r9,4)
add    $0x2,%r9
cmp    %rax,%r9
jl     2920 <radfg+0x1800>
jmp    28f0 <radfg+0x17d0>
movl   $0x0,0x28(%rsp)
mov    0x48(%rsp),%r12
cmp    %r13d,%r12d
jl     2014 <radfg+0xef4>
test   %r13d,%r13d
jle    2c0f <radfg+0x1aef>
mov    0x60(%rsp),%rax
mov    %eax,%r12d
mov    0x48(%rsp),%rax
imul   %eax,%r12d
movslq %eax,%rcx
mov    0x14(%rsp),%r13d
mov    %eax,%edi
mov    0x50(%rsp),%rax
lea    (%rax,%rdi,4),%rdx
mov    %rdx,0x30(%rsp)
mov    %edi,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x38(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x58(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
mov    %rdx,%rsi
mov    %rdx,0x70(%rsp)
and    %rdx,%rbp
mov    %rbp,0x78(%rsp)
mov    %edi,%r14d
and    $0x3,%r14d
mov    0x8(%rsp),%rbp
lea    0x30(%rbp),%r8
mov    %rcx,0x40(%rsp)
lea    0x0(,%rcx,4),%r10
lea    0x30(%rax),%rcx
mov    %rcx,0x88(%rsp)
add    $0xc,%rax
mov    %rax,0x20(%rsp)
xor    %r15d,%r15d
xor    %r9d,%r9d
mov    %r14,0x18(%rsp)
mov    0x50(%rsp),%rbx
jmp    2a66 <radfg+0x1946>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    %r10,%r8
add    %r12d,%r15d
add    %r10,%rbp
cmp    %r13,%r9
je     2c0f <radfg+0x1aef>
cmpl   $0x0,0x48(%rsp)
jle    2a50 <radfg+0x1930>
movslq %r15d,%r11
cmpl   $0x8,0x48(%rsp)
jae    2a80 <radfg+0x1960>
xor    %eax,%eax
jmp    2b70 <radfg+0x1a50>
xchg   %ax,%ax
mov    %r13,%r14
mov    %r12d,%eax
imul   %r9d,%eax
mov    %r9,%r13
imul   0x40(%rsp),%r13
lea    (%rdi,%r13,1),%rcx
cltq
lea    (%rbx,%rax,4),%rdx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
cmp    %rcx,%rdx
jae    2acc <radfg+0x19ac>
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
lea    (%rsi,%r13,4),%rcx
cmp    %rax,%rcx
jae    2acc <radfg+0x19ac>
xor    %eax,%eax
mov    %r14,%r13
mov    0x18(%rsp),%r14
jmp    2b70 <radfg+0x1a50>
cmpq   $0x0,0x58(%rsp)
je     2bfd <radfg+0x1add>
mov    0x88(%rsp),%rax
lea    (%rax,%r11,4),%rsi
mov    0x78(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x30(%r8,%rax,4),%xmm0
movups -0x20(%r8,%rax,4),%xmm1
movups %xmm0,-0x30(%rsi,%rax,4)
movups %xmm1,-0x20(%rsi,%rax,4)
movups -0x10(%r8,%rax,4),%xmm0
movups (%r8,%rax,4),%xmm1
movups %xmm0,-0x10(%rsi,%rax,4)
movups %xmm1,(%rsi,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    2af0 <radfg+0x19d0>
testb  $0x1,0x70(%rsp)
je     2b54 <radfg+0x1a34>
mov    %r12d,%ecx
imul   %r9d,%ecx
movslq %ecx,%rcx
add    %rax,%r13
mov    0x8(%rsp),%rdx
movups (%rdx,%r13,4),%xmm0
movups 0x10(%rdx,%r13,4),%xmm1
add    %rax,%rcx
movups %xmm0,(%rbx,%rcx,4)
movups %xmm1,0x10(%rbx,%rcx,4)
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
mov    %r14,%r13
mov    0x18(%rsp),%r14
je     2a50 <radfg+0x1930>
nopl   (%rax)
mov    %rax,%rsi
not    %rsi
add    %rdi,%rsi
test   %r14,%r14
je     2ba5 <radfg+0x1a85>
lea    (%rbx,%r11,4),%rdx
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    2b90 <radfg+0x1a70>
cmp    $0x3,%rsi
jb     2a50 <radfg+0x1930>
mov    0x20(%rsp),%rcx
lea    (%rcx,%r11,4),%rdx
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rax,4)
movss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rax,4)
movss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdi
jne    2bc0 <radfg+0x1aa0>
jmp    2a50 <radfg+0x1930>
xor    %eax,%eax
testb  $0x1,0x70(%rsp)
jne    2b2b <radfg+0x1a0b>
jmp    2b54 <radfg+0x1a34>
cmpb   $0x0,0x28(%rsp)
mov    0x50(%rsp),%rbx
je     2cfc <radfg+0x1bdc>
mov    0x48(%rsp),%rdx
movslq %edx,%r14
mov    0x60(%rsp),%rsi
movslq %esi,%rcx
mov    0x6c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edi
cmovge %eax,%edi
mov    %rdi,0x40(%rsp)
mov    0x14(%rsp),%eax
movslq %eax,%r8
mov    %eax,%eax
mov    %rax,0x20(%rsp)
lea    -0x1(%rcx),%rbp
imul   %r14,%r8
imul   %r8,%rbp
shl    $0x2,%rbp
shl    $0x2,%r8
lea    0x0(,%r14,4),%rdi
lea    (%rbx,%r14,8),%r11
imul   %r14,%rcx
shl    $0x3,%r14
shl    $0x2,%rcx
lea    (%rdx,%rdx,1),%eax
mov    %eax,0x18(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0xffffffff,%eax
imul   %edx,%esi
mov    $0x1,%edx
mov    %r8,%r15
jmp    2cb8 <radfg+0x1b98>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
sub    %r8,%rbp
add    %r14,%r11
add    0x18(%rsp),%eax
add    %r8,%r15
cmp    0x40(%rsp),%rdx
je     2cfc <radfg+0x1bdc>
cmpl   $0x0,0x14(%rsp)
jle    2ca0 <radfg+0x1b80>
mov    0x20(%rsp),%r9
mov    %eax,%r10d
mov    %r11,%r13
mov    0x8(%rsp),%r12
nop
movss  (%r12,%r15,1),%xmm0
movslq %r10d,%r10
movss  %xmm0,(%rbx,%r10,4)
movss  (%r12,%rbp,1),%xmm0
movss  %xmm0,0x0(%r13)
add    %rdi,%r12
add    %rcx,%r13
add    %esi,%r10d
add    $0xffffffffffffffff,%r9
jne    2cd0 <radfg+0x1bb0>
jmp    2ca0 <radfg+0x1b80>
cmpl   $0x1,0x48(%rsp)
mov    0x60(%rsp),%rdx
je     3177 <radfg+0x2057>
mov    0xa4(%rsp),%eax
cmp    0x14(%rsp),%eax
jge    2f55 <radfg+0x1e35>
cmpb   $0x0,0x28(%rsp)
je     3177 <radfg+0x2057>
mov    0x48(%rsp),%r8
movslq %r8d,%rsi
movslq 0x60(%rsp),%rdx
mov    0x14(%rsp),%ecx
movslq %ecx,%rax
mov    0x6c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,0x78(%rsp)
mov    %ecx,%ecx
mov    %rcx,0x20(%rsp)
lea    (%r8,%r8,1),%ecx
mov    %ecx,0x88(%rsp)
mov    0x60(%rsp),%rcx
imul   %r8d,%ecx
mov    %rcx,0x60(%rsp)
lea    (%r8,%r8,1),%ecx
add    $0xfffffffd,%ecx
mov    %ecx,0x38(%rsp)
lea    0x8(%rbx,%rsi,8),%rcx
mov    %rcx,0x58(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x90(%rsp)
mov    %rdx,%r13
imul   %rsi,%r13
shl    $0x2,%r13
add    $0xffffffffffffffff,%rdx
imul   %rsi,%rax
imul   %rax,%rdx
mov    0x8(%rsp),%rbp
lea    0x8(,%rdx,4),%rdx
add    %rbp,%rdx
mov    %rdx,0x70(%rsp)
lea    0x0(,%rax,4),%rdx
mov    %rdx,0x98(%rsp)
neg    %rdx
mov    %rdx,0xa8(%rsp)
mov    %rsi,0x40(%rsp)
lea    0x0(,%rsi,4),%rdi
lea    0x8(,%rax,4),%rax
add    %rbp,%rax
mov    %rax,0x30(%rsp)
mov    $0x1,%edx
mov    %r8d,%eax
mov    %r8d,0x18(%rsp)
mov    0x60(%rsp),%r14
jmp    2e5f <radfg+0x1d3f>
nopl   (%rax)
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
mov    0x88(%rsp),%eax
add    %eax,0x18(%rsp)
add    %eax,0x38(%rsp)
mov    0x90(%rsp),%rax
add    %rax,0x58(%rsp)
mov    0xa8(%rsp),%rax
add    %rax,0x70(%rsp)
mov    0x30(%rsp),%rax
add    0x98(%rsp),%rax
mov    %rax,0x30(%rsp)
cmp    0x78(%rsp),%rdx
je     3177 <radfg+0x2057>
mov    %rdx,0x28(%rsp)
cmpl   $0x3,0x48(%rsp)
jl     2e10 <radfg+0x1cf0>
mov    $0x2,%r11d
mov    0x30(%rsp),%r12
mov    0x70(%rsp),%r9
mov    0x58(%rsp),%rcx
mov    0x38(%rsp),%eax
mov    %eax,0x8(%rsp)
jmp    2eb0 <radfg+0x1d90>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r11
addl   $0xfffffffe,0x8(%rsp)
add    $0x8,%rcx
add    $0x8,%r9
add    $0x8,%r12
cmp    0x40(%rsp),%r11
jge    2e10 <radfg+0x1cf0>
cmpl   $0x0,0x14(%rsp)
jle    2e90 <radfg+0x1d70>
mov    0x40(%rsp),%rax
sub    %r11,%rax
mov    0x20(%rsp),%rdx
xor    %esi,%esi
mov    %rcx,%r8
mov    0x8(%rsp),%ebp
mov    %rcx,%r15
mov    0x18(%rsp),%ecx
mov    %ecx,%r10d
mov    %r15,%rcx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%r12,%rsi,1),%xmm0
addss  -0x4(%r9,%rsi,1),%xmm0
movss  %xmm0,-0x4(%r8)
movss  -0x4(%r12,%rsi,1),%xmm0
subss  -0x4(%r9,%rsi,1),%xmm0
movslq %ebp,%rbp
movss  %xmm0,(%rbx,%rbp,4)
movss  (%r12,%rsi,1),%xmm0
addss  (%r9,%rsi,1),%xmm0
movss  %xmm0,(%r8)
movss  (%r9,%rsi,1),%xmm0
subss  (%r12,%rsi,1),%xmm0
movslq %r10d,%r10
lea    (%rax,%r10,1),%rbx
mov    0x50(%rsp),%r15
movss  %xmm0,(%r15,%rbx,4)
mov    0x50(%rsp),%rbx
add    %r14d,%r10d
add    %r14d,%ebp
add    %r13,%r8
add    %rdi,%rsi
add    $0xffffffffffffffff,%rdx
jne    2ee0 <radfg+0x1dc0>
jmp    2e90 <radfg+0x1d70>
cmpb   $0x0,0x28(%rsp)
je     3177 <radfg+0x2057>
mov    0x48(%rsp),%r8
movslq %r8d,%rax
movslq %edx,%rcx
mov    0x14(%rsp),%r9d
movslq %r9d,%rsi
mov    0x6c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,0x58(%rsp)
mov    %r9d,%ebp
lea    (%rbx,%rax,8),%rdi
mov    %rdi,0x20(%rsp)
lea    0x0(,%rax,8),%rdi
mov    %rdi,0x70(%rsp)
mov    %rcx,%rdi
imul   %rax,%rdi
shl    $0x2,%rdi
mov    %rdi,0x40(%rsp)
add    $0xffffffffffffffff,%rcx
imul   %rax,%rsi
imul   %rsi,%rcx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rcx,4),%rcx
mov    %rcx,0x30(%rsp)
lea    0x0(,%rsi,4),%rcx
mov    %rcx,0x78(%rsp)
neg    %rcx
mov    %rcx,0x88(%rsp)
lea    0x0(,%rax,4),%r14
lea    (%rdi,%rsi,4),%rsi
mov    %rsi,0x18(%rsp)
lea    (%r8,%r8,1),%esi
mov    %esi,0x90(%rsp)
lea    (%r8,%r8,1),%esi
add    $0xfffffffd,%esi
mov    %esi,0x28(%rsp)
imul   %r8d,%edx
lea    -0x8(%rbx),%rsi
mov    %rsi,0x8(%rsp)
mov    $0x1,%ecx
mov    %r8d,%esi
mov    %r8d,0x38(%rsp)
jmp    3079 <radfg+0x1f59>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
mov    0x70(%rsp),%rsi
add    %rsi,0x20(%rsp)
mov    0x88(%rsp),%rsi
add    %rsi,0x30(%rsp)
mov    0x18(%rsp),%rsi
add    0x78(%rsp),%rsi
mov    %rsi,0x18(%rsp)
mov    0x90(%rsp),%esi
add    %esi,0x28(%rsp)
add    %esi,0x38(%rsp)
cmp    0x58(%rsp),%rcx
je     3177 <radfg+0x2057>
mov    %rcx,0x60(%rsp)
cmpl   $0x0,0x14(%rsp)
jle    3030 <radfg+0x1f10>
mov    0x38(%rsp),%r10d
mov    0x28(%rsp),%edi
mov    0x18(%rsp),%rsi
mov    0x30(%rsp),%r13
mov    0x20(%rsp),%r15
xor    %r12d,%r12d
jmp    30cd <radfg+0x1fad>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r12
add    0x40(%rsp),%r15
add    %r14,%r13
add    %r14,%rsi
add    %edx,%edi
add    %edx,%r10d
cmp    %rbp,%r12
je     3030 <radfg+0x1f10>
cmpl   $0x3,0x48(%rsp)
jl     30b0 <radfg+0x1f90>
mov    %rdx,%rbx
movslq %r10d,%rdx
add    %rax,%rdx
mov    %rbp,%rcx
mov    0x8(%rsp),%rbp
lea    0x0(,%rdx,4),%r11
add    %rbp,%r11
mov    %rcx,%rbp
mov    %rbx,%rdx
mov    0x50(%rsp),%rbx
mov    $0x2,%r9d
mov    %edi,%r8d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rsi,%r9,4),%xmm0
addss  -0x4(%r13,%r9,4),%xmm0
movss  %xmm0,-0x4(%r15,%r9,4)
movss  -0x4(%rsi,%r9,4),%xmm0
subss  -0x4(%r13,%r9,4),%xmm0
movslq %r8d,%r8
movss  %xmm0,(%rbx,%r8,4)
movss  (%rsi,%r9,4),%xmm0
addss  0x0(%r13,%r9,4),%xmm0
movss  %xmm0,(%r15,%r9,4)
movss  0x0(%r13,%r9,4),%xmm0
subss  (%rsi,%r9,4),%xmm0
movss  %xmm0,(%r11)
add    $0x2,%r9
add    $0xfffffffe,%r8d
add    $0xfffffffffffffff8,%r11
cmp    %rax,%r9
jl     3110 <radfg+0x1ff0>
jmp    30b0 <radfg+0x1f90>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@radfg.twopi = internal constant float 0x401921FB60000000
define void @radfg(i32 %0, i32 %1, i32 %2, i32 %3, float* %4, float* %5, float* %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%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 float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store float* %4, float** %12
store float* %5, float** %13
store float* %6, float** %14
%39 = load i32, i32* %9
%40 = sitofp i32 %39 to float
%41 = fdiv float 0x401921FB60000000, %40
store float %41, float* %35
%42 = load float, float* %35
%43 = call float @cos(float %42)
store float %43, float* %34
%44 = load float, float* %35
%45 = call float @sin(float %44)
store float %45, float* %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 float*, float** %12
%61 = load i32, i32* %25
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
%65 = load float*, float** %13
%66 = load i32, i32* %25
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float %64, float* %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 float*, float** %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 float, float* %83, i64 %91
%93 = load float, float* %92
%94 = load float*, float** %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 float, float* %94, i64 %102
store float %93, float* %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 float*, float** %14
%141 = load i32, i32* %15
%142 = sub nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %140, i64 %143
%145 = load float, float* %144
%146 = load float*, float** %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 float, float* %146, i64 %157
%159 = load float, float* %158
%160 = load float*, float** %14
%161 = load i32, i32* %15
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %160, i64 %162
%164 = load float, float* %163
%165 = load float*, float** %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 float, float* %165, i64 %175
%177 = load float, float* %176
%178 = fmul float %164, %177
%179 = call float @llvm.fmuladd.f32(float %145, float %159, float %178)
%180 = load float*, float** %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 float, float* %180, i64 %191
store float %179, float* %192
%193 = load float*, float** %14
%194 = load i32, i32* %15
%195 = sub nsw i32 %194, 1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %193, i64 %196
%198 = load float, float* %197
%199 = load float*, float** %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 float, float* %199, i64 %209
%211 = load float, float* %210
%212 = load float*, float** %14
%213 = load i32, i32* %15
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %212, i64 %214
%216 = load float, float* %215
%217 = load float*, float** %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 float, float* %217, i64 %228
%230 = load float, float* %229
%231 = fmul float %216, %230
%232 = fneg float %231
%233 = call float @llvm.fmuladd.f32(float %198, float %211, float %232)
%234 = load float*, float** %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 float, float* %234, i64 %244
store float %233, float* %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 float*, float** %14
%284 = load i32, i32* %15
%285 = sub nsw i32 %284, 1
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds float, float* %283, i64 %286
%288 = load float, float* %287
%289 = load float*, float** %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 float, float* %289, i64 %300
%302 = load float, float* %301
%303 = load float*, float** %14
%304 = load i32, i32* %15
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float, float* %303, i64 %305
%307 = load float, float* %306
%308 = load float*, float** %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 float, float* %308, i64 %318
%320 = load float, float* %319
%321 = fmul float %307, %320
%322 = call float @llvm.fmuladd.f32(float %288, float %302, float %321)
%323 = load float*, float** %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 float, float* %323, i64 %334
store float %322, float* %335
%336 = load float*, float** %14
%337 = load i32, i32* %15
%338 = sub nsw i32 %337, 1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %336, i64 %339
%341 = load float, float* %340
%342 = load float*, float** %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 float, float* %342, i64 %352
%354 = load float, float* %353
%355 = load float*, float** %14
%356 = load i32, i32* %15
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %355, i64 %357
%359 = load float, float* %358
%360 = load float*, float** %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 float, float* %360, i64 %371
%373 = load float, float* %372
%374 = fmul float %359, %373
%375 = fneg float %374
%376 = call float @llvm.fmuladd.f32(float %341, float %354, float %375)
%377 = load float*, float** %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 float, float* %377, i64 %387
store float %376, float* %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 float*, float** %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 float, float* %424, i64 %435
%437 = load float, float* %436
%438 = load float*, float** %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 float, float* %438, i64 %449
%451 = load float, float* %450
%452 = fadd float %437, %451
%453 = load float*, float** %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 float, float* %453, i64 %464
store float %452, float* %465
%466 = load float*, float** %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 float, float* %466, i64 %476
%478 = load float, float* %477
%479 = load float*, float** %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 float, float* %479, i64 %489
%491 = load float, float* %490
%492 = fsub float %478, %491
%493 = load float*, float** %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 float, float* %493, i64 %504
store float %492, float* %505
%506 = load float*, float** %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 float, float* %506, i64 %516
%518 = load float, float* %517
%519 = load float*, float** %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 float, float* %519, i64 %529
%531 = load float, float* %530
%532 = fadd float %518, %531
%533 = load float*, float** %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 float, float* %533, i64 %543
store float %532, float* %544
%545 = load float*, float** %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 float, float* %545, i64 %556
%558 = load float, float* %557
%559 = load float*, float** %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 float, float* %559, i64 %570
%572 = load float, float* %571
%573 = fsub float %558, %572
%574 = load float*, float** %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 float, float* %574, i64 %584
store float %573, float* %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 float*, float** %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 float, float* %617, i64 %628
%630 = load float, float* %629
%631 = load float*, float** %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 float, float* %631, i64 %642
%644 = load float, float* %643
%645 = fadd float %630, %644
%646 = load float*, float** %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 float, float* %646, i64 %657
store float %645, float* %658
%659 = load float*, float** %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 float, float* %659, i64 %669
%671 = load float, float* %670
%672 = load float*, float** %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 float, float* %672, i64 %682
%684 = load float, float* %683
%685 = fsub float %671, %684
%686 = load float*, float** %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 float, float* %686, i64 %697
store float %685, float* %698
%699 = load float*, float** %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 float, float* %699, i64 %709
%711 = load float, float* %710
%712 = load float*, float** %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 float, float* %712, i64 %722
%724 = load float, float* %723
%725 = fadd float %711, %724
%726 = load float*, float** %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 float, float* %726, i64 %736
store float %725, float* %737
%738 = load float*, float** %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 float, float* %738, i64 %749
%751 = load float, float* %750
%752 = load float*, float** %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 float, float* %752, i64 %763
%765 = load float, float* %764
%766 = fsub float %751, %765
%767 = load float*, float** %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 float, float* %767, i64 %777
store float %766, float* %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 float*, float** %13
%799 = load i32, i32* %25
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds float, float* %798, i64 %800
%802 = load float, float* %801
%803 = load float*, float** %12
%804 = load i32, i32* %25
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds float, float* %803, i64 %805
store float %802, float* %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 float*, float** %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 float, float* %825, i64 %833
%835 = load float, float* %834
%836 = load float*, float** %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 float, float* %836, i64 %844
%846 = load float, float* %845
%847 = fadd float %835, %846
%848 = load float*, float** %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 float, float* %848, i64 %856
store float %847, float* %857
%858 = load float*, float** %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 float, float* %858, i64 %866
%868 = load float, float* %867
%869 = load float*, float** %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 float, float* %869, i64 %877
%879 = load float, float* %878
%880 = fsub float %868, %879
%881 = load float*, float** %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 float, float* %881, i64 %889
store float %880, float* %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 float 1.000000e+00, float* %31
store float 0.000000e+00, float* %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 float, float* %34
%908 = load float, float* %31
%909 = load float, float* %36
%910 = load float, float* %29
%911 = fmul float %909, %910
%912 = fneg float %911
%913 = call float @llvm.fmuladd.f32(float %907, float %908, float %912)
store float %913, float* %37
%914 = load float, float* %34
%915 = load float, float* %29
%916 = load float, float* %36
%917 = load float, float* %31
%918 = fmul float %916, %917
%919 = call float @llvm.fmuladd.f32(float %914, float %915, float %918)
store float %919, float* %29
%920 = load float, float* %37
store float %920, float* %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 float*, float** %12
%927 = load i32, i32* %25
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds float, float* %926, i64 %928
%930 = load float, float* %929
%931 = load float, float* %31
%932 = load float*, float** %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 float, float* %932, i64 %936
%938 = load float, float* %937
%939 = call float @llvm.fmuladd.f32(float %931, float %938, float %930)
%940 = load float*, float** %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 float, float* %940, i64 %946
store float %939, float* %947
%948 = load float, float* %29
%949 = load float*, float** %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 float, float* %949, i64 %956
%958 = load float, float* %957
%959 = fmul float %948, %958
%960 = load float*, float** %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 float, float* %960, i64 %966
store float %959, float* %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 float, float* %31
store float %972, float* %28
%973 = load float, float* %29
store float %973, float* %33
%974 = load float, float* %31
store float %974, float* %32
%975 = load float, float* %29
store float %975, float* %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 float, float* %28
%985 = load float, float* %32
%986 = load float, float* %33
%987 = load float, float* %30
%988 = fmul float %986, %987
%989 = fneg float %988
%990 = call float @llvm.fmuladd.f32(float %984, float %985, float %989)
store float %990, float* %38
%991 = load float, float* %28
%992 = load float, float* %30
%993 = load float, float* %33
%994 = load float, float* %32
%995 = fmul float %993, %994
%996 = call float @llvm.fmuladd.f32(float %991, float %992, float %995)
store float %996, float* %30
%997 = load float, float* %38
store float %997, float* %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 float, float* %32
%1004 = load float*, float** %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 float, float* %1004, i64 %1010
%1012 = load float, float* %1011
%1013 = load float*, float** %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 float, float* %1013, i64 %1019
%1021 = load float, float* %1020
%1022 = call float @llvm.fmuladd.f32(float %1003, float %1012, float %1021)
store float %1022, float* %1020
%1023 = load float, float* %30
%1024 = load float*, float** %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 float, float* %1024, i64 %1030
%1032 = load float, float* %1031
%1033 = load float*, float** %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 float, float* %1033, i64 %1039
%1041 = load float, float* %1040
%1042 = call float @llvm.fmuladd.f32(float %1023, float %1032, float %1041)
store float %1042, float* %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 float*, float** %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 float, float* %1065, i64 %1071
%1073 = load float, float* %1072
%1074 = load float*, float** %13
%1075 = load i32, i32* %25
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds float, float* %1074, i64 %1076
%1078 = load float, float* %1077
%1079 = fadd float %1078, %1073
store float %1079, float* %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 float*, float** %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 float, float* %1102, i64 %1108
%1110 = load float, float* %1109
%1111 = load float*, float** %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 float, float* %1111, i64 %1119
store float %1110, float* %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 float*, float** %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 float, float* %1140, i64 %1146
%1148 = load float, float* %1147
%1149 = load float*, float** %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 float, float* %1149, i64 %1157
store float %1148, float* %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 float*, float** %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 float, float* %1183, i64 %1191
%1193 = load float, float* %1192
%1194 = load float*, float** %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 float, float* %1194, i64 %1206
store float %1193, float* %1207
%1208 = load float*, float** %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 float, float* %1208, i64 %1216
%1218 = load float, float* %1217
%1219 = load float*, float** %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 float, float* %1219, i64 %1227
store float %1218, float* %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 float*, float** %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 float, float* %1268, i64 %1279
%1281 = load float, float* %1280
%1282 = load float*, float** %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 float, float* %1282, i64 %1293
%1295 = load float, float* %1294
%1296 = fadd float %1281, %1295
%1297 = load float*, float** %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 float, float* %1297, i64 %1308
store float %1296, float* %1309
%1310 = load float*, float** %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 float, float* %1310, i64 %1321
%1323 = load float, float* %1322
%1324 = load float*, float** %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 float, float* %1324, i64 %1335
%1337 = load float, float* %1336
%1338 = fsub float %1323, %1337
%1339 = load float*, float** %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 float, float* %1339, i64 %1351
store float %1338, float* %1352
%1353 = load float*, float** %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 float, float* %1353, i64 %1363
%1365 = load float, float* %1364
%1366 = load float*, float** %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 float, float* %1366, i64 %1376
%1378 = load float, float* %1377
%1379 = fadd float %1365, %1378
%1380 = load float*, float** %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 float, float* %1380, i64 %1390
store float %1379, float* %1391
%1392 = load float*, float** %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 float, float* %1392, i64 %1402
%1404 = load float, float* %1403
%1405 = load float*, float** %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 float, float* %1405, i64 %1415
%1417 = load float, float* %1416
%1418 = fsub float %1404, %1417
%1419 = load float*, float** %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 float, float* %1419, i64 %1430
store float %1418, float* %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 float*, float** %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 float, float* %1468, i64 %1479
%1481 = load float, float* %1480
%1482 = load float*, float** %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 float, float* %1482, i64 %1493
%1495 = load float, float* %1494
%1496 = fadd float %1481, %1495
%1497 = load float*, float** %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 float, float* %1497, i64 %1508
store float %1496, float* %1509
%1510 = load float*, float** %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 float, float* %1510, i64 %1521
%1523 = load float, float* %1522
%1524 = load float*, float** %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 float, float* %1524, i64 %1535
%1537 = load float, float* %1536
%1538 = fsub float %1523, %1537
%1539 = load float*, float** %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 float, float* %1539, i64 %1551
store float %1538, float* %1552
%1553 = load float*, float** %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 float, float* %1553, i64 %1563
%1565 = load float, float* %1564
%1566 = load float*, float** %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 float, float* %1566, i64 %1576
%1578 = load float, float* %1577
%1579 = fadd float %1565, %1578
%1580 = load float*, float** %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 float, float* %1580, i64 %1590
store float %1579, float* %1591
%1592 = load float*, float** %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 float, float* %1592, i64 %1602
%1604 = load float, float* %1603
%1605 = load float*, float** %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 float, float* %1605, i64 %1615
%1617 = load float, float* %1616
%1618 = fsub float %1604, %1617
%1619 = load float*, float** %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 float, float* %1619, i64 %1630
store float %1618, float* %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, float* %4, float* %5, float* nocapture %6) {
%8 = sitofp i32 %1 to float
%9 = fdiv float 0x401921FB60000000, %8
%10 = tail call float @cos(float %9)
%11 = tail call float @sin(float %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, 8
br i1 %21, label %107, label %22
22: ; preds = %19
%23 = getelementptr float, float* %5, i64 %20
%24 = getelementptr float, float* %4, i64 %20
%25 = icmp ugt float* %24, %5
%26 = icmp ugt float* %23, %4
%27 = and i1 %25, %26
br i1 %27, label %107, label %28
28: ; preds = %22
%29 = and i64 %20, 4294967288
%30 = add nsw i64 %29, -8
%31 = lshr exact i64 %30, 3
%32 = add nuw nsw i64 %31, 1
%33 = and i64 %32, 3
%34 = icmp ult i64 %30, 24
br i1 %34, label %86, label %35
35: ; preds = %28
%36 = and i64 %32, 4611686018427387900
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %83, %37 ]
%39 = phi i64 [ 0, %35 ], [ %84, %37 ]
%40 = getelementptr inbounds float, float* %4, i64 %38
%41 = bitcast float* %40 to <4 x float>*
%42 = load <4 x float>, <4 x float>* %41
%43 = getelementptr inbounds float, float* %40, i64 4
%44 = bitcast float* %43 to <4 x float>*
%45 = load <4 x float>, <4 x float>* %44
%46 = getelementptr inbounds float, float* %5, i64 %38
%47 = bitcast float* %46 to <4 x float>*
store <4 x float> %42, <4 x float>* %47
%48 = getelementptr inbounds float, float* %46, i64 4
%49 = bitcast float* %48 to <4 x float>*
store <4 x float> %45, <4 x float>* %49
%50 = or i64 %38, 8
%51 = getelementptr inbounds float, float* %4, i64 %50
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = getelementptr inbounds float, float* %51, i64 4
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = getelementptr inbounds float, float* %5, i64 %50
%58 = bitcast float* %57 to <4 x float>*
store <4 x float> %53, <4 x float>* %58
%59 = getelementptr inbounds float, float* %57, i64 4
%60 = bitcast float* %59 to <4 x float>*
store <4 x float> %56, <4 x float>* %60
%61 = or i64 %38, 16
%62 = getelementptr inbounds float, float* %4, i64 %61
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = getelementptr inbounds float, float* %62, i64 4
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds float, float* %5, i64 %61
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %64, <4 x float>* %69
%70 = getelementptr inbounds float, float* %68, i64 4
%71 = bitcast float* %70 to <4 x float>*
store <4 x float> %67, <4 x float>* %71
%72 = or i64 %38, 24
%73 = getelementptr inbounds float, float* %4, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %73, i64 4
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = getelementptr inbounds float, float* %5, i64 %72
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> %75, <4 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 4
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %78, <4 x float>* %82
%83 = add nuw i64 %38, 32
%84 = add 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 float, float* %4, i64 %90
%93 = bitcast float* %92 to <4 x float>*
%94 = load <4 x float>, <4 x float>* %93
%95 = getelementptr inbounds float, float* %92, i64 4
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = getelementptr inbounds float, float* %5, i64 %90
%99 = bitcast float* %98 to <4 x float>*
store <4 x float> %94, <4 x float>* %99
%100 = getelementptr inbounds float, float* %98, i64 4
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %97, <4 x float>* %101
%102 = add nuw i64 %90, 8
%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 float, float* %4, i64 %114
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %5, i64 %114
store float %117, float* %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, 8
br i1 %128, label %214, label %129
129: ; preds = %126
%130 = getelementptr float, float* %4, i64 %127
%131 = getelementptr float, float* %5, i64 %127
%132 = icmp ugt float* %131, %4
%133 = icmp ugt float* %130, %5
%134 = and i1 %132, %133
br i1 %134, label %214, label %135
135: ; preds = %129
%136 = and i64 %127, 4294967288
%137 = add nsw i64 %136, -8
%138 = lshr exact i64 %137, 3
%139 = add nuw nsw i64 %138, 1
%140 = and i64 %139, 3
%141 = icmp ult i64 %137, 24
br i1 %141, label %193, label %142
142: ; preds = %135
%143 = and i64 %139, 4611686018427387900
br label %144
144: ; preds = %144, %142
%145 = phi i64 [ 0, %142 ], [ %190, %144 ]
%146 = phi i64 [ 0, %142 ], [ %191, %144 ]
%147 = getelementptr inbounds float, float* %5, i64 %145
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %147, i64 4
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = getelementptr inbounds float, float* %4, i64 %145
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %149, <4 x float>* %154
%155 = getelementptr inbounds float, float* %153, i64 4
%156 = bitcast float* %155 to <4 x float>*
store <4 x float> %152, <4 x float>* %156
%157 = or i64 %145, 8
%158 = getelementptr inbounds float, float* %5, i64 %157
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %158, i64 4
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %4, i64 %157
%165 = bitcast float* %164 to <4 x float>*
store <4 x float> %160, <4 x float>* %165
%166 = getelementptr inbounds float, float* %164, i64 4
%167 = bitcast float* %166 to <4 x float>*
store <4 x float> %163, <4 x float>* %167
%168 = or i64 %145, 16
%169 = getelementptr inbounds float, float* %5, i64 %168
%170 = bitcast float* %169 to <4 x float>*
%171 = load <4 x float>, <4 x float>* %170
%172 = getelementptr inbounds float, float* %169, i64 4
%173 = bitcast float* %172 to <4 x float>*
%174 = load <4 x float>, <4 x float>* %173
%175 = getelementptr inbounds float, float* %4, i64 %168
%176 = bitcast float* %175 to <4 x float>*
store <4 x float> %171, <4 x float>* %176
%177 = getelementptr inbounds float, float* %175, i64 4
%178 = bitcast float* %177 to <4 x float>*
store <4 x float> %174, <4 x float>* %178
%179 = or i64 %145, 24
%180 = getelementptr inbounds float, float* %5, i64 %179
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = getelementptr inbounds float, float* %180, i64 4
%184 = bitcast float* %183 to <4 x float>*
%185 = load <4 x float>, <4 x float>* %184
%186 = getelementptr inbounds float, float* %4, i64 %179
%187 = bitcast float* %186 to <4 x float>*
store <4 x float> %182, <4 x float>* %187
%188 = getelementptr inbounds float, float* %186, i64 4
%189 = bitcast float* %188 to <4 x float>*
store <4 x float> %185, <4 x float>* %189
%190 = add nuw i64 %145, 32
%191 = add 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 float, float* %5, i64 %197
%200 = bitcast float* %199 to <4 x float>*
%201 = load <4 x float>, <4 x float>* %200
%202 = getelementptr inbounds float, float* %199, i64 4
%203 = bitcast float* %202 to <4 x float>*
%204 = load <4 x float>, <4 x float>* %203
%205 = getelementptr inbounds float, float* %4, i64 %197
%206 = bitcast float* %205 to <4 x float>*
store <4 x float> %201, <4 x float>* %206
%207 = getelementptr inbounds float, float* %205, i64 4
%208 = bitcast float* %207 to <4 x float>*
store <4 x float> %204, <4 x float>* %208
%209 = add nuw i64 %197, 8
%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 float, float* %5, i64 %221
%224 = load float, float* %223
%225 = getelementptr inbounds float, float* %4, i64 %221
store float %224, float* %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 float, float* %4, i64 %246
%248 = load float, float* %247
%249 = getelementptr inbounds float, float* %5, i64 %246
store float %248, float* %249
%250 = add nuw nsw i64 %246, 1
%251 = getelementptr inbounds float, float* %4, i64 %250
%252 = load float, float* %251
%253 = getelementptr inbounds float, float* %5, i64 %250
store float %252, float* %253
%254 = add nuw nsw i64 %246, 2
%255 = getelementptr inbounds float, float* %4, i64 %254
%256 = load float, float* %255
%257 = getelementptr inbounds float, float* %5, i64 %254
store float %256, float* %257
%258 = add nuw nsw i64 %246, 3
%259 = getelementptr inbounds float, float* %4, i64 %258
%260 = load float, float* %259
%261 = getelementptr inbounds float, float* %5, i64 %258
store float %260, float* %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 float, float* %4, i64 %272
%274 = load float, float* %273
%275 = getelementptr inbounds float, float* %5, i64 %272
store float %274, float* %275
%276 = or i64 %269, 1
%277 = add nsw i64 %276, %267
%278 = mul nsw i64 %277, %236
%279 = getelementptr inbounds float, float* %4, i64 %278
%280 = load float, float* %279
%281 = getelementptr inbounds float, float* %5, i64 %278
store float %280, float* %281
%282 = or i64 %269, 2
%283 = add nsw i64 %282, %267
%284 = mul nsw i64 %283, %236
%285 = getelementptr inbounds float, float* %4, i64 %284
%286 = load float, float* %285
%287 = getelementptr inbounds float, float* %5, i64 %284
store float %286, float* %287
%288 = or i64 %269, 3
%289 = add nsw i64 %288, %267
%290 = mul nsw i64 %289, %236
%291 = getelementptr inbounds float, float* %4, i64 %290
%292 = load float, float* %291
%293 = getelementptr inbounds float, float* %5, i64 %290
store float %292, float* %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 float, float* %4, i64 %303
%305 = load float, float* %304
%306 = getelementptr inbounds float, float* %5, i64 %303
store float %305, float* %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 float, float* %6, i64 %335
%337 = getelementptr inbounds float, float* %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 float, float* %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 float, float* %4, i64 %349
%351 = load float, float* %350
%352 = load float, float* %337
%353 = add nsw i64 %345, %331
%354 = getelementptr inbounds float, float* %4, i64 %353
%355 = load float, float* %354
%356 = fmul float %352, %355
%357 = tail call float @llvm.fmuladd.f32(float %342, float %351, float %356)
%358 = getelementptr inbounds float, float* %5, i64 %349
store float %357, float* %358
%359 = load float, float* %336
%360 = load float, float* %354
%361 = load float, float* %337
%362 = load float, float* %350
%363 = fneg float %361
%364 = fmul float %362, %363
%365 = tail call float @llvm.fmuladd.f32(float %359, float %360, float %364)
%366 = getelementptr inbounds float, float* %5, i64 %353
store float %365, float* %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 float, float* %6, i64 %399
%401 = load float, float* %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 float, float* %4, i64 %405
%407 = load float, float* %406
%408 = getelementptr inbounds float, float* %6, i64 %398
%409 = load float, float* %408
%410 = add nsw i64 %396, %394
%411 = getelementptr inbounds float, float* %4, i64 %410
%412 = load float, float* %411
%413 = fmul float %409, %412
%414 = tail call float @llvm.fmuladd.f32(float %401, float %407, float %413)
%415 = getelementptr inbounds float, float* %5, i64 %405
store float %414, float* %415
%416 = load float, float* %400
%417 = load float, float* %411
%418 = load float, float* %408
%419 = load float, float* %406
%420 = fneg float %418
%421 = fmul float %419, %420
%422 = tail call float @llvm.fmuladd.f32(float %416, float %417, float %421)
%423 = getelementptr inbounds float, float* %5, i64 %410
store float %422, float* %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 float, float* %5, i64 %472
%474 = load float, float* %473
%475 = add nsw i64 %471, %468
%476 = getelementptr inbounds float, float* %5, i64 %475
%477 = load float, float* %476
%478 = fadd float %474, %477
%479 = getelementptr inbounds float, float* %4, i64 %472
store float %478, float* %479
%480 = add nsw i64 %470, %466
%481 = getelementptr inbounds float, float* %5, i64 %480
%482 = load float, float* %481
%483 = add nsw i64 %470, %468
%484 = getelementptr inbounds float, float* %5, i64 %483
%485 = load float, float* %484
%486 = fsub float %482, %485
%487 = getelementptr inbounds float, float* %4, i64 %475
store float %486, float* %487
%488 = load float, float* %481
%489 = load float, float* %484
%490 = fadd float %488, %489
%491 = getelementptr inbounds float, float* %4, i64 %480
store float %490, float* %491
%492 = load float, float* %476
%493 = load float, float* %473
%494 = fsub float %492, %493
%495 = getelementptr inbounds float, float* %4, i64 %483
store float %494, float* %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 float, float* %5, i64 %518
%520 = load float, float* %519
%521 = add nsw i64 %515, %509
%522 = mul nsw i64 %521, %450
%523 = add nsw i64 %522, %513
%524 = getelementptr inbounds float, float* %5, i64 %523
%525 = load float, float* %524
%526 = fadd float %520, %525
%527 = getelementptr inbounds float, float* %4, i64 %518
store float %526, float* %527
%528 = add nsw i64 %517, %511
%529 = getelementptr inbounds float, float* %5, i64 %528
%530 = load float, float* %529
%531 = add nsw i64 %522, %511
%532 = getelementptr inbounds float, float* %5, i64 %531
%533 = load float, float* %532
%534 = fsub float %530, %533
%535 = getelementptr inbounds float, float* %4, i64 %523
store float %534, float* %535
%536 = load float, float* %529
%537 = load float, float* %532
%538 = fadd float %536, %537
%539 = getelementptr inbounds float, float* %4, i64 %528
store float %538, float* %539
%540 = load float, float* %524
%541 = load float, float* %519
%542 = fsub float %540, %541
%543 = getelementptr inbounds float, float* %4, i64 %531
store float %542, float* %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 float, float* %5, i64 %553
%555 = load float, float* %554
%556 = getelementptr inbounds float, float* %4, i64 %553
store float %555, float* %556
%557 = add nuw nsw i64 %553, 1
%558 = getelementptr inbounds float, float* %5, i64 %557
%559 = load float, float* %558
%560 = getelementptr inbounds float, float* %4, i64 %557
store float %559, float* %560
%561 = add nuw nsw i64 %553, 2
%562 = getelementptr inbounds float, float* %5, i64 %561
%563 = load float, float* %562
%564 = getelementptr inbounds float, float* %4, i64 %561
store float %563, float* %564
%565 = add nuw nsw i64 %553, 3
%566 = getelementptr inbounds float, float* %5, i64 %565
%567 = load float, float* %566
%568 = getelementptr inbounds float, float* %4, i64 %565
store float %567, float* %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 float %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 float, float* %4, i64 %594
%611 = getelementptr float, float* %4, i64 %588
%612 = getelementptr float, float* %4, i64 %606
%613 = getelementptr float, float* %4, i64 %589
%614 = add nsw i64 %589, %594
%615 = getelementptr float, float* %4, i64 %614
%616 = insertelement <2 x float> poison, float %10, i64 0
%617 = shufflevector <2 x float> %616, <2 x float> poison, <2 x i32> zeroinitializer
%618 = insertelement <2 x float> poison, float %10, i64 0
%619 = shufflevector <2 x float> %618, <2 x float> poison, <2 x i32> zeroinitializer
%620 = insertelement <2 x float> poison, float %11, i64 1
%621 = insertelement <2 x float> poison, float %583, i64 0
%622 = and i64 %594, 4294967292
%623 = add nsw i64 %622, -4
%624 = lshr exact i64 %623, 2
%625 = add nuw nsw i64 %624, 1
%626 = icmp ult i32 %3, 4
%627 = and i64 %594, 4294967292
%628 = and i64 %625, 1
%629 = icmp eq i64 %623, 0
%630 = and i64 %625, 9223372036854775806
%631 = icmp eq i64 %628, 0
%632 = icmp eq i64 %627, %594
%633 = icmp ult i32 %3, 4
%634 = and i64 %594, 4294967292
%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 float, float* %5, i64 %645
%647 = load float, float* %646
%648 = add nsw i64 %643, %641
%649 = mul nsw i64 %648, %575
%650 = getelementptr inbounds float, float* %5, i64 %649
%651 = load float, float* %650
%652 = fadd float %647, %651
%653 = getelementptr inbounds float, float* %4, i64 %645
store float %652, float* %653
%654 = load float, float* %650
%655 = load float, float* %646
%656 = fsub float %654, %655
%657 = getelementptr inbounds float, float* %4, i64 %649
store float %656, float* %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 float, float* %5, i64 %594
%670 = add nsw i64 %588, %594
%671 = and i64 %594, 4294967288
%672 = add nsw i64 %671, -8
%673 = lshr exact i64 %672, 3
%674 = add nuw nsw i64 %673, 1
%675 = icmp ult i32 %3, 8
%676 = and i64 %594, 4294967288
%677 = and i64 %674, 1
%678 = icmp eq i64 %672, 0
%679 = and i64 %674, 4611686018427387902
%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 float> [ <float 1.000000e+00, float 0.000000e+00>, %582 ], [ %713, %943 ]
%689 = mul i64 %686, %588
%690 = add i64 %689, %588
%691 = getelementptr float, float* %5, i64 %690
%692 = add i64 %606, %689
%693 = getelementptr float, float* %5, i64 %692
%694 = mul i64 %686, %588
%695 = sub i64 %608, %694
%696 = getelementptr float, float* %5, i64 %695
%697 = sub i64 %609, %694
%698 = getelementptr float, float* %5, i64 %697
%699 = mul i64 %686, %588
%700 = add i64 %699, %588
%701 = getelementptr float, float* %5, i64 %700
%702 = add i64 %597, %699
%703 = getelementptr float, float* %5, i64 %702
%704 = mul i64 %686, %588
%705 = sub i64 %599, %704
%706 = getelementptr float, float* %5, i64 %705
%707 = sub i64 %600, %704
%708 = getelementptr float, float* %5, i64 %707
%709 = sub nsw i64 %590, %687
%710 = shufflevector <2 x float> %620, <2 x float> %688, <2 x i32> <i32 3, i32 1>
%711 = shufflevector <2 x float> %621, <2 x float> %688, <2 x i32> <i32 0, i32 2>
%712 = fmul <2 x float> %710, %711
%713 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %619, <2 x float> %688, <2 x float> %712)
%714 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %617, <2 x float> %688, <2 x float> %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 float* %691, %698
%720 = icmp ult float* %696, %693
%721 = and i1 %719, %720
%722 = icmp ult float* %691, %610
%723 = icmp ugt float* %693, %4
%724 = and i1 %722, %723
%725 = or i1 %721, %724
%726 = icmp ult float* %691, %612
%727 = icmp ult float* %611, %693
%728 = and i1 %726, %727
%729 = or i1 %725, %728
%730 = icmp ult float* %691, %615
%731 = icmp ult float* %613, %693
%732 = and i1 %730, %731
%733 = or i1 %729, %732
%734 = icmp ult float* %696, %610
%735 = icmp ugt float* %698, %4
%736 = and i1 %734, %735
%737 = or i1 %733, %736
%738 = icmp ult float* %696, %612
%739 = icmp ult float* %611, %698
%740 = and i1 %738, %739
%741 = or i1 %737, %740
%742 = icmp ult float* %696, %615
%743 = icmp ult float* %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 float> %714, <2 x float> undef, <4 x i32> zeroinitializer
%748 = shufflevector <2 x float> %714, <2 x float> undef, <4 x i32> <i32 1, i32 1, 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 float, float* %4, i64 %750
%753 = bitcast float* %752 to <4 x float>*
%754 = load <4 x float>, <4 x float>* %753
%755 = add nsw i64 %750, %588
%756 = getelementptr inbounds float, float* %4, i64 %755
%757 = bitcast float* %756 to <4 x float>*
%758 = load <4 x float>, <4 x float>* %757
%759 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %747, <4 x float> %758, <4 x float> %754)
%760 = add nsw i64 %750, %716
%761 = getelementptr inbounds float, float* %5, i64 %760
%762 = bitcast float* %761 to <4 x float>*
store <4 x float> %759, <4 x float>* %762
%763 = add nsw i64 %750, %589
%764 = getelementptr inbounds float, float* %4, i64 %763
%765 = bitcast float* %764 to <4 x float>*
%766 = load <4 x float>, <4 x float>* %765
%767 = fmul <4 x float> %748, %766
%768 = add nsw i64 %750, %717
%769 = getelementptr inbounds float, float* %5, i64 %768
%770 = bitcast float* %769 to <4 x float>*
store <4 x float> %767, <4 x float>* %770
%771 = or i64 %750, 4
%772 = getelementptr inbounds float, float* %4, i64 %771
%773 = bitcast float* %772 to <4 x float>*
%774 = load <4 x float>, <4 x float>* %773
%775 = add nsw i64 %771, %588
%776 = getelementptr inbounds float, float* %4, i64 %775
%777 = bitcast float* %776 to <4 x float>*
%778 = load <4 x float>, <4 x float>* %777
%779 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %747, <4 x float> %778, <4 x float> %774)
%780 = add nsw i64 %771, %716
%781 = getelementptr inbounds float, float* %5, i64 %780
%782 = bitcast float* %781 to <4 x float>*
store <4 x float> %779, <4 x float>* %782
%783 = add nsw i64 %771, %589
%784 = getelementptr inbounds float, float* %4, i64 %783
%785 = bitcast float* %784 to <4 x float>*
%786 = load <4 x float>, <4 x float>* %785
%787 = fmul <4 x float> %748, %786
%788 = add nsw i64 %771, %717
%789 = getelementptr inbounds float, float* %5, i64 %788
%790 = bitcast float* %789 to <4 x float>*
store <4 x float> %787, <4 x float>* %790
%791 = add nuw i64 %750, 8
%792 = add 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 float, float* %4, i64 %795
%798 = bitcast float* %797 to <4 x float>*
%799 = load <4 x float>, <4 x float>* %798
%800 = add nsw i64 %795, %588
%801 = getelementptr inbounds float, float* %4, i64 %800
%802 = bitcast float* %801 to <4 x float>*
%803 = load <4 x float>, <4 x float>* %802
%804 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %747, <4 x float> %803, <4 x float> %799)
%805 = add nsw i64 %795, %716
%806 = getelementptr inbounds float, float* %5, i64 %805
%807 = bitcast float* %806 to <4 x float>*
store <4 x float> %804, <4 x float>* %807
%808 = add nsw i64 %795, %589
%809 = getelementptr inbounds float, float* %4, i64 %808
%810 = bitcast float* %809 to <4 x float>*
%811 = load <4 x float>, <4 x float>* %810
%812 = fmul <4 x float> %748, %811
%813 = add nsw i64 %795, %717
%814 = getelementptr inbounds float, float* %5, i64 %813
%815 = bitcast float* %814 to <4 x float>*
store <4 x float> %812, <4 x float>* %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 float> %714, i64 0
%820 = extractelement <2 x float> %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 float> %714, i64 1
%824 = fneg float %823
%825 = mul nsw i64 %687, %588
%826 = mul nsw i64 %709, %588
%827 = insertelement <2 x float> poison, float %824, i64 0
%828 = shufflevector <2 x float> %714, <2 x float> undef, <2 x i32> zeroinitializer
%829 = icmp ult float* %701, %708
%830 = icmp ult float* %706, %703
%831 = and i1 %829, %830
br label %850
832: ; preds = %817, %832
%833 = phi i64 [ %848, %832 ], [ %818, %817 ]
%834 = getelementptr inbounds float, float* %4, i64 %833
%835 = load float, float* %834
%836 = add nsw i64 %833, %588
%837 = getelementptr inbounds float, float* %4, i64 %836
%838 = load float, float* %837
%839 = tail call float @llvm.fmuladd.f32(float %819, float %838, float %835)
%840 = add nsw i64 %833, %716
%841 = getelementptr inbounds float, float* %5, i64 %840
store float %839, float* %841
%842 = add nsw i64 %833, %589
%843 = getelementptr inbounds float, float* %4, i64 %842
%844 = load float, float* %843
%845 = fmul float %820, %844
%846 = add nsw i64 %833, %717
%847 = getelementptr inbounds float, float* %5, i64 %846
store float %845, float* %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 float> [ %714, %822 ], [ %867, %939 ]
%854 = mul i64 %851, %588
%855 = add i64 %601, %854
%856 = getelementptr float, float* %4, i64 %855
%857 = add i64 %602, %854
%858 = getelementptr float, float* %4, i64 %857
%859 = mul i64 %851, %588
%860 = sub i64 %604, %859
%861 = getelementptr float, float* %4, i64 %860
%862 = sub i64 %605, %859
%863 = getelementptr float, float* %4, i64 %862
%864 = shufflevector <2 x float> %853, <2 x float> %714, <2 x i32> <i32 1, i32 3>
%865 = shufflevector <2 x float> %827, <2 x float> %853, <2 x i32> <i32 0, i32 2>
%866 = fmul <2 x float> %864, %865
%867 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %828, <2 x float> %853, <2 x float> %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 float* %701, %858
%874 = icmp ult float* %856, %703
%875 = and i1 %873, %874
%876 = or i1 %831, %875
%877 = icmp ult float* %701, %863
%878 = icmp ult float* %861, %703
%879 = and i1 %877, %878
%880 = or i1 %876, %879
%881 = icmp ult float* %706, %858
%882 = icmp ult float* %856, %708
%883 = and i1 %881, %882
%884 = or i1 %880, %883
%885 = icmp ult float* %706, %863
%886 = icmp ult float* %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 float> %867, <2 x float> undef, <4 x i32> zeroinitializer
%891 = shufflevector <2 x float> %867, <2 x float> undef, <4 x i32> <i32 1, i32 1, 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 float, float* %4, i64 %894
%896 = bitcast float* %895 to <4 x float>*
%897 = load <4 x float>, <4 x float>* %896
%898 = add nsw i64 %893, %825
%899 = getelementptr inbounds float, float* %5, i64 %898
%900 = bitcast float* %899 to <4 x float>*
%901 = load <4 x float>, <4 x float>* %900
%902 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %890, <4 x float> %897, <4 x float> %901)
%903 = bitcast float* %899 to <4 x float>*
store <4 x float> %902, <4 x float>* %903
%904 = add nsw i64 %893, %871
%905 = getelementptr inbounds float, float* %4, i64 %904
%906 = bitcast float* %905 to <4 x float>*
%907 = load <4 x float>, <4 x float>* %906
%908 = add nsw i64 %893, %826
%909 = getelementptr inbounds float, float* %5, i64 %908
%910 = bitcast float* %909 to <4 x float>*
%911 = load <4 x float>, <4 x float>* %910
%912 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %891, <4 x float> %907, <4 x float> %911)
%913 = bitcast float* %909 to <4 x float>*
store <4 x float> %912, <4 x float>* %913
%914 = add nuw i64 %893, 4
%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 float> %867, i64 0
%920 = extractelement <2 x float> %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 float, float* %4, i64 %923
%925 = load float, float* %924
%926 = add nsw i64 %922, %825
%927 = getelementptr inbounds float, float* %5, i64 %926
%928 = load float, float* %927
%929 = tail call float @llvm.fmuladd.f32(float %919, float %925, float %928)
store float %929, float* %927
%930 = add nsw i64 %922, %871
%931 = getelementptr inbounds float, float* %4, i64 %930
%932 = load float, float* %931
%933 = add nsw i64 %922, %826
%934 = getelementptr inbounds float, float* %5, i64 %933
%935 = load float, float* %934
%936 = tail call float @llvm.fmuladd.f32(float %920, float %932, float %935)
store float %936, float* %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 float, float* %4, i64 %951
%953 = add i64 %670, %950
%954 = getelementptr float, float* %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 float* %954, %5
%959 = icmp ult float* %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 float, float* %4, i64 %965
%967 = bitcast float* %966 to <4 x float>*
%968 = load <4 x float>, <4 x float>* %967
%969 = getelementptr inbounds float, float* %966, i64 4
%970 = bitcast float* %969 to <4 x float>*
%971 = load <4 x float>, <4 x float>* %970
%972 = getelementptr inbounds float, float* %5, i64 %963
%973 = bitcast float* %972 to <4 x float>*
%974 = load <4 x float>, <4 x float>* %973
%975 = getelementptr inbounds float, float* %972, i64 4
%976 = bitcast float* %975 to <4 x float>*
%977 = load <4 x float>, <4 x float>* %976
%978 = fadd <4 x float> %968, %974
%979 = fadd <4 x float> %971, %977
%980 = bitcast float* %972 to <4 x float>*
store <4 x float> %978, <4 x float>* %980
%981 = bitcast float* %975 to <4 x float>*
store <4 x float> %979, <4 x float>* %981
%982 = or i64 %963, 8
%983 = add nsw i64 %982, %956
%984 = getelementptr inbounds float, float* %4, i64 %983
%985 = bitcast float* %984 to <4 x float>*
%986 = load <4 x float>, <4 x float>* %985
%987 = getelementptr inbounds float, float* %984, i64 4
%988 = bitcast float* %987 to <4 x float>*
%989 = load <4 x float>, <4 x float>* %988
%990 = getelementptr inbounds float, float* %5, i64 %982
%991 = bitcast float* %990 to <4 x float>*
%992 = load <4 x float>, <4 x float>* %991
%993 = getelementptr inbounds float, float* %990, i64 4
%994 = bitcast float* %993 to <4 x float>*
%995 = load <4 x float>, <4 x float>* %994
%996 = fadd <4 x float> %986, %992
%997 = fadd <4 x float> %989, %995
%998 = bitcast float* %990 to <4 x float>*
store <4 x float> %996, <4 x float>* %998
%999 = bitcast float* %993 to <4 x float>*
store <4 x float> %997, <4 x float>* %999
%1000 = add nuw i64 %963, 16
%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 float, float* %4, i64 %1006
%1008 = bitcast float* %1007 to <4 x float>*
%1009 = load <4 x float>, <4 x float>* %1008
%1010 = getelementptr inbounds float, float* %1007, i64 4
%1011 = bitcast float* %1010 to <4 x float>*
%1012 = load <4 x float>, <4 x float>* %1011
%1013 = getelementptr inbounds float, float* %5, i64 %1004
%1014 = bitcast float* %1013 to <4 x float>*
%1015 = load <4 x float>, <4 x float>* %1014
%1016 = getelementptr inbounds float, float* %1013, i64 4
%1017 = bitcast float* %1016 to <4 x float>*
%1018 = load <4 x float>, <4 x float>* %1017
%1019 = fadd <4 x float> %1009, %1015
%1020 = fadd <4 x float> %1012, %1018
%1021 = bitcast float* %1013 to <4 x float>*
store <4 x float> %1019, <4 x float>* %1021
%1022 = bitcast float* %1016 to <4 x float>*
store <4 x float> %1020, <4 x float>* %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 float, float* %4, i64 %1028
%1030 = load float, float* %1029
%1031 = getelementptr inbounds float, float* %5, i64 %1025
%1032 = load float, float* %1031
%1033 = fadd float %1030, %1032
store float %1033, float* %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 float, float* %4, i64 %1040
%1042 = load float, float* %1041
%1043 = getelementptr inbounds float, float* %5, i64 %1039
%1044 = load float, float* %1043
%1045 = fadd float %1042, %1044
store float %1045, float* %1043
%1046 = add nuw nsw i64 %1039, 1
%1047 = add nsw i64 %1046, %956
%1048 = getelementptr inbounds float, float* %4, i64 %1047
%1049 = load float, float* %1048
%1050 = getelementptr inbounds float, float* %5, i64 %1046
%1051 = load float, float* %1050
%1052 = fadd float %1049, %1051
store float %1052, float* %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 float, float* %4, i64 %1069
%1071 = and i64 %1069, 4294967288
%1072 = add nsw i64 %1071, -8
%1073 = lshr exact i64 %1072, 3
%1074 = add nuw nsw i64 %1073, 1
%1075 = icmp ult i32 %0, 8
%1076 = and i64 %1069, 4294967288
%1077 = and i64 %1074, 1
%1078 = icmp eq i64 %1072, 0
%1079 = and i64 %1074, 4611686018427387902
%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 float, float* %4, i64 %1100
%1102 = getelementptr float, float* %1070, i64 %1100
%1103 = mul i64 %1097, %1067
%1104 = getelementptr float, float* %5, i64 %1103
%1105 = add i64 %1103, %1069
%1106 = getelementptr float, float* %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 float* %1101, %1106
%1114 = icmp ult float* %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 float, float* %5, i64 %1120
%1122 = bitcast float* %1121 to <4 x float>*
%1123 = load <4 x float>, <4 x float>* %1122
%1124 = getelementptr inbounds float, float* %1121, i64 4
%1125 = bitcast float* %1124 to <4 x float>*
%1126 = load <4 x float>, <4 x float>* %1125
%1127 = add nsw i64 %1118, %1111
%1128 = getelementptr inbounds float, float* %4, i64 %1127
%1129 = bitcast float* %1128 to <4 x float>*
store <4 x float> %1123, <4 x float>* %1129
%1130 = getelementptr inbounds float, float* %1128, i64 4
%1131 = bitcast float* %1130 to <4 x float>*
store <4 x float> %1126, <4 x float>* %1131
%1132 = or i64 %1118, 8
%1133 = add nsw i64 %1132, %1108
%1134 = getelementptr inbounds float, float* %5, i64 %1133
%1135 = bitcast float* %1134 to <4 x float>*
%1136 = load <4 x float>, <4 x float>* %1135
%1137 = getelementptr inbounds float, float* %1134, i64 4
%1138 = bitcast float* %1137 to <4 x float>*
%1139 = load <4 x float>, <4 x float>* %1138
%1140 = add nsw i64 %1132, %1111
%1141 = getelementptr inbounds float, float* %4, i64 %1140
%1142 = bitcast float* %1141 to <4 x float>*
store <4 x float> %1136, <4 x float>* %1142
%1143 = getelementptr inbounds float, float* %1141, i64 4
%1144 = bitcast float* %1143 to <4 x float>*
store <4 x float> %1139, <4 x float>* %1144
%1145 = add nuw i64 %1118, 16
%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 float, float* %5, i64 %1151
%1153 = bitcast float* %1152 to <4 x float>*
%1154 = load <4 x float>, <4 x float>* %1153
%1155 = getelementptr inbounds float, float* %1152, i64 4
%1156 = bitcast float* %1155 to <4 x float>*
%1157 = load <4 x float>, <4 x float>* %1156
%1158 = add nsw i64 %1149, %1111
%1159 = getelementptr inbounds float, float* %4, i64 %1158
%1160 = bitcast float* %1159 to <4 x float>*
store <4 x float> %1154, <4 x float>* %1160
%1161 = getelementptr inbounds float, float* %1159, i64 4
%1162 = bitcast float* %1161 to <4 x float>*
store <4 x float> %1157, <4 x float>* %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 float, float* %5, i64 %1171
%1173 = load float, float* %1172
%1174 = add nsw i64 %1169, %1111
%1175 = getelementptr inbounds float, float* %4, i64 %1174
store float %1173, float* %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 float, float* %5, i64 %1184
%1186 = load float, float* %1185
%1187 = add nsw i64 %1183, %1111
%1188 = getelementptr inbounds float, float* %4, i64 %1187
store float %1186, float* %1188
%1189 = add nuw nsw i64 %1183, 1
%1190 = add nsw i64 %1189, %1108
%1191 = getelementptr inbounds float, float* %5, i64 %1190
%1192 = load float, float* %1191
%1193 = add nsw i64 %1189, %1111
%1194 = getelementptr inbounds float, float* %4, i64 %1193
store float %1192, float* %1194
%1195 = add nuw nsw i64 %1183, 2
%1196 = add nsw i64 %1195, %1108
%1197 = getelementptr inbounds float, float* %5, i64 %1196
%1198 = load float, float* %1197
%1199 = add nsw i64 %1195, %1111
%1200 = getelementptr inbounds float, float* %4, i64 %1199
store float %1198, float* %1200
%1201 = add nuw nsw i64 %1183, 3
%1202 = add nsw i64 %1201, %1108
%1203 = getelementptr inbounds float, float* %5, i64 %1202
%1204 = load float, float* %1203
%1205 = add nsw i64 %1201, %1111
%1206 = getelementptr inbounds float, float* %4, i64 %1205
store float %1204, float* %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 float, float* %5, i64 %1219
%1221 = load float, float* %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 float, float* %4, i64 %1225
store float %1221, float* %1226
%1227 = or i64 %1216, 1
%1228 = mul nsw i64 %1227, %1089
%1229 = add nuw nsw i64 %1228, %1213
%1230 = getelementptr inbounds float, float* %5, i64 %1229
%1231 = load float, float* %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 float, float* %4, i64 %1235
store float %1231, float* %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 float, float* %5, i64 %1244
%1246 = load float, float* %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 float, float* %4, i64 %1250
store float %1246, float* %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 float, float* %5, i64 %1274
%1276 = load float, float* %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 float, float* %4, i64 %1283
store float %1276, float* %1284
%1285 = add nsw i64 %1272, %1270
%1286 = mul nsw i64 %1285, %1258
%1287 = getelementptr inbounds float, float* %5, i64 %1286
%1288 = load float, float* %1287
%1289 = mul nsw i64 %1278, %1258
%1290 = getelementptr inbounds float, float* %4, i64 %1289
store float %1288, float* %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 float, float* %5, i64 %1346
%1348 = load float, float* %1347
%1349 = add nsw i64 %1345, %1333
%1350 = getelementptr inbounds float, float* %5, i64 %1349
%1351 = load float, float* %1350
%1352 = fadd float %1348, %1351
%1353 = add nsw i64 %1345, %1336
%1354 = getelementptr inbounds float, float* %4, i64 %1353
store float %1352, float* %1354
%1355 = load float, float* %1347
%1356 = load float, float* %1350
%1357 = fsub float %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 float, float* %4, i64 %1361
store float %1357, float* %1362
%1363 = add nsw i64 %1343, %1331
%1364 = getelementptr inbounds float, float* %5, i64 %1363
%1365 = load float, float* %1364
%1366 = add nsw i64 %1343, %1333
%1367 = getelementptr inbounds float, float* %5, i64 %1366
%1368 = load float, float* %1367
%1369 = fadd float %1365, %1368
%1370 = add nsw i64 %1343, %1336
%1371 = getelementptr inbounds float, float* %4, i64 %1370
store float %1369, float* %1371
%1372 = load float, float* %1367
%1373 = load float, float* %1364
%1374 = fsub float %1372, %1373
%1375 = add nsw i64 %1344, %1341
%1376 = getelementptr inbounds float, float* %4, i64 %1375
store float %1374, float* %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 float, float* %5, i64 %1402
%1404 = load float, float* %1403
%1405 = add nsw i64 %1399, %1391
%1406 = mul nsw i64 %1405, %1313
%1407 = add nsw i64 %1406, %1396
%1408 = getelementptr inbounds float, float* %5, i64 %1407
%1409 = load float, float* %1408
%1410 = fadd float %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 float, float* %4, i64 %1414
store float %1410, float* %1415
%1416 = load float, float* %1403
%1417 = load float, float* %1408
%1418 = fsub float %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 float, float* %4, i64 %1424
store float %1418, float* %1425
%1426 = add nsw i64 %1401, %1393
%1427 = getelementptr inbounds float, float* %5, i64 %1426
%1428 = load float, float* %1427
%1429 = add nsw i64 %1406, %1393
%1430 = getelementptr inbounds float, float* %5, i64 %1429
%1431 = load float, float* %1430
%1432 = fadd float %1428, %1431
%1433 = add nsw i64 %1413, %1393
%1434 = getelementptr inbounds float, float* %4, i64 %1433
store float %1432, float* %1434
%1435 = load float, float* %1430
%1436 = load float, float* %1427
%1437 = fsub float %1435, %1436
%1438 = sext i32 %1421 to i64
%1439 = add nsw i64 %1394, %1438
%1440 = getelementptr inbounds float, float* %4, i64 %1439
store float %1437, float* %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
}