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


x86 assembly (clang, -O0):
<radbg>:
push   %rbp
mov    %rsp,%rbp
sub    $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    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x6c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1225 <radbg+0x105>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1220 <radbg+0x100>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120d <radbg+0xed>
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  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%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    11bf <radbg+0x9f>
jmp    1212 <radbg+0xf2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ac <radbg+0x8c>
jmp    12a5 <radbg+0x185>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a0 <radbg+0x180>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128d <radbg+0x16d>
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  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%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    123f <radbg+0x11f>
jmp    1292 <radbg+0x172>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    122c <radbg+0x10c>
jmp    12a5 <radbg+0x185>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13bc <radbg+0x29c>
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    13a9 <radbg+0x289>
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  (%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
addss  (%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    -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  (%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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12d1 <radbg+0x1b1>
jmp    13ae <radbg+0x28e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ac <radbg+0x18c>
cmpl   $0x1,-0x4(%rbp)
je     1863 <radbg+0x743>
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1618 <radbg+0x4f8>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1613 <radbg+0x4f3>
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    1600 <radbg+0x4e0>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15ed <radbg+0x4cd>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1408 <radbg+0x2e8>
jmp    15f2 <radbg+0x4d2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13f5 <radbg+0x2d5>
jmp    1605 <radbg+0x4e5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13d9 <radbg+0x2b9>
jmp    185e <radbg+0x73e>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1859 <radbg+0x739>
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    1846 <radbg+0x726>
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    1833 <radbg+0x713>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x1,%edx
sub    $0x1,%edx
mov    -0x34(%rbp),%esi
imul   -0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1657 <radbg+0x537>
jmp    1838 <radbg+0x718>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    163b <radbg+0x51b>
jmp    184b <radbg+0x72b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    161f <radbg+0x4ff>
jmp    185e <radbg+0x73e>
jmp    1863 <radbg+0x743>
movss  0x1799(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1af2 <radbg+0x9d2>
mov    -0x8(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movss  -0x70(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x58(%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  -0x58(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    198a <radbg+0x86a>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%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    -0x18(%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  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%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    18f4 <radbg+0x7d4>
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1adf <radbg+0x9bf>
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1acc <radbg+0x9ac>
movss  -0x64(%rbp),%xmm0
mov    -0x20(%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    -0x18(%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  -0x5c(%rbp),%xmm0
mov    -0x20(%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    -0x18(%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    1a2e <radbg+0x90e>
jmp    1ad1 <radbg+0x9b1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19b9 <radbg+0x899>
jmp    1ae4 <radbg+0x9c4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    187f <radbg+0x75f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b63 <radbg+0xa43>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b50 <radbg+0xa30>
mov    -0x20(%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    1b0c <radbg+0x9ec>
jmp    1b55 <radbg+0xa35>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1af9 <radbg+0x9d9>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c5b <radbg+0xb3b>
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    1c48 <radbg+0xb28>
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    -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
subss  (%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    -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    -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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b86 <radbg+0xa66>
jmp    1c4d <radbg+0xb2d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b6a <radbg+0xa4a>
cmpl   $0x1,-0x4(%rbp)
jne    1c6a <radbg+0xb4a>
jmp    24e9 <radbg+0x13c9>
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1e8f <radbg+0xd6f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e8a <radbg+0xd6a>
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    1e77 <radbg+0xd57>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e64 <radbg+0xd44>
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),%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
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cac <radbg+0xb8c>
jmp    1e69 <radbg+0xd49>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c99 <radbg+0xb79>
jmp    1e7c <radbg+0xd5c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c7d <radbg+0xb5d>
jmp    20a8 <radbg+0xf88>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    20a3 <radbg+0xf83>
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    2090 <radbg+0xf70>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    207d <radbg+0xf5d>
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),%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
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
addss  (%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
movss  %xmm0,(%rax,%rcx,4)
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),%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
subss  (%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ec5 <radbg+0xda5>
jmp    2082 <radbg+0xf62>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1eb2 <radbg+0xd92>
jmp    2095 <radbg+0xf75>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e96 <radbg+0xd76>
jmp    20a8 <radbg+0xf88>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    20e3 <radbg+0xfc3>
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    20af <radbg+0xf8f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2162 <radbg+0x1042>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    214f <radbg+0x102f>
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    -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    20fd <radbg+0xfdd>
jmp    2154 <radbg+0x1034>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20ea <radbg+0xfca>
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     232d <radbg+0x120d>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2328 <radbg+0x1208>
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    2315 <radbg+0x11f5>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2302 <radbg+0x11e2>
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -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),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    21be <radbg+0x109e>
jmp    2307 <radbg+0x11e7>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    21a2 <radbg+0x1082>
jmp    231a <radbg+0x11fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    217d <radbg+0x105d>
jmp    24e9 <radbg+0x13c9>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    24e4 <radbg+0x13c4>
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    24d1 <radbg+0x13b1>
mov    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    24be <radbg+0x139e>
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    -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),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    -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),%xmm2
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%esi
imul   -0xc(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2371 <radbg+0x1251>
jmp    24c3 <radbg+0x13a3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2358 <radbg+0x1238>
jmp    24d6 <radbg+0x13b6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    233c <radbg+0x121c>
jmp    24e9 <radbg+0x13c9>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %esi,%r14d
cvtsi2ss %esi,%xmm1
mov    %r9,0x20(%rsp)
mov    %r8,%rbx
mov    %ecx,0x70(%rsp)
mov    %edx,%r12d
mov    %edi,%ebp
movss  0x1eaf(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x48(%rsp)
call   1040 <cos@plt>
movaps %xmm0,0x90(%rsp)
movss  0x48(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%rbp),%ecx
shr    $0x1f,%ecx
lea    0x1(%r14),%eax
shr    $0x1f,%eax
mov    %r14,0x30(%rsp)
add    %r14d,%eax
add    $0x1,%eax
mov    %eax,0x54(%rsp)
cmp    %r12d,%ebp
mov    %r12d,0xc(%rsp)
mov    %rbp,0x48(%rsp)
mov    %rcx,0x40(%rsp)
jge    1280 <radbg+0x160>
test   %ebp,%ebp
movaps 0x90(%rsp),%xmm11
jle    14f0 <radbg+0x3d0>
mov    0x30(%rsp),%r9
mov    0x48(%rsp),%rax
imul   %eax,%r9d
mov    %eax,%ecx
mov    %r12d,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    (%r9,%r9,1),%r14d
lea    0x0(,%rcx,8),%r15
xor    %eax,%eax
mov    0x20(%rsp),%r10
jmp    1201 <radbg+0xe1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x4,%r10
cmp    %rcx,%rax
je     14f0 <radbg+0x3d0>
test   %r12d,%r12d
jle    11f0 <radbg+0xd0>
cmp    $0x1,%r12d
jne    1210 <radbg+0xf0>
xor    %ebp,%ebp
jmp    1253 <radbg+0x133>
xor    %esi,%esi
mov    %r10,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
lea    (%rax,%rsi,1),%rdx
movss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rdi)
lea    (%r9,%rsi,1),%edx
movslq %edx,%rdx
add    %rax,%rdx
movss  (%rbx,%rdx,4),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
add    $0x2,%rbp
add    %r14d,%esi
add    %r15,%rdi
cmp    %rbp,%r11
jne    1220 <radbg+0x100>
test   $0x1,%r8b
je     11f0 <radbg+0xd0>
mov    %r9d,%edx
imul   %ebp,%edx
movslq %edx,%rdx
add    %rax,%rdx
movss  (%rbx,%rdx,4),%xmm1
imul   %rcx,%rbp
add    %rax,%rbp
mov    0x20(%rsp),%rdx
movss  %xmm1,(%rdx,%rbp,4)
jmp    11f0 <radbg+0xd0>
test   %r12d,%r12d
movaps 0x90(%rsp),%xmm11
jle    14f0 <radbg+0x3d0>
mov    0x30(%rsp),%rax
mov    %eax,%ecx
mov    0x48(%rsp),%rax
imul   %eax,%ecx
movslq %eax,%r11
mov    %r12d,%edx
mov    %ecx,%r12d
mov    %rdx,%rcx
mov    %eax,%edi
lea    (%rbx,%rdi,4),%rax
mov    %rax,0x18(%rsp)
mov    %edi,%eax
and    $0xfffffff8,%eax
mov    %rax,0x58(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rax
mov    %rdx,0x88(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x80(%rsp)
mov    %edi,%edx
and    $0x3,%edx
lea    0x30(%rbx),%rax
mov    %rax,0x78(%rsp)
mov    0x20(%rsp),%r14
lea    0x30(%r14),%r13
lea    0x0(,%r11,4),%r15
lea    0xc(%rbx),%rax
mov    %rax,0x60(%rsp)
xor    %r8d,%r8d
xor    %r10d,%r10d
mov    %rdx,0x28(%rsp)
mov    %rcx,0x10(%rsp)
jmp    1346 <radbg+0x226>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r12d,%r8d
add    %r15,%r13
add    %r15,%r14
cmp    %rcx,%r10
je     14f0 <radbg+0x3d0>
mov    0x48(%rsp),%rax
test   %eax,%eax
jle    1330 <radbg+0x210>
movslq %r8d,%r9
cmp    $0x8,%eax
jae    1360 <radbg+0x240>
xor    %ebp,%ebp
jmp    1460 <radbg+0x340>
xchg   %ax,%ax
mov    %r10,%rbp
imul   %r11,%rbp
mov    %r12d,%eax
imul   %r10d,%eax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rbp,4),%rdx
cltq
mov    0x18(%rsp),%rsi
lea    (%rsi,%rax,4),%rsi
cmp    %rsi,%rdx
jae    13a9 <radbg+0x289>
lea    (%rdi,%rbp,1),%rdx
lea    (%rcx,%rdx,4),%rdx
lea    (%rbx,%rax,4),%rax
cmp    %rdx,%rax
jae    13a9 <radbg+0x289>
xor    %ebp,%ebp
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
jmp    1460 <radbg+0x340>
mov    %r11,%rdx
mov    %r12d,%ecx
cmpq   $0x0,0x38(%rsp)
je     140b <radbg+0x2eb>
mov    0x78(%rsp),%rax
lea    (%rax,%r9,4),%rax
mov    0x80(%rsp),%r12
xor    %r11d,%r11d
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%r11,4),%xmm1
movups -0x20(%rax,%r11,4),%xmm2
movups %xmm1,-0x30(%r13,%r11,4)
movups %xmm2,-0x20(%r13,%r11,4)
movups -0x10(%rax,%r11,4),%xmm1
movups (%rax,%r11,4),%xmm2
movups %xmm1,-0x10(%r13,%r11,4)
movups %xmm2,0x0(%r13,%r11,4)
add    $0x10,%r11
add    $0xfffffffffffffffe,%r12
jne    13d0 <radbg+0x2b0>
jmp    140e <radbg+0x2ee>
xor    %r11d,%r11d
testb  $0x1,0x88(%rsp)
01
mov    %ecx,%r12d
je     1441 <radbg+0x321>
mov    %r12d,%eax
imul   %r10d,%eax
cltq
add    %r11,%rax
movups (%rbx,%rax,4),%xmm1
movups 0x10(%rbx,%rax,4),%xmm2
add    %r11,%rbp
mov    0x20(%rsp),%rax
movups %xmm1,(%rax,%rbp,4)
movups %xmm2,0x10(%rax,%rbp,4)
mov    0x58(%rsp),%rax
mov    %rax,%rbp
cmp    %rdi,%rax
mov    %rdx,%r11
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
je     1330 <radbg+0x210>
nop
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %rdx,%rdx
je     1495 <radbg+0x375>
lea    (%rbx,%r9,4),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm1
movss  %xmm1,(%r14,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1480 <radbg+0x360>
cmp    $0x3,%rax
mov    0x28(%rsp),%rdx
jb     1330 <radbg+0x210>
mov    0x60(%rsp),%rax
lea    (%rax,%r9,4),%rax
nopl   (%rax)
movss  -0xc(%rax,%rbp,4),%xmm1
movss  %xmm1,(%r14,%rbp,4)
movss  -0x8(%rax,%rbp,4),%xmm1
movss  %xmm1,0x4(%r14,%rbp,4)
movss  -0x4(%rax,%rbp,4),%xmm1
movss  %xmm1,0x8(%r14,%rbp,4)
movss  (%rax,%rbp,4),%xmm1
movss  %xmm1,0xc(%r14,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    14b0 <radbg+0x390>
jmp    1330 <radbg+0x210>
mov    0x48(%rsp),%rax
mov    0x40(%rsp),%rcx
add    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,0xa4(%rsp)
sarl   0x54(%rsp)
cmpl   $0x3,0x30(%rsp)
jl     1603 <radbg+0x4e3>
mov    0x30(%rsp),%r8
mov    %r8d,%ecx
mov    0x48(%rsp),%rbp
movslq %ebp,%rax
mov    0x54(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%esi
cmovge %edx,%esi
mov    %rsi,0x28(%rsp)
mov    0xc(%rsp),%edx
movslq %edx,%r14
mov    %edx,%edx
mov    %rdx,0x10(%rsp)
lea    -0x1(%rcx),%rdi
imul   %rax,%r14
imul   %r14,%rdi
shl    $0x2,%rdi
shl    $0x2,%r14
lea    0x0(,%rax,4),%rsi
lea    (%rbx,%rax,8),%r9
lea    0x0(,%rax,8),%rdx
mov    %rdx,0x18(%rsp)
imul   %rcx,%rax
shl    $0x2,%rax
lea    0x0(%rbp,%rbp,1),%r11d
lea    -0x1(%rbp,%rbp,1),%r12d
mov    %r8d,%ecx
imul   %ebp,%ecx
mov    $0x1,%r13d
mov    %r14,%rdx
jmp    15b9 <radbg+0x499>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
sub    %r14,%rdi
add    %r14,%rdx
add    0x18(%rsp),%r9
add    %r11d,%r12d
cmp    0x28(%rsp),%r13
je     1603 <radbg+0x4e3>
cmpl   $0x0,0xc(%rsp)
jle    15a0 <radbg+0x480>
mov    0x10(%rsp),%rbp
mov    %r12d,%r8d
mov    %r9,%r15
mov    0x20(%rsp),%r10
movslq %r8d,%r8
movss  (%rbx,%r8,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r10,%rdx,1)
movss  (%r15),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r10,%rdi,1)
add    %rsi,%r10
add    %rax,%r15
add    %ecx,%r8d
add    $0xffffffffffffffff,%rbp
jne    15d0 <radbg+0x4b0>
jmp    15a0 <radbg+0x480>
sarl   0xa4(%rsp)
cmpl   $0x1,0x48(%rsp)
jne    1e30 <radbg+0xd10>
cmpl   $0x3,0x30(%rsp)
jl     259a <radbg+0x147a>
movaps %xmm0,%xmm9
xorps  0x19e5(%rip),%xmm0
shufps $0x0,%xmm9,%xmm9
mov    0x30(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    0x70(%rsp),%r9d
imul   %r9d,%eax
movslq %r9d,%r13
movslq %eax,%rdx
mov    %ecx,%ecx
mov    0x54(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%esi
cmovge %eax,%esi
mov    %rsi,0x88(%rsp)
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
mov    %rsi,0x170(%rsp)
mov    %r13d,%r11d
lea    -0x1(%rcx),%rsi
imul   %r13,%rsi
mov    %rcx,0xc8(%rsp)
lea    -0x2(%rcx),%rbp
imul   %r13,%rbp
lea    (%rdx,%r11,1),%rax
mov    0x20(%rsp),%r14
lea    (%r14,%rax,4),%rax
mov    %rax,0x148(%rsp)
shufps $0x0,%xmm11,%xmm11
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x118(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x138(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x130(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
lea    0x0(,%r13,4),%rdi
mov    %rdi,%rax
neg    %rax
mov    %rax,0x28(%rsp)
movss  0x1905(%rip),%xmm2
movaps 0x1909(%rip),%xmm8
lea    (%r11,%r13,1),%rax
lea    (%rsi,%r11,1),%rcx
mov    %rcx,0x160(%rsp)
lea    0x0(%r13,%r13,1),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%r11,%r13,2),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(%rbp,%r11,1),%rcx
mov    %rcx,0x180(%rsp)
lea    (%r14,%r11,4),%rcx
mov    %rcx,0xe0(%rsp)
lea    (%r14,%r13,4),%rcx
mov    %rcx,0xd8(%rsp)
mov    %rax,0xf0(%rsp)
lea    (%r14,%rax,4),%rax
mov    %rax,0x140(%rsp)
mov    %rdx,0xe8(%rsp)
lea    (%r14,%rdx,4),%rax
mov    %rax,0xd0(%rsp)
lea    0x10(%rbx,%r13,4),%rcx
lea    0x10(%rbx,%rsi,4),%rdx
lea    (%r14,%r13,8),%rax
mov    %rax,0x158(%rsp)
lea    (%rbx,%r13,4),%r10
mov    %rbp,0xa8(%rsp)
lea    (%r14,%rbp,4),%rax
mov    %rax,0x150(%rsp)
lea    (%rbx,%rsi,4),%r15
mov    $0x1,%eax
mov    %rax,0xb0(%rsp)
xor    %eax,%eax
mov    %r13,0x100(%rsp)
mov    %rsi,0x168(%rsp)
mov    %rsi,0xf8(%rsp)
mov    %r13,0x78(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rbx,0x120(%rsp)
jmp    184f <radbg+0x72f>
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rsi
add    $0x1,%rsi
mov    0x178(%rsp),%rax
add    $0x1,%rax
mov    0x110(%rsp),%rcx
add    %rdi,%rcx
mov    0x28(%rsp),%rbp
mov    0x108(%rsp),%rdx
add    %rbp,%rdx
sub    %r13,0xf8(%rsp)
add    %r13,0x100(%rsp)
add    %rdi,%r10
add    %rbp,%r15
mov    %rsi,0xb0(%rsp)
cmp    0x170(%rsp),%rsi
je     207c <radbg+0xf5c>
mov    %rdx,0x108(%rsp)
mov    %rcx,0x110(%rsp)
mov    %rax,0x178(%rsp)
imul   %r13,%rax
lea    (%rax,%r13,1),%rcx
mov    0xf0(%rsp),%rdx
add    %rax,%rdx
mov    0x168(%rsp),%rsi
sub    %rax,%rsi
mov    0x160(%rsp),%rdi
sub    %rax,%rdi
lea    (%rbx,%rcx,4),%rax
mov    %rax,0x60(%rsp)
lea    (%rbx,%rdx,4),%rax
mov    %rax,0x40(%rsp)
lea    (%rbx,%rsi,4),%rax
mov    %rax,0x90(%rsp)
lea    (%rbx,%rdi,4),%rax
mov    %rax,0x58(%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   %r9d,%r9d
jle    196c <radbg+0x84c>
cmp    $0x4,%r9d
jae    1c10 <radbg+0xaf0>
xor    %r8d,%r8d
mov    0xf8(%rsp),%rax
add    %r8,%rax
lea    (%rbx,%rax,4),%r12
mov    0xe8(%rsp),%rax
add    %r8,%rax
lea    (%r14,%rax,4),%rsi
mov    0x100(%rsp),%rax
add    %r8,%rax
lea    (%rbx,%rax,4),%rbp
lea    0x0(%r13,%r8,1),%rax
lea    (%r14,%rax,4),%rax
lea    (%r14,%r8,4),%rcx
mov    %r11,%rdi
sub    %r8,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rcx,%rdx,4),%xmm3
movss  %xmm3,0x0(%rbp,%rdx,4)
movss  (%rsi,%rdx,4),%xmm3
mulss  %xmm4,%xmm3
movss  %xmm3,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1940 <radbg+0x820>
cmpl   $0x5,0x30(%rsp)
mov    0x38(%rsp),%rdi
mov    0x88(%rsp),%rdx
jb     17f0 <radbg+0x6d0>
xorps  %xmm8,%xmm4
movaps %xmm2,%xmm10
shufps $0x0,%xmm2,%xmm10
mov    0x58(%rsp),%rax
cmp    %rax,0x60(%rsp)
setb   %al
mov    0x90(%rsp),%rcx
cmp    0x40(%rsp),%rcx
setb   %cl
and    %al,%cl
mov    %cl,0x80(%rsp)
mov    $0x2,%ecx
mov    0x150(%rsp),%r8
mov    0x158(%rsp),%rsi
xor    %r12d,%r12d
movaps %xmm2,%xmm6
jmp    19f9 <radbg+0x8d9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x1,%r12
add    %rdi,%rsi
add    0x28(%rsp),%r8
cmp    %rdx,%rcx
je     17f0 <radbg+0x6d0>
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   %r9d,%r9d
jle    19e0 <radbg+0x8c0>
movaps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm7
cmp    $0x4,%r9d
jae    1a30 <radbg+0x910>
xor    %ebp,%ebp
jmp    1bd0 <radbg+0xab0>
nopl   (%rax)
mov    %r12,%rax
imul   %r13,%rax
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rax,1),%r9
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,1),%r13
mov    0xa8(%rsp),%rbp
sub    %rax,%rbp
mov    0x180(%rsp),%rdx
sub    %rax,%rdx
lea    (%r14,%r9,4),%r9
lea    (%r14,%r13,4),%rax
lea    (%r14,%rbp,4),%r13
lea    (%r14,%rdx,4),%rbp
mov    0x60(%rsp),%rbx
cmp    %rax,%rbx
setb   %dl
mov    0x40(%rsp),%rdi
cmp    %rdi,%r9
setb   %r14b
and    %dl,%r14b
or     0x80(%rsp),%r14b
cmp    %rbp,%rbx
setb   %dl
cmp    %rdi,%r13
setb   0x18(%rsp)
mov    0x90(%rsp),%rbx
cmp    %rax,%rbx
setb   %al
mov    0x58(%rsp),%rdi
cmp    %rdi,%r9
setb   0x10(%rsp)
cmp    %rbp,%rbx
setb   %r9b
cmp    %rdi,%r13
setb   %r13b
test   %r14b,%r14b
jne    1b82 <radbg+0xa62>
and    0x18(%rsp),%dl
mov    0x120(%rsp),%rbx
jne    1baa <radbg+0xa8a>
and    0x10(%rsp),%al
mov    0x20(%rsp),%r14
mov    0x88(%rsp),%rdx
jne    1b6f <radbg+0xa4f>
mov    $0x0,%ebp
and    %r13b,%r9b
mov    0x70(%rsp),%r9d
mov    0x78(%rsp),%r13
mov    0x38(%rsp),%rdi
jne    1bd0 <radbg+0xab0>
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
xor    %eax,%eax
mov    0x118(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm1
mulps  %xmm3,%xmm1
movups (%r10,%rax,4),%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%r10,%rax,4)
movups (%r8,%rax,4),%xmm1
movups (%r15,%rax,4),%xmm5
mulps  %xmm7,%xmm1
addps  %xmm5,%xmm1
movups %xmm1,(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1b30 <radbg+0xa10>
mov    %rbp,%rax
cmp    %r11,%rbp
jne    1bd0 <radbg+0xab0>
jmp    19e0 <radbg+0x8c0>
xor    %ebp,%ebp
mov    0x70(%rsp),%r9d
mov    0x78(%rsp),%r13
mov    0x38(%rsp),%rdi
jmp    1bd0 <radbg+0xab0>
xor    %ebp,%ebp
mov    0x20(%rsp),%r14
mov    0x70(%rsp),%r9d
mov    0x78(%rsp),%r13
mov    0x38(%rsp),%rdi
mov    0x88(%rsp),%rdx
mov    0x120(%rsp),%rbx
jmp    1bd0 <radbg+0xab0>
xor    %ebp,%ebp
mov    0x20(%rsp),%r14
mov    0x70(%rsp),%r9d
mov    0x78(%rsp),%r13
mov    0x38(%rsp),%rdi
mov    0x88(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbp,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%r10,%rbp,4),%xmm1
movss  %xmm1,(%r10,%rbp,4)
movss  (%r8,%rbp,4),%xmm1
mulss  %xmm7,%xmm1
addss  (%r15,%rbp,4),%xmm1
movss  %xmm1,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1bd0 <radbg+0xab0>
jmp    19e0 <radbg+0x8c0>
nopl   0x0(%rax)
mov    0x60(%rsp),%rbp
mov    0x58(%rsp),%rcx
cmp    %rcx,%rbp
setb   0x18(%rsp)
mov    0x40(%rsp),%r8
mov    0x90(%rsp),%rdx
cmp    %r8,%rdx
setb   0x10(%rsp)
mov    0xe0(%rsp),%rax
cmp    %rax,%rbp
setb   %r9b
cmp    %r14,%r8
seta   0x80(%rsp)
mov    0x140(%rsp),%rdi
cmp    %rdi,%rbp
setb   0x6f(%rsp)
mov    0xd8(%rsp),%r12
cmp    %r8,%r12
setb   0x6e(%rsp)
mov    0x148(%rsp),%rsi
cmp    %rsi,%rbp
setb   0x6d(%rsp)
mov    0xd0(%rsp),%rbp
cmp    %r8,%rbp
setb   %r8b
cmp    %rax,%rdx
setb   %al
cmp    %r14,%rcx
seta   0x6c(%rsp)
cmp    %rdi,%rdx
setb   %dil
cmp    %rcx,%r12
setb   %r12b
cmp    %rsi,%rdx
setb   %sil
cmp    %rcx,%rbp
setb   %cl
mov    0x10(%rsp),%dl
test   %dl,0x18(%rsp)
jne    1e23 <radbg+0xd03>
and    0x80(%rsp),%r9b
mov    0x70(%rsp),%r9d
jne    18ed <radbg+0x7cd>
mov    0x6e(%rsp),%dl
and    %dl,0x6f(%rsp)
jne    18ed <radbg+0x7cd>
and    %r8b,0x6d(%rsp)
jne    18ed <radbg+0x7cd>
and    0x6c(%rsp),%al
jne    18ed <radbg+0x7cd>
and    %r12b,%dil
jne    18ed <radbg+0x7cd>
mov    $0x0,%r8d
and    %cl,%sil
jne    18f0 <radbg+0x7d0>
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
cmpq   $0x0,0x138(%rsp)
mov    0x110(%rsp),%rdi
mov    0x108(%rsp),%rbp
je     1dae <radbg+0xc8e>
mov    0x128(%rsp),%rdx
xor    %ecx,%ecx
mov    0xd8(%rsp),%rax
mov    0xd0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r14,%rcx,4),%xmm3
movups (%rax,%rcx,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,-0x10(%rdi,%rcx,4)
movups (%rsi,%rcx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,-0x10(%rbp,%rcx,4)
movups 0x10(%r14,%rcx,4),%xmm3
movups 0x10(%rax,%rcx,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,(%rdi,%rcx,4)
movups 0x10(%rsi,%rcx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,0x0(%rbp,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1d60 <radbg+0xc40>
jmp    1db0 <radbg+0xc90>
xor    %ecx,%ecx
testb  $0x1,0x130(%rsp)
01
mov    0x118(%rsp),%rdi
je     1e12 <radbg+0xcf2>
mov    0xc8(%rsp),%rax
mov    0xb0(%rsp),%rdx
sub    %rdx,%rax
imul   %r13,%rdx
imul   %r13,%rax
movups (%r14,%rcx,4),%xmm3
lea    (%rcx,%r13,1),%rsi
movups (%r14,%rsi,4),%xmm6
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
add    %rcx,%rdx
movups %xmm5,(%rbx,%rdx,4)
mov    0xe8(%rsp),%rdx
add    %rcx,%rdx
movups (%r14,%rdx,4),%xmm3
mulps  %xmm4,%xmm3
add    %rcx,%rax
movups %xmm3,(%rbx,%rax,4)
mov    %rdi,%r8
cmp    %r11,%rdi
jne    18f0 <radbg+0x7d0>
jmp    196c <radbg+0x84c>
xor    %r8d,%r8d
mov    0x70(%rsp),%r9d
jmp    18f0 <radbg+0x7d0>
mov    0xa4(%rsp),%eax
cmp    0xc(%rsp),%eax
jge    22b3 <radbg+0x1193>
cmpl   $0x3,0x30(%rsp)
mov    0x48(%rsp),%r11
jl     287e <radbg+0x175e>
mov    0x30(%rsp),%r8
mov    %r8d,%eax
movslq %r11d,%rbp
mov    0xc(%rsp),%edx
movslq %edx,%rcx
mov    0x54(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%edi
cmovge %esi,%edi
mov    %rdi,0x80(%rsp)
mov    %edx,%edx
mov    %rdx,0x60(%rsp)
lea    -0x1(%rax),%rdx
imul   %rbp,%rcx
imul   %rcx,%rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0x58(%rsp)
lea    0x0(,%rcx,4),%rdx
mov    %rdx,0x78(%rsp)
neg    %rdx
mov    %rdx,0xa8(%rsp)
lea    0x0(,%rbp,4),%rdx
lea    (%rsi,%rcx,4),%rcx
add    $0x8,%rcx
mov    %rcx,0x40(%rsp)
lea    (%r11,%r11,1),%ecx
mov    %ecx,0xc0(%rsp)
mov    %r8d,%edi
imul   %r11d,%edi
lea    (%r11,%r11,1),%ecx
add    $0xfffffffd,%ecx
mov    %ecx,0x38(%rsp)
lea    0x8(%rbx,%rbp,8),%rcx
mov    %rcx,0x88(%rsp)
lea    0x0(,%rbp,8),%rcx
mov    %rcx,0xb8(%rsp)
mov    %rbp,0x18(%rsp)
imul   %rbp,%rax
shl    $0x2,%rax
mov    $0x1,%esi
mov    %r11d,%ecx
mov    %r11d,0x10(%rsp)
jmp    1f85 <radbg+0xe65>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x90(%rsp),%rsi
add    $0x1,%rsi
mov    0xa8(%rsp),%rcx
add    %rcx,0x58(%rsp)
mov    0x40(%rsp),%rcx
add    0x78(%rsp),%rcx
mov    %rcx,0x40(%rsp)
mov    0xc0(%rsp),%ecx
add    %ecx,0x10(%rsp)
add    %ecx,0x38(%rsp)
mov    0xb8(%rsp),%rcx
add    %rcx,0x88(%rsp)
cmp    0x80(%rsp),%rsi
je     1615 <radbg+0x4f5>
mov    %rsi,0x90(%rsp)
cmpl   $0x3,0x48(%rsp)
jl     1f30 <radbg+0xe10>
mov    $0x2,%r10d
mov    0x88(%rsp),%rcx
mov    %rcx,0x28(%rsp)
mov    0x38(%rsp),%r12d
mov    0x40(%rsp),%r15
mov    0x58(%rsp),%r11
jmp    1fe1 <radbg+0xec1>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r10
add    $0x8,%r11
add    $0x8,%r15
add    $0xfffffffe,%r12d
addq   $0x8,0x28(%rsp)
cmp    0x18(%rsp),%r10
jge    1f30 <radbg+0xe10>
cmpl   $0x0,0xc(%rsp)
jle    1fc0 <radbg+0xea0>
mov    0x18(%rsp),%rbp
sub    %r10,%rbp
mov    0x60(%rsp),%rsi
mov    0x28(%rsp),%r13
mov    %r12d,%r14d
mov    0x10(%rsp),%ecx
mov    %ecx,%r8d
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%r13),%xmm1
movslq %r14d,%r14
addss  (%rbx,%r14,4),%xmm1
movss  %xmm1,-0x4(%r15,%rcx,1)
movss  -0x4(%r13),%xmm1
subss  (%rbx,%r14,4),%xmm1
movss  %xmm1,-0x4(%r11,%rcx,1)
movss  0x0(%r13),%xmm1
movslq %r8d,%r8
lea    0x0(%rbp,%r8,1),%r9
subss  (%rbx,%r9,4),%xmm1
movss  %xmm1,(%r15,%rcx,1)
movss  0x0(%r13),%xmm1
addss  (%rbx,%r9,4),%xmm1
movss  %xmm1,(%r11,%rcx,1)
add    %rdx,%rcx
add    %edi,%r8d
add    %edi,%r14d
add    %rax,%r13
add    $0xffffffffffffffff,%rsi
jne    2010 <radbg+0xef0>
jmp    1fc0 <radbg+0xea0>
cmpl   $0x3,0x30(%rsp)
jl     259a <radbg+0x147a>
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r15d
cmovge %eax,%r15d
mov    %r11d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x10(%rsp)
mov    %r11,%r14
neg    %r14
mov    0x20(%rsp),%rax
lea    (%rax,%r13,4),%rsi
add    $0x30,%rsi
lea    (%rax,%r13,4),%rdx
add    $0x4,%rdx
mov    $0x1,%ecx
xor    %r13d,%r13d
mov    0x70(%rsp),%r9d
mov    0x78(%rsp),%r10
jmp    2117 <radbg+0xff7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
add    $0x1,%r13
add    %rdi,%rsi
add    %rdi,%rdx
cmp    %r15,%rcx
je     24d5 <radbg+0x13b5>
test   %r9d,%r9d
jle    2100 <radbg+0xfe0>
mov    %rcx,%r12
imul   %r10,%r12
cmp    $0x8,%r9d
jae    2130 <radbg+0x1010>
xor    %ebp,%ebp
jmp    2230 <radbg+0x1110>
mov    %r13,%rax
imul   %r10,%rax
mov    0xf0(%rsp),%rdi
lea    (%rdi,%rax,1),%rbp
mov    0x20(%rsp),%rdi
lea    (%rdi,%rbp,4),%rbp
cmp    %rdi,%rbp
jbe    216e <radbg+0x104e>
add    %r10,%rax
lea    (%rdi,%rax,4),%rax
cmp    0xe0(%rsp),%rax
jae    216e <radbg+0x104e>
xor    %ebp,%ebp
mov    0x38(%rsp),%rdi
jmp    2230 <radbg+0x1110>
cmpq   $0x0,0x28(%rsp)
je     22a1 <radbg+0x1181>
mov    0x10(%rsp),%rax
xor    %ebp,%ebp
mov    0x20(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rsi,%rbp,4),%xmm0
movups -0x20(%rsi,%rbp,4),%xmm1
movups (%r9,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r9,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%r9,%rbp,4),%xmm1
movups 0x30(%r9,%rbp,4),%xmm3
movups %xmm2,(%r9,%rbp,4)
movups %xmm0,0x10(%r9,%rbp,4)
movups -0x10(%rsi,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups (%rsi,%rbp,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%r9,%rbp,4)
movups %xmm1,0x30(%r9,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rax
jne    2190 <radbg+0x1070>
testb  $0x1,0x18(%rsp)
je     2218 <radbg+0x10f8>
lea    (%r12,%rbp,1),%rax
mov    0x20(%rsp),%rdi
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups (%rdi,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdi,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdi,%rbp,4)
movups %xmm0,0x10(%rdi,%rbp,4)
mov    %r8,%rbp
cmp    %r11,%r8
mov    0x70(%rsp),%r9d
mov    0x38(%rsp),%rdi
je     2100 <radbg+0xfe0>
xchg   %ax,%ax
mov    %rbp,%rax
test   $0x1,%r11b
je     2258 <radbg+0x1138>
add    %rbp,%r12
mov    0x20(%rsp),%rax
movss  (%rax,%r12,4),%xmm0
addss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    %r14,%rbp
mov    0x20(%rsp),%rbp
je     2100 <radbg+0xfe0>
nopl   0x0(%rax)
movss  -0x4(%rdx,%rax,4),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  (%rdx,%rax,4),%xmm0
addss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    2270 <radbg+0x1150>
jmp    2100 <radbg+0xfe0>
xor    %ebp,%ebp
testb  $0x1,0x18(%rsp)
jne    21ee <radbg+0x10ce>
jmp    2218 <radbg+0x10f8>
cmpl   $0x3,0x30(%rsp)
mov    0x48(%rsp),%r11
jl     287e <radbg+0x175e>
movslq %r11d,%rax
mov    0x30(%rsp),%r8
mov    %r8d,%ecx
mov    0xc(%rsp),%edx
movslq %edx,%rdi
mov    0x54(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%ebp
cmovge %esi,%ebp
mov    %rbp,0x38(%rsp)
mov    %edx,%esi
lea    -0x1(%rcx),%rdx
imul   %rax,%rdi
imul   %rdi,%rdx
mov    0x20(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
mov    %rdx,0x60(%rsp)
lea    0x0(,%rdi,4),%rdx
mov    %rdx,0x88(%rsp)
neg    %rdx
mov    %rdx,0x80(%rsp)
lea    0x0(,%rax,4),%rdx
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
mov    %rdi,0x18(%rsp)
lea    (%rbx,%rax,8),%rdi
mov    %rdi,0x40(%rsp)
lea    0x0(,%rax,8),%rdi
mov    %rdi,0x78(%rsp)
imul   %rax,%rcx
shl    $0x2,%rcx
lea    (%r11,%r11,1),%edi
mov    %edi,0xa8(%rsp)
lea    (%r11,%r11,1),%edi
add    $0xfffffffd,%edi
mov    %edi,0x90(%rsp)
imul   %r11d,%r8d
lea    -0x8(%rbx),%rdi
mov    %rdi,0x28(%rsp)
mov    $0x1,%ebp
mov    %r11d,%edi
mov    %r11d,0x58(%rsp)
jmp    23ef <radbg+0x12cf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rbp
add    $0x1,%rbp
mov    0x80(%rsp),%rdi
add    %rdi,0x60(%rsp)
mov    0x18(%rsp),%rdi
add    0x88(%rsp),%rdi
mov    %rdi,0x18(%rsp)
mov    0x78(%rsp),%rdi
add    %rdi,0x40(%rsp)
mov    0xa8(%rsp),%edi
add    %edi,0x90(%rsp)
add    %edi,0x58(%rsp)
cmp    0x38(%rsp),%rbp
je     1615 <radbg+0x4f5>
mov    %rbp,0x10(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    23a0 <radbg+0x1280>
mov    0x58(%rsp),%r10d
mov    0x90(%rsp),%edi
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x60(%rsp),%r11
xor    %r12d,%r12d
jmp    243c <radbg+0x131c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %rdx,%r11
add    %rdx,%r14
add    %rcx,%r13
add    %r8d,%edi
add    %r8d,%r10d
cmp    %rsi,%r12
je     23a0 <radbg+0x1280>
cmpl   $0x3,0x48(%rsp)
jl     2420 <radbg+0x1300>
movslq %r10d,%rbp
add    %rax,%rbp
mov    %rdx,%r9
mov    %rsi,%rdx
mov    %rcx,%rsi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbp,4),%rbp
mov    %rsi,%rcx
mov    %rdx,%rsi
mov    %r9,%rdx
mov    $0x2,%r9d
mov    %edi,%r15d
nopl   (%rax)
movss  -0x4(%r13,%r9,4),%xmm1
movslq %r15d,%r15
addss  (%rbx,%r15,4),%xmm1
movss  %xmm1,-0x4(%r14,%r9,4)
movss  -0x4(%r13,%r9,4),%xmm1
subss  (%rbx,%r15,4),%xmm1
movss  %xmm1,-0x4(%r11,%r9,4)
movss  0x0(%r13,%r9,4),%xmm1
subss  0x0(%rbp),%xmm1
movss  %xmm1,(%r14,%r9,4)
movss  0x0(%r13,%r9,4),%xmm1
addss  0x0(%rbp),%xmm1
movss  %xmm1,(%r11,%r9,4)
add    $0x2,%r9
add    $0xfffffffe,%r15d
add    $0xfffffffffffffff8,%rbp
cmp    %rax,%r9
jl     2470 <radbg+0x1350>
jmp    2420 <radbg+0x1300>
cmpl   $0x3,0x30(%rsp)
mov    0xc(%rsp),%r12d
jl     259a <radbg+0x147a>
movslq 0x48(%rsp),%r15
movslq %r12d,%rax
mov    0x54(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%r9d
cmovge %ecx,%r9d
mov    %r12d,%r8d
mov    0xc8(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
imul   %r15,%rax
imul   %rax,%rcx
lea    (%rbx,%rcx,4),%rsi
lea    0x0(,%rax,4),%r10
mov    %r10,%r11
neg    %r11
shl    $0x2,%r15
mov    0x20(%rsp),%rdi
lea    (%rdi,%rcx,4),%rdx
lea    (%rbx,%rax,4),%rcx
lea    (%rdi,%rax,4),%rbp
mov    $0x1,%r14d
jmp    2565 <radbg+0x1445>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
add    %r11,%rsi
add    %r11,%rdx
add    %r10,%rcx
add    %r10,%rbp
cmp    %r9,%r14
je     259a <radbg+0x147a>
test   %r12d,%r12d
jle    2550 <radbg+0x1430>
mov    %r8,%rdi
xor    %eax,%eax
nop
movss  (%rcx,%rax,1),%xmm0
subss  (%rsi,%rax,1),%xmm0
movss  %xmm0,0x0(%rbp,%rax,1)
movss  (%rcx,%rax,1),%xmm0
addss  (%rsi,%rax,1),%xmm0
movss  %xmm0,(%rdx,%rax,1)
add    %r15,%rax
add    $0xffffffffffffffff,%rdi
jne    2570 <radbg+0x1450>
jmp    2550 <radbg+0x1430>
mov    0x48(%rsp),%r11
cmp    $0x1,%r11d
je     2ef8 <radbg+0x1dd8>
mov    0xa4(%rsp),%eax
cmp    0xc(%rsp),%eax
jge    272c <radbg+0x160c>
cmpl   $0x3,0x30(%rsp)
jl     287e <radbg+0x175e>
movslq %r11d,%rax
mov    0x30(%rsp),%edx
mov    0xc(%rsp),%ecx
movslq %ecx,%rsi
mov    0x54(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,0x18(%rsp)
mov    %ecx,%r10d
add    $0xffffffffffffffff,%rdx
imul   %rax,%rsi
imul   %rsi,%rdx
mov    0x20(%rsp),%rdi
lea    (%rdi,%rdx,4),%rcx
add    $0x8,%rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%rsi,4),%rcx
mov    %rcx,0x10(%rsp)
neg    %rcx
mov    %rcx,0x60(%rsp)
lea    0x0(,%rax,4),%rcx
lea    (%rbx,%rdx,4),%r8
add    $0x8,%r8
lea    (%rbx,%rsi,4),%r15
add    $0x8,%r15
lea    (%rdi,%rsi,4),%r12
add    $0x8,%r12
mov    $0x1,%r13d
jmp    267c <radbg+0x155c>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
mov    0x60(%rsp),%rdx
add    %rdx,0x28(%rsp)
add    %rdx,%r8
mov    0x10(%rsp),%rdx
add    %rdx,%r15
add    %rdx,%r12
cmp    0x18(%rsp),%r13
mov    0x48(%rsp),%r11
je     287e <radbg+0x175e>
cmp    $0x3,%r11d
jl     2650 <radbg+0x1530>
mov    $0x2,%ebp
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r8,%r14
mov    0x28(%rsp),%r11
jmp    26b9 <radbg+0x1599>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rbp
add    $0x8,%r11
add    $0x8,%r14
add    $0x8,%rsi
add    $0x8,%rdi
cmp    %rax,%rbp
jge    2650 <radbg+0x1530>
cmpl   $0x0,0xc(%rsp)
jle    26a0 <radbg+0x1580>
mov    %r10,%rdx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rsi,%r9,1),%xmm0
subss  (%r14,%r9,1),%xmm0
movss  %xmm0,-0x4(%rdi,%r9,1)
movss  -0x4(%rsi,%r9,1),%xmm0
addss  (%r14,%r9,1),%xmm0
movss  %xmm0,-0x4(%r11,%r9,1)
movss  (%rsi,%r9,1),%xmm0
addss  -0x4(%r14,%r9,1),%xmm0
movss  %xmm0,(%rdi,%r9,1)
movss  (%rsi,%r9,1),%xmm0
subss  -0x4(%r14,%r9,1),%xmm0
movss  %xmm0,(%r11,%r9,1)
add    %rcx,%r9
add    $0xffffffffffffffff,%rdx
jne    26d0 <radbg+0x15b0>
jmp    26a0 <radbg+0x1580>
cmpl   $0x3,0x30(%rsp)
jl     287e <radbg+0x175e>
movslq %r11d,%rax
mov    0x30(%rsp),%esi
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
mov    0x54(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%ebp
cmovge %edx,%ebp
mov    %rbp,0x28(%rsp)
mov    %ecx,%edx
imul   %rax,%rdi
lea    (%rbx,%rdi,4),%r8
lea    0x0(,%rdi,4),%rbp
lea    0x0(,%rax,4),%rcx
mov    0x20(%rsp),%r9
lea    (%r9,%rdi,4),%r14
add    $0xffffffffffffffff,%rsi
imul   %rdi,%rsi
lea    (%rbx,%rsi,4),%r15
mov    %rbp,0x18(%rsp)
neg    %rbp
mov    %rbp,0x10(%rsp)
lea    (%r9,%rsi,4),%r12
mov    $0x1,%r13d
jmp    27d5 <radbg+0x16b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x18(%rsp),%rsi
add    %rsi,%r8
add    %rsi,%r14
mov    0x10(%rsp),%rsi
add    %rsi,%r15
add    %rsi,%r12
cmp    0x28(%rsp),%r13
je     287e <radbg+0x175e>
cmpl   $0x0,0xc(%rsp)
jle    27b0 <radbg+0x1690>
mov    %r12,%rdi
mov    %r15,%rbp
mov    %r14,%rsi
mov    %r8,%r10
xor    %r9d,%r9d
jmp    280a <radbg+0x16ea>
nopl   (%rax)
add    $0x1,%r9
add    %rcx,%r10
add    %rcx,%rsi
add    %rcx,%rbp
add    %rcx,%rdi
cmp    %rdx,%r9
mov    0x48(%rsp),%r11
je     27b0 <radbg+0x1690>
cmp    $0x3,%r11d
jl     27f0 <radbg+0x16d0>
mov    $0x2,%r11d
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%r10,%r11,4),%xmm0
subss  0x0(%rbp,%r11,4),%xmm0
movss  %xmm0,-0x4(%rsi,%r11,4)
movss  -0x4(%r10,%r11,4),%xmm0
addss  0x0(%rbp,%r11,4),%xmm0
movss  %xmm0,-0x4(%rdi,%r11,4)
movss  (%r10,%r11,4),%xmm0
addss  -0x4(%rbp,%r11,4),%xmm0
movss  %xmm0,(%rsi,%r11,4)
movss  (%r10,%r11,4),%xmm0
subss  -0x4(%rbp,%r11,4),%xmm0
movss  %xmm0,(%rdi,%r11,4)
add    $0x2,%r11
cmp    %rax,%r11
jl     2820 <radbg+0x1700>
jmp    27f0 <radbg+0x16d0>
mov    0x70(%rsp),%ecx
test   %ecx,%ecx
mov    0x20(%rsp),%rax
jle    2a14 <radbg+0x18f4>
mov    %ecx,%r8d
cmp    $0x8,%ecx
jb     28ad <radbg+0x178d>
lea    (%rax,%r8,4),%rcx
cmp    %rbx,%rcx
jbe    292c <radbg+0x180c>
lea    (%rbx,%r8,4),%rcx
cmp    %rax,%rcx
jbe    292c <radbg+0x180c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     28e4 <radbg+0x17c4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    28d0 <radbg+0x17b0>
cmp    $0x3,%rdx
jb     2a14 <radbg+0x18f4>
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movss  0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    28f0 <radbg+0x17d0>
jmp    2a14 <radbg+0x18f4>
mov    %r8d,%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    2950 <radbg+0x1830>
xor    %edi,%edi
jmp    29c8 <radbg+0x18a8>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups 0x60(%rax,%rdi,4),%xmm0
movups 0x70(%rax,%rdi,4),%xmm1
movups %xmm0,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2970 <radbg+0x1850>
test   %rdx,%rdx
je     2a0b <radbg+0x18eb>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    29f0 <radbg+0x18d0>
cmp    %r8,%rcx
jne    28af <radbg+0x178f>
cmpl   $0x2,0x30(%rsp)
jl     2ef8 <radbg+0x1dd8>
movslq %r11d,%rax
mov    0xc(%rsp),%ecx
movslq %ecx,%rbp
mov    %ecx,%r14d
mov    %r14d,%ecx
and    $0x3,%ecx
mov    %rcx,0x90(%rsp)
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x80(%rsp)
lea    0x2(%rbp),%rcx
imul   %rax,%rcx
lea    (%rbx,%rcx,4),%rdx
mov    %rdx,0x78(%rsp)
mov    %rbp,%rdx
imul   %rax,%rdx
lea    0x0(,%rdx,4),%rsi
mov    %rsi,0x38(%rsp)
mov    %rax,%rsi
shl    $0x4,%rsi
mov    %rsi,0xa8(%rsp)
mov    0x20(%rsp),%rdi
lea    (%rdi,%rcx,4),%r15
lea    0x1(%rbp),%rsi
imul   %rax,%rsi
lea    (%rbx,%rsi,4),%r13
lea    (%rdi,%rsi,4),%r8
lea    0x3(%rbp),%rsi
imul   %rax,%rsi
lea    (%rbx,%rsi,4),%r9
lea    (%rdi,%rsi,4),%r11
lea    (%rdi,%rdx,4),%r10
lea    (%rbx,%rdx,4),%rdi
mov    0x1c0(%rsp),%rdx
mov    0x30(%rsp),%ecx
mov    %rcx,0x60(%rsp)
mov    %r14,0x28(%rsp)
lea    -0x1(%r14),%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rax,4),%r12
mov    $0x1,%r14d
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r12,0x88(%rsp)
jmp    2b2d <radbg+0x1a0d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
mov    0x10(%rsp),%rcx
add    0x38(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0x18(%rsp),%rcx
add    0x58(%rsp),%rcx
mov    %rcx,0x18(%rsp)
cmp    0x60(%rsp),%r14
je     2bf8 <radbg+0x1ad8>
cmpl   $0x0,0xc(%rsp)
jle    2b00 <radbg+0x19e0>
mov    %r14,0x40(%rsp)
cmpq   $0x3,0x70(%rsp)
jae    2b50 <radbg+0x1a30>
xor    %ebp,%ebp
jmp    2bad <radbg+0x1a8d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%r14
xor    %ebp,%ebp
mov    0x80(%rsp),%rcx
mov    0x78(%rsp),%rsi
mov    0xa8(%rsp),%r12
nopl   0x0(%rax)
movss  (%r10,%r14,1),%xmm0
movss  %xmm0,(%rdi,%r14,1)
movss  (%r8,%r14,1),%xmm0
movss  %xmm0,0x0(%r13,%r14,1)
movss  (%r15,%r14,1),%xmm0
movss  %xmm0,(%rsi,%r14,1)
movss  (%r11,%r14,1),%xmm0
movss  %xmm0,(%r9,%r14,1)
add    $0x4,%rbp
add    %r12,%r14
cmp    %rbp,%rcx
jne    2b70 <radbg+0x1a50>
cmpq   $0x0,0x90(%rsp)
mov    0x20(%rsp),%rcx
mov    0x88(%rsp),%r12
mov    0x40(%rsp),%r14
je     2b00 <radbg+0x19e0>
add    0x18(%rsp),%rbp
imul   %r12,%rbp
mov    0x90(%rsp),%rsi
nop
movss  (%rcx,%rbp,1),%xmm0
movss  %xmm0,(%rbx,%rbp,1)
add    %r12,%rbp
add    $0xffffffffffffffff,%rsi
jne    2be0 <radbg+0x1ac0>
jmp    2b00 <radbg+0x19e0>
mov    0xa4(%rsp),%ecx
cmp    0xc(%rsp),%ecx
jle    2d90 <radbg+0x1c70>
cmpl   $0x2,0x30(%rsp)
mov    0x48(%rsp),%rdi
jl     2ef8 <radbg+0x1dd8>
movslq 0xc(%rsp),%rsi
imul   %rax,%rsi
mov    %rsi,%rcx
shl    $0x20,%rcx
movabs $0x100000000,%rbp
mov    %rcx,0x80(%rsp)
add    %rcx,%rbp
mov    %rbp,0x10(%rsp)
mov    %rax,%rcx
shl    $0x20,%rcx
mov    %rcx,0x18(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x58(%rsp)
lea    (%rbx,%rsi,4),%rcx
mov    %rcx,0x38(%rsp)
shl    $0x2,%rsi
mov    %rsi,0x70(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x40(%rsp)
mov    $0x1,%esi
movabs $0x200000000,%r9
mov    0x20(%rsp),%r8
jmp    2cd4 <radbg+0x1bb4>
nopl   0x0(%rax)
mov    0x90(%rsp),%rsi
add    $0x1,%rsi
mov    0x40(%rsp),%rcx
add    %edi,%ecx
mov    %rcx,0x40(%rsp)
mov    0x10(%rsp),%rcx
add    0x80(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0x70(%rsp),%rcx
add    %rcx,0x58(%rsp)
add    %rcx,0x38(%rsp)
cmp    0x60(%rsp),%rsi
je     2ef8 <radbg+0x1dd8>
mov    %rsi,0x90(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    2c90 <radbg+0x1b70>
movslq 0x40(%rsp),%rcx
lea    (%rdx,%rcx,4),%rbp
mov    0x38(%rsp),%rsi
mov    0x58(%rsp),%rcx
mov    0x10(%rsp),%r13
xor    %r10d,%r10d
jmp    2d1f <radbg+0x1bff>
add    $0x1,%r10
add    0x18(%rsp),%r13
add    %r12,%rcx
add    %r12,%rsi
cmp    0x28(%rsp),%r10
mov    0x48(%rsp),%rdi
je     2c90 <radbg+0x1b70>
cmp    $0x3,%edi
jl     2d00 <radbg+0x1be0>
mov    $0x2,%r14d
mov    %r13,%r15
nopl   (%rax)
movss  -0x4(%rbp,%r14,4),%xmm0
mov    %r15,%r11
movss  (%rcx,%r14,4),%xmm1
mulss  0x0(%rbp,%r14,4),%xmm1
sar    $0x1e,%r11
mulss  (%r8,%r11,1),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%r11,1)
movss  0x0(%rbp,%r14,4),%xmm0
mulss  (%r8,%r11,1),%xmm0
movss  -0x4(%rbp,%r14,4),%xmm1
mulss  (%rcx,%r14,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%r14,4)
add    $0x2,%r14
add    %r9,%r15
cmp    %rax,%r14
jl     2d30 <radbg+0x1c10>
jmp    2d00 <radbg+0x1be0>
cmpl   $0x2,0x30(%rsp)
mov    0x48(%rsp),%rsi
jl     2ef8 <radbg+0x1dd8>
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
imul   %esi,%ecx
mov    %rcx,0x38(%rsp)
add    $0x1,%ecx
mov    %ecx,0x18(%rsp)
imul   %rax,%rdi
mov    0x20(%rsp),%rcx
lea    (%rcx,%rdi,4),%rcx
mov    %rcx,0x10(%rsp)
lea    (%rbx,%rdi,4),%rcx
mov    %rcx,0x40(%rsp)
shl    $0x2,%rdi
mov    %rdi,0x58(%rsp)
movl   $0xffffffff,0x90(%rsp)
ff ff ff ff
mov    $0x1,%r12d
mov    0x20(%rsp),%r15
mov    0x48(%rsp),%r8
jmp    2e36 <radbg+0x1d16>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x48(%rsp),%rsi
add    %esi,0x90(%rsp)
mov    0x18(%rsp),%ecx
add    0x38(%rsp),%ecx
mov    %ecx,0x18(%rsp)
mov    0x58(%rsp),%rcx
add    %rcx,0x10(%rsp)
add    %rcx,0x40(%rsp)
cmp    0x60(%rsp),%r12
je     2ef8 <radbg+0x1dd8>
cmp    $0x3,%esi
jl     2e00 <radbg+0x1ce0>
movslq 0x90(%rsp),%rbp
mov    $0x2,%esi
mov    0x40(%rsp),%rdi
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%r13d
jmp    2e78 <radbg+0x1d58>
nopl   0x0(%rax)
add    $0x2,%rsi
add    $0x2,%r13d
add    $0x8,%rcx
add    $0x8,%rdi
mov    %r9,%rbp
cmp    %rax,%rsi
jge    2e00 <radbg+0x1ce0>
lea    0x2(%rbp),%r9
cmpl   $0x0,0xc(%rsp)
jle    2e60 <radbg+0x1d40>
mov    $0x2,%r10d
mov    0x28(%rsp),%r11
mov    %r13d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x4(%rdx,%rbp,4),%xmm0
movss  (%rcx,%r10,4),%xmm1
mulss  (%rdx,%r9,4),%xmm1
movslq %r14d,%r14
mulss  (%r15,%r14,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rbx,%r14,4)
movss  (%rdx,%r9,4),%xmm0
mulss  (%r15,%r14,4),%xmm0
movss  0x4(%rdx,%rbp,4),%xmm1
mulss  (%rcx,%r10,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%r10,4)
add    %r8d,%r14d
add    %rax,%r10
add    $0xffffffffffffffff,%r11
jne    2ea0 <radbg+0x1d80>
jmp    2e60 <radbg+0x1d40>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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