#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 dradbg(int ido, int ip, int l1, int idl1, float *cc, float *c1, float *c2,
            float *ch, float *ch2, float *wa) {
  static float tpi = 6.283185307179586f;
  int idij, ipph, i, j, k, l, ik, is, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9,
      t10, t11, t12;
  float dc2, ai1, ai2, ar1, ar2, ds2;
  int nbd;
  float dcp, arg, dsp, ar1h, ar2h;
  int ipp2;
  t10 = ip * ido;
  t0 = l1 * ido;
  arg = tpi / (float)ip;
  dcp = cos(arg);
  dsp = sin(arg);
  nbd = (ido - 1) >> 1;
  ipp2 = ip;
  ipph = (ip + 1) >> 1;
  if (ido < l1)
    goto L103;
  t1 = 0;
  t2 = 0;
  for (k = 0; k < l1; k++) {
    t3 = t1;
    t4 = t2;
    for (i = 0; i < ido; i++) {
      ch[t3] = cc[t4];
      t3++;
      t4++;
    }
    t1 += ido;
    t2 += t10;
  }
  goto L106;
L103:
  t1 = 0;
  for (i = 0; i < ido; i++) {
    t2 = t1;
    t3 = t1;
    for (k = 0; k < l1; k++) {
      ch[t2] = cc[t3];
      t2 += ido;
      t3 += t10;
    }
    t1++;
  }
L106:
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = (t5 = ido << 1);
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t6 = t5;
    for (k = 0; k < l1; k++) {
      ch[t3] = cc[t6 - 1] + cc[t6 - 1];
      ch[t4] = cc[t6] + cc[t6];
      t3 += ido;
      t4 += ido;
      t6 += t10;
    }
    t5 += t7;
  }
  if (ido == 1)
    goto L116;
  if (nbd < l1)
    goto L112;
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t7 += (ido << 1);
    t8 = t7;
    for (k = 0; k < l1; k++) {
      t5 = t3;
      t6 = t4;
      t9 = t8;
      t11 = t8;
      for (i = 2; i < ido; i += 2) {
        t5 += 2;
        t6 += 2;
        t9 += 2;
        t11 -= 2;
        ch[t5 - 1] = cc[t9 - 1] + cc[t11 - 1];
        ch[t6 - 1] = cc[t9 - 1] - cc[t11 - 1];
        ch[t5] = cc[t9] - cc[t11];
        ch[t6] = cc[t9] + cc[t11];
      }
      t3 += ido;
      t4 += ido;
      t8 += t10;
    }
  }
  goto L116;
L112:
  t1 = 0;
  t2 = ipp2 * t0;
  t7 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    t7 += (ido << 1);
    t8 = t7;
    t9 = t7;
    for (i = 2; i < ido; i += 2) {
      t3 += 2;
      t4 += 2;
      t8 += 2;
      t9 -= 2;
      t5 = t3;
      t6 = t4;
      t11 = t8;
      t12 = t9;
      for (k = 0; k < l1; k++) {
        ch[t5 - 1] = cc[t11 - 1] + cc[t12 - 1];
        ch[t6 - 1] = cc[t11 - 1] - cc[t12 - 1];
        ch[t5] = cc[t11] - cc[t12];
        ch[t6] = cc[t11] + cc[t12];
        t5 += ido;
        t6 += ido;
        t11 += t10;
        t12 += t10;
      }
    }
  }
L116:
  ar1 = 1.f;
  ai1 = 0.f;
  t1 = 0;
  t9 = (t2 = ipp2 * idl1);
  t3 = (ip - 1) * idl1;
  for (l = 1; l < ipph; l++) {
    t1 += idl1;
    t2 -= idl1;
    ar1h = dcp * ar1 - dsp * ai1;
    ai1 = dcp * ai1 + dsp * ar1;
    ar1 = ar1h;
    t4 = t1;
    t5 = t2;
    t6 = 0;
    t7 = idl1;
    t8 = t3;
    for (ik = 0; ik < idl1; ik++) {
      c2[t4++] = ch2[t6++] + ar1 * ch2[t7++];
      c2[t5++] = ai1 * ch2[t8++];
    }
    dc2 = ar1;
    ds2 = ai1;
    ar2 = ar1;
    ai2 = ai1;
    t6 = idl1;
    t7 = t9 - idl1;
    for (j = 2; j < ipph; j++) {
      t6 += idl1;
      t7 -= idl1;
      ar2h = dc2 * ar2 - ds2 * ai2;
      ai2 = dc2 * ai2 + ds2 * ar2;
      ar2 = ar2h;
      t4 = t1;
      t5 = t2;
      t11 = t6;
      t12 = t7;
      for (ik = 0; ik < idl1; ik++) {
        c2[t4++] += ar2 * ch2[t11++];
        c2[t5++] += ai2 * ch2[t12++];
      }
    }
  }
  t1 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += idl1;
    t2 = t1;
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += ch2[t2++];
  }
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (k = 0; k < l1; k++) {
      ch[t3] = c1[t3] - c1[t4];
      ch[t4] = c1[t3] + c1[t4];
      t3 += ido;
      t4 += ido;
    }
  }
  if (ido == 1)
    goto L132;
  if (nbd < l1)
    goto L128;
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (k = 0; k < l1; k++) {
      t5 = t3;
      t6 = t4;
      for (i = 2; i < ido; i += 2) {
        t5 += 2;
        t6 += 2;
        ch[t5 - 1] = c1[t5 - 1] - c1[t6];
        ch[t6 - 1] = c1[t5 - 1] + c1[t6];
        ch[t5] = c1[t5] + c1[t6 - 1];
        ch[t6] = c1[t5] - c1[t6 - 1];
      }
      t3 += ido;
      t4 += ido;
    }
  }
  goto L132;
L128:
  t1 = 0;
  t2 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1;
    t4 = t2;
    for (i = 2; i < ido; i += 2) {
      t3 += 2;
      t4 += 2;
      t5 = t3;
      t6 = t4;
      for (k = 0; k < l1; k++) {
        ch[t5 - 1] = c1[t5 - 1] - c1[t6];
        ch[t6 - 1] = c1[t5 - 1] + c1[t6];
        ch[t5] = c1[t5] + c1[t6 - 1];
        ch[t6] = c1[t5] - c1[t6 - 1];
        t5 += ido;
        t6 += ido;
      }
    }
  }
L132:
  if (ido == 1)
    return;
  for (ik = 0; ik < idl1; ik++)
    c2[ik] = ch2[ik];
  t1 = 0;
  for (j = 1; j < ip; j++) {
    t2 = (t1 += t0);
    for (k = 0; k < l1; k++) {
      c1[t2] = ch[t2];
      t2 += ido;
    }
  }
  if (nbd > l1)
    goto L139;
  is = -ido - 1;
  t1 = 0;
  for (j = 1; j < ip; j++) {
    is += ido;
    t1 += t0;
    idij = is;
    t2 = t1;
    for (i = 2; i < ido; i += 2) {
      t2 += 2;
      idij += 2;
      t3 = t2;
      for (k = 0; k < l1; k++) {
        c1[t3 - 1] = wa[idij - 1] * ch[t3 - 1] - wa[idij] * ch[t3];
        c1[t3] = wa[idij - 1] * ch[t3] + wa[idij] * ch[t3 - 1];
        t3 += ido;
      }
    }
  }
  return;
L139:
  is = -ido - 1;
  t1 = 0;
  for (j = 1; j < ip; j++) {
    is += ido;
    t1 += t0;
    t2 = t1;
    for (k = 0; k < l1; k++) {
      idij = is;
      t3 = t2;
      for (i = 2; i < ido; i += 2) {
        idij += 2;
        t3 += 2;
        c1[t3 - 1] = wa[idij - 1] * ch[t3 - 1] - wa[idij] * ch[t3];
        c1[t3] = wa[idij - 1] * ch[t3] + wa[idij] * ch[t3 - 1];
      }
      t2 += ido;
    }
  }
}


x86 assembly (clang, -O0):
<dradbg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  0x3ec5(%rip),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
call   1040 <cos@plt>
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
call   1030 <sin@plt>
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11db <dradbg+0xbb>
jmp    127a <dradbg+0x15a>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1275 <dradbg+0x155>
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1255 <dradbg+0x135>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120f <dradbg+0xef>
mov    -0x4(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f0 <dradbg+0xd0>
jmp    1309 <dradbg+0x1e9>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1304 <dradbg+0x1e4>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ed <dradbg+0x1cd>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a7 <dradbg+0x187>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1288 <dradbg+0x168>
jmp    1309 <dradbg+0x1e9>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    %eax,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    140d <dradbg+0x2ed>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f6 <dradbg+0x2d6>
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1369 <dradbg+0x249>
mov    -0x60(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1330 <dradbg+0x210>
cmpl   $0x1,-0x4(%rbp)
jne    141c <dradbg+0x2fc>
jmp    17da <dradbg+0x6ba>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1430 <dradbg+0x310>
jmp    15fb <dradbg+0x4db>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15f6 <dradbg+0x4d6>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15e3 <dradbg+0x4c3>
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15ba <dradbg+0x49a>
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c2 <dradbg+0x3a2>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1497 <dradbg+0x377>
jmp    15e8 <dradbg+0x4c8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1452 <dradbg+0x332>
jmp    17da <dradbg+0x6ba>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    17d5 <dradbg+0x6b5>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17c2 <dradbg+0x6a2>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x64(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17af <dradbg+0x68f>
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16b7 <dradbg+0x597>
jmp    17b4 <dradbg+0x694>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1668 <dradbg+0x548>
jmp    17c7 <dradbg+0x6a7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    161d <dradbg+0x4fd>
jmp    17da <dradbg+0x6ba>
movss  0x181e(%rip),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b33 <dradbg+0xa13>
mov    -0x10(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1979 <dradbg+0x859>
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x5c(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x84(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18d7 <dradbg+0x7b7>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b20 <dradbg+0xa00>
mov    -0x10(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x60(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x60(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b0d <dradbg+0x9ed>
movss  -0x88(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x70(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x74(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a70 <dradbg+0x950>
jmp    1b12 <dradbg+0x9f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19c3 <dradbg+0x8a3>
jmp    1b25 <dradbg+0xa05>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    181d <dradbg+0x6fd>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1bb9 <dradbg+0xa99>
mov    -0x10(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ba6 <dradbg+0xa86>
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x4c(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b63 <dradbg+0xa43>
jmp    1bab <dradbg+0xa8b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b41 <dradbg+0xa21>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c94 <dradbg+0xb74>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1c81 <dradbg+0xb61>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c07 <dradbg+0xae7>
jmp    1c86 <dradbg+0xb66>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bd4 <dradbg+0xab4>
cmpl   $0x1,-0x4(%rbp)
jne    1ca3 <dradbg+0xb83>
jmp    1fd2 <dradbg+0xeb2>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1cb7 <dradbg+0xb97>
jmp    1e42 <dradbg+0xd22>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e3d <dradbg+0xd1d>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1e2a <dradbg+0xd0a>
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e0a <dradbg+0xcea>
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d24 <dradbg+0xc04>
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d05 <dradbg+0xbe5>
jmp    1e2f <dradbg+0xd0f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1cd2 <dradbg+0xbb2>
jmp    1fd2 <dradbg+0xeb2>
movl   $0x0,-0x48(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1fcd <dradbg+0xead>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1fba <dradbg+0xe9a>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fa7 <dradbg+0xe87>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ec1 <dradbg+0xda1>
jmp    1fac <dradbg+0xe8c>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e90 <dradbg+0xd70>
jmp    1fbf <dradbg+0xe9f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e5d <dradbg+0xd3d>
jmp    1fd2 <dradbg+0xeb2>
cmpl   $0x1,-0x4(%rbp)
jne    1fe1 <dradbg+0xec1>
jmp    2399 <dradbg+0x1279>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    201c <dradbg+0xefc>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fe8 <dradbg+0xec8>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2099 <dradbg+0xf79>
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2086 <dradbg+0xf66>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2049 <dradbg+0xf29>
jmp    208b <dradbg+0xf6b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    202a <dradbg+0xf0a>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    20ad <dradbg+0xf8d>
jmp    2228 <dradbg+0x1108>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2223 <dradbg+0x1103>
mov    -0x4(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2210 <dradbg+0x10f0>
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    21fd <dradbg+0x10dd>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2122 <dradbg+0x1002>
jmp    2202 <dradbg+0x10e2>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    20f7 <dradbg+0xfd7>
jmp    2215 <dradbg+0x10f5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20c6 <dradbg+0xfa6>
jmp    2399 <dradbg+0x1279>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2399 <dradbg+0x1279>
mov    -0x4(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2386 <dradbg+0x1266>
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    236f <dradbg+0x124f>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    228b <dradbg+0x116b>
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    226c <dradbg+0x114c>
jmp    238b <dradbg+0x126b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2241 <dradbg+0x1121>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradbg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,(%rsp)
mov    %ecx,0x68(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%ebx
cvtsi2ss %esi,%xmm1
mov    0x1a8(%rsp),%r15
mov    %esi,%eax
imul   %edi,%eax
mov    %eax,0x44(%rsp)
movss  0x2e9e(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp)
call   1040 <cos@plt>
movaps %xmm0,0xf0(%rsp)
movss  0x10(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%rbx),%eax
mov    %rax,0x98(%rsp)
mov    %rbp,0x30(%rsp)
lea    0x1(%rbp),%eax
mov    %eax,0x40(%rsp)
cmp    %r14d,%ebx
mov    %r14,0x20(%rsp)
mov    %rbx,0x10(%rsp)
jge    13c8 <dradbg+0x2a8>
test   %ebx,%ebx
movaps 0xf0(%rsp),%xmm11
jle    1660 <dradbg+0x540>
mov    0x10(%rsp),%edx
movslq 0x44(%rsp),%r11
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%esi
mov    %esi,0x48(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %esi,0x38(%rsp)
and    $0xfffffffc,%eax
mov    %eax,0x80(%rsp)
mov    %r11,%r9
shl    $0x4,%r9
lea    (%r11,%r11,2),%rax
mov    (%rsp),%rsi
lea    (%rsi,%rax,4),%rax
mov    %rax,0xa0(%rsp)
lea    (%rsi,%r11,8),%rax
mov    %rax,0x28(%rsp)
lea    (%rsi,%r11,4),%rax
mov    %rax,0xb0(%rsp)
mov    %rdx,%r10
shl    $0x4,%r10
lea    (%rdx,%rdx,2),%rsi
lea    (%r15,%rsi,4),%rsi
mov    %rsi,0xc8(%rsp)
lea    (%r15,%rdx,8),%rsi
mov    %rsi,0xc0(%rsp)
lea    (%r15,%rdx,4),%rsi
mov    %rsi,0xb8(%rsp)
lea    0x0(,%r11,4),%rbx
lea    0x0(,%rdx,4),%rax
xor    %ecx,%ecx
xor    %r14d,%r14d
mov    %rbx,0x58(%rsp)
mov    %rax,0x70(%rsp)
mov    %r10,0x8(%rsp)
jmp    1281 <dradbg+0x161>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x4,%rcx
cmp    %rdx,%r14
je     1660 <dradbg+0x540>
cmpl   $0x0,0x20(%rsp)
jle    1270 <dradbg+0x150>
mov    %r14,%rsi
mov    %r14,0x50(%rsp)
mov    %r14,%r8
cmpl   $0x3,0x48(%rsp)
mov    %r9,%rax
jb     1370 <dradbg+0x250>
mov    0x80(%rsp),%r13d
mov    0xb8(%rsp),%rbp
mov    0xc0(%rsp),%r14
mov    0xc8(%rsp),%r15
mov    0x1a8(%rsp),%r12
mov    0xb0(%rsp),%r9
mov    0x28(%rsp),%r10
mov    0xa0(%rsp),%rbx
mov    (%rsp),%rdi
mov    0x50(%rsp),%r8
mov    %r8,%rsi
mov    %rcx,0x18(%rsp)
nop
movss  (%rdi,%rcx,1),%xmm1
movss  %xmm1,(%r12,%rcx,1)
add    %rdx,%r8
add    %r11,%rsi
movss  (%r9,%rcx,1),%xmm1
movss  %xmm1,0x0(%rbp,%rcx,1)
add    %rdx,%r8
add    %r11,%rsi
movss  (%r10,%rcx,1),%xmm1
movss  %xmm1,(%r14,%rcx,1)
add    %rdx,%r8
add    %r11,%rsi
movss  (%rbx,%rcx,1),%xmm1
movss  %xmm1,(%r15,%rcx,1)
add    %rdx,%r8
add    %r11,%rsi
add    %rax,%rdi
add    %rax,%rbx
add    %rax,%r10
add    %rax,%r9
mov    %rdx,%rcx
mov    %r11,%rdx
mov    %rax,%r11
mov    0x8(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r14
add    %rax,%rbp
mov    %r11,%rax
mov    %rdx,%r11
mov    %rcx,%rdx
mov    0x18(%rsp),%rcx
add    $0xfffffffc,%r13d
jne    12f0 <dradbg+0x1d0>
cmpl   $0x0,0x38(%rsp)
mov    0x1a8(%rsp),%r15
mov    %rax,%r9
mov    0x58(%rsp),%rbx
mov    0x70(%rsp),%rax
mov    0x50(%rsp),%r14
je     1270 <dradbg+0x150>
mov    (%rsp),%rdi
lea    (%rdi,%rsi,4),%rsi
lea    (%r15,%r8,4),%rdi
mov    0x38(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi),%xmm1
movss  %xmm1,(%rdi)
add    %rbx,%rsi
add    %rax,%rdi
add    $0xffffffff,%ebp
jne    13b0 <dradbg+0x290>
jmp    1270 <dradbg+0x150>
test   %r14d,%r14d
movaps 0xf0(%rsp),%xmm11
jle    1660 <dradbg+0x540>
movslq 0x10(%rsp),%r13
movslq 0x44(%rsp),%r12
mov    0x98(%rsp),%rax
lea    0x1(%rax),%r8
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa0(%rsp)
mov    (%rsp),%rax
lea    0x30(%rax),%rdi
lea    0x0(,%r12,4),%rcx
mov    %rcx,0x18(%rsp)
lea    0x30(%r15),%r9
lea    0x0(,%r13,4),%rcx
mov    %rcx,0x8(%rsp)
add    $0xc,%rax
mov    %rax,0x38(%rsp)
lea    0xc(%r15),%rax
mov    %rax,0x48(%rsp)
xor    %edx,%edx
xor    %r10d,%r10d
xor    %r11d,%r11d
mov    %r8,0x50(%rsp)
jmp    148f <dradbg+0x36f>
xchg   %ax,%ax
add    %r13,%r10
add    %r12,%rdx
add    $0x1,%r11d
add    0x18(%rsp),%rdi
add    0x8(%rsp),%r9
cmp    0x20(%rsp),%r11d
je     1660 <dradbg+0x540>
cmpl   $0x0,0x10(%rsp)
jle    1470 <dradbg+0x350>
xor    %eax,%eax
cmpl   $0x7,0x98(%rsp)
07
jae    14b0 <dradbg+0x390>
mov    %rdx,%r14
mov    %r10,%rbp
jmp    1580 <dradbg+0x460>
nopl   (%rax)
lea    (%r8,%rdx,1),%rcx
lea    (%r15,%r10,4),%rsi
mov    (%rsp),%rbx
lea    (%rbx,%rcx,4),%rcx
cmp    %rcx,%rsi
jae    14e4 <dradbg+0x3c4>
lea    (%r8,%r10,1),%rcx
lea    (%r15,%rcx,4),%rcx
mov    (%rsp),%rsi
lea    (%rsi,%rdx,4),%rsi
mov    %rdx,%r14
mov    %r10,%rbp
cmp    %rcx,%rsi
jb     1580 <dradbg+0x460>
cmpq   $0x0,0x70(%rsp)
je     164b <dradbg+0x52b>
mov    0xa0(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rax,4),%xmm1
movups -0x20(%rdi,%rax,4),%xmm2
movups %xmm1,-0x30(%r9,%rax,4)
movups %xmm2,-0x20(%r9,%rax,4)
movups -0x10(%rdi,%rax,4),%xmm1
movups (%rdi,%rax,4),%xmm2
movups %xmm1,-0x10(%r9,%rax,4)
movups %xmm2,(%r9,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1500 <dradbg+0x3e0>
testb  $0x1,0x80(%rsp)
01
je     155d <dradbg+0x43d>
lea    (%rdx,%rax,1),%rcx
add    %r10,%rax
mov    (%rsp),%rsi
movups (%rsi,%rcx,4),%xmm1
movups 0x10(%rsi,%rcx,4),%xmm2
movups %xmm1,(%r15,%rax,4)
movups %xmm2,0x10(%r15,%rax,4)
cmp    0x58(%rsp),%r8
je     1470 <dradbg+0x350>
mov    0x58(%rsp),%rax
lea    (%rdx,%rax,1),%r14
lea    (%r10,%rax,1),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rsi
mov    %esi,%ecx
sub    %eax,%ecx
mov    %eax,%ebx
not    %ebx
add    %esi,%ebx
and    $0x3,%ecx
je     15e6 <dradbg+0x4c6>
mov    %r12,%r8
mov    %r13,%r12
mov    (%rsp),%rsi
lea    (%rsi,%r14,4),%rsi
lea    (%r15,%rbp,4),%r15
neg    %ecx
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movss  (%rsi),%xmm1
movss  %xmm1,(%r15)
add    $0xffffffffffffffff,%r13
add    $0x4,%rsi
add    $0x4,%r15
cmp    %r13d,%ecx
jne    15b0 <dradbg+0x490>
sub    %r13,%r14
sub    %r13,%rbp
sub    %r13d,%eax
mov    0x1a8(%rsp),%r15
mov    %r12,%r13
mov    %r8,%r12
mov    0x50(%rsp),%r8
cmp    $0x3,%ebx
jb     1470 <dradbg+0x350>
mov    0x38(%rsp),%rcx
lea    (%rcx,%r14,4),%rcx
mov    0x48(%rsp),%rsi
lea    (%rsi,%rbp,4),%rsi
mov    0x10(%rsp),%rbx
sub    %eax,%ebx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rcx,%rax,4),%xmm1
movss  %xmm1,-0xc(%rsi,%rax,4)
movss  -0x8(%rcx,%rax,4),%xmm1
movss  %xmm1,-0x8(%rsi,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rax,4)
movss  (%rcx,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rax,4)
add    $0x4,%rax
cmp    %eax,%ebx
jne    1610 <dradbg+0x4f0>
jmp    1470 <dradbg+0x350>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    153e <dradbg+0x41e>
jmp    155d <dradbg+0x43d>
mov    0x20(%rsp),%r11
mov    %r11d,%ecx
mov    0x10(%rsp),%rax
imul   %eax,%ecx
mov    %rcx,0x28(%rsp)
sarl   0x40(%rsp)
add    %eax,%eax
mov    %rax,0x48(%rsp)
cmpl   $0x3,0x30(%rsp)
jl     1834 <dradbg+0x714>
movslq 0x10(%rsp),%rcx
movslq 0x48(%rsp),%r10
movslq 0x44(%rsp),%rdx
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%esi
mov    0x28(%rsp),%rbp
imul   %ebp,%esi
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r12d
cmovge %eax,%r12d
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %eax,0x80(%rsp)
mov    %rcx,0x58(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    (%rsp),%rbx
lea    (%rbx,%r10,4),%rcx
lea    (%rdx,%rdx,1),%rdi
add    %r10,%rdx
lea    (%rbx,%rdx,4),%rdx
mov    $0x1,%r8d
xor    %r9d,%r9d
mov    %r10,%r14
mov    %ebp,%r13d
mov    %r10,0x70(%rsp)
mov    %r12d,0x8(%rsp)
jmp    174e <dradbg+0x62e>
nop
mov    %rbp,%r12
mov    (%rsp),%rbp
movss  -0x4(%rbp,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r15,%r12,4)
mov    0x8(%rsp),%r12d
movss  0x0(%rbp,%rbx,4),%xmm1
addss  %xmm1,%xmm1
mov    0x18(%rsp),%rbx
movss  %xmm1,(%r15,%rbx,4)
add    %r10,%r14
add    $0x1,%r8d
mov    0x28(%rsp),%rbp
add    %ebp,%r13d
sub    %ebp,%esi
add    %r10,%r9
cmp    %r12d,%r8d
je     1834 <dradbg+0x714>
test   %r11d,%r11d
jle    1731 <dradbg+0x611>
movslq %esi,%rbx
movslq %r13d,%rbp
cmp    $0x1,%r11d
mov    %rbx,0x18(%rsp)
jne    1770 <dradbg+0x650>
mov    %r14,%rbx
test   $0x1,%r11b
je     1731 <dradbg+0x611>
jmp    1700 <dradbg+0x5e0>
nop
mov    %esi,0x50(%rsp)
mov    %rbp,%rsi
mov    0x58(%rsp),%rbp
lea    (%rbx,%rbp,1),%r10
lea    (%rsi,%rbp,1),%r12
lea    (%r15,%rbx,4),%rbp
lea    (%r15,%r10,4),%r10
mov    %rsi,0x38(%rsp)
lea    (%r15,%rsi,4),%r11
lea    (%r15,%r12,4),%r15
mov    0x80(%rsp),%r12d
mov    %r9,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r11,%rsi,4)
movss  (%rcx,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,0x0(%rbp,%rsi,4)
movss  -0x4(%rdx,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r15,%rsi,4)
movss  (%rdx,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r10,%rsi,4)
add    %rax,%rsi
add    %rdi,%rbx
add    $0xfffffffe,%r12d
jne    17b0 <dradbg+0x690>
add    %rsi,0x18(%rsp)
mov    0x70(%rsp),%r10
add    %r10,%rbx
mov    0x38(%rsp),%rbp
add    %rsi,%rbp
mov    0x20(%rsp),%r11
mov    0x1a8(%rsp),%r15
mov    0x50(%rsp),%esi
mov    0x8(%rsp),%r12d
test   $0x1,%r11b
je     1731 <dradbg+0x611>
jmp    1700 <dradbg+0x5e0>
mov    0x98(%rsp),%rax
sar    %eax
mov    %rax,0x98(%rsp)
cmpl   $0x1,0x10(%rsp)
jne    20ba <dradbg+0xf9a>
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x64(%rsp)
cmp    $0x3,%eax
mov    0x10(%rsp),%rcx
mov    0x1b0(%rsp),%r8
jl     2734 <dradbg+0x1614>
mov    0x64(%rsp),%edx
mov    0x68(%rsp),%r12d
imul   %r12d,%edx
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
xorps  0x2780(%rip),%xmm0
movslq %edx,%r9
movslq %r12d,%rdi
mov    0x30(%rsp),%rax
add    $0xfffffffe,%eax
imul   %r12d,%eax
mov    %eax,0xec(%rsp)
mov    0x40(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%ecx
cmovge %eax,%ecx
mov    %ecx,0x18(%rsp)
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %ecx,0xd8(%rsp)
mov    %edi,%ebx
lea    -0x1(%rdi),%ebp
lea    (%rdi,%rbx,1),%rax
lea    (%r8,%rax,4),%rax
mov    %rax,0x158(%rsp)
lea    (%r9,%rbx,1),%rax
lea    (%r8,%rax,4),%rax
mov    %rax,0x150(%rsp)
shufps $0x0,%xmm11,%xmm11
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,0x140(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x138(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x130(%rsp)
movabs $0x1fffffff8,%rax
or     $0x4,%rax
lea    0x1(%rbp),%rsi
mov    %rsi,0xb8(%rsp)
and    %rsi,%rax
mov    %rax,0xb0(%rsp)
movss  0x26ac(%rip),%xmm2
movaps 0x26b0(%rip),%xmm8
lea    (%rdi,%rdi,1),%eax
mov    %eax,0xe8(%rsp)
mov    0x1a0(%rsp),%r14
lea    0x4(%r14,%rbp,4),%rax
mov    %rax,0x160(%rsp)
mov    %rbp,0x50(%rsp)
lea    0x4(%r8,%rbp,4),%rax
mov    %rax,0xa0(%rsp)
lea    (%r14,%rbx,4),%rax
mov    %rax,0x148(%rsp)
mov    %rbx,0xa8(%rsp)
lea    (%r8,%rbx,4),%rax
mov    %rax,0xd0(%rsp)
lea    (%r8,%rdi,4),%rax
mov    %rax,0x110(%rsp)
lea    (%r8,%r9,4),%rax
mov    %rax,0x108(%rsp)
mov    %rdi,0x88(%rsp)
lea    (%rcx,%rdi,1),%rax
mov    %rax,0x120(%rsp)
mov    %r9,0x90(%rsp)
mov    %rcx,0x100(%rsp)
lea    (%rcx,%r9,1),%rax
mov    %rax,0x118(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x128(%rsp)
mov    $0x1,%eax
mov    %r12d,%ecx
jmp    1a38 <dradbg+0x918>
nop
mov    0xf0(%rsp),%eax
add    $0x1,%eax
mov    0x44(%rsp),%edx
sub    %r12d,%edx
mov    0xe0(%rsp),%ecx
add    %r12d,%ecx
cmp    0xd8(%rsp),%eax
je     222f <dradbg+0x110f>
mov    %eax,0xf0(%rsp)
mov    %edx,0x44(%rsp)
movslq %edx,%rax
mov    %rax,0x8(%rsp)
lea    (%r14,%rax,4),%r15
mov    %ecx,0xe0(%rsp)
movslq %ecx,%rax
mov    %rax,(%rsp)
lea    (%r14,%rax,4),%r11
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   %r12d,%r12d
jle    1b1a <dradbg+0x9fa>
cmp    $0x4,%r12d
jae    1e00 <dradbg+0xce0>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdx
xor    %esi,%esi
mov    0x88(%rsp),%r14
mov    0x90(%rsp),%r9
mov    0x1a0(%rsp),%rbp
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
lea    (%r8,%rsi,4),%rbx
mov    0xa8(%rsp),%rdi
sub    %rsi,%rdi
lea    (%r8,%r14,4),%rax
mov    %rbp,%r14
lea    (%r8,%r9,4),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  (%rax,%rbp,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rbx,%rbp,4),%xmm3
movss  %xmm3,(%rcx,%rbp,4)
movss  (%rsi,%rbp,4),%xmm3
mulss  %xmm4,%xmm3
movss  %xmm3,(%rdx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1af0 <dradbg+0x9d0>
cmpl   $0x5,0x30(%rsp)
jb     1a10 <dradbg+0x8f0>
mov    0x160(%rsp),%rax
mov    (%rsp),%rdx
lea    (%rax,%rdx,4),%rsi
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
xorps  %xmm8,%xmm4
movaps %xmm2,%xmm10
shufps $0x0,%xmm2,%xmm10
mov    %rax,0x70(%rsp)
cmp    %rax,%r11
setb   %al
mov    %rsi,0x58(%rsp)
cmp    %rsi,%r15
setb   %bl
and    %al,%bl
mov    %bl,0x80(%rsp)
mov    0xb0(%rsp),%rax
add    %rax,%rdx
mov    %rdx,0xc8(%rsp)
add    %rcx,%rax
mov    %rax,0xc0(%rsp)
mov    $0x2,%r13d
mov    0xe8(%rsp),%r10d
mov    0xec(%rsp),%edx
movaps %xmm2,%xmm6
jmp    1bc5 <dradbg+0xaa5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13d
sub    %r12d,%edx
add    %r12d,%r10d
cmp    0x18(%rsp),%r13d
je     1a10 <dradbg+0x8f0>
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   %r12d,%r12d
jle    1bb0 <dradbg+0xa90>
movslq %edx,%r9
movslq %r10d,%rcx
xor    %eax,%eax
movaps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm7
cmpl   $0x3,0x50(%rsp)
jae    1c60 <dradbg+0xb40>
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
lea    (%r14,%rbx,4),%rbx
lea    (%r14,%rbp,4),%rbp
lea    (%r8,%rcx,4),%rdi
lea    (%r8,%r9,4),%rcx
mov    %r12d,%esi
sub    %eax,%esi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%rbx,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  (%rcx,%rax,4),%xmm1
mulss  %xmm7,%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %eax,%esi
jne    1c20 <dradbg+0xb00>
jmp    1bb0 <dradbg+0xa90>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r8,%r9,4),%rbx
lea    (%r8,%rcx,4),%rbp
mov    0xa0(%rsp),%rax
mov    %rcx,0x48(%rsp)
lea    (%rax,%rcx,4),%rcx
mov    %r9,0x38(%rsp)
lea    (%rax,%r9,4),%rsi
cmp    %rcx,%r11
setb   %al
mov    0x58(%rsp),%rdi
cmp    %rdi,%rbp
setb   %r12b
and    %al,%r12b
or     0x80(%rsp),%r12b
cmp    %rsi,%r11
setb   %al
cmp    %rdi,%rbx
setb   %r9b
cmp    %rcx,%r15
setb   %cl
mov    0x70(%rsp),%rdi
cmp    %rdi,%rbp
setb   %r8b
cmp    %rsi,%r15
setb   %sil
cmp    %rdi,%rbx
setb   %r14b
test   %r12b,%r12b
jne    1dc0 <dradbg+0xca0>
and    %r9b,%al
mov    0x68(%rsp),%r12d
jne    1dd0 <dradbg+0xcb0>
and    %r8b,%cl
mov    0x38(%rsp),%r9
mov    $0x0,%eax
jne    1d9d <dradbg+0xc7d>
and    %r14b,%sil
mov    0x1b0(%rsp),%r8
mov    0x48(%rsp),%rcx
jne    1d87 <dradbg+0xc67>
mov    0xb0(%rsp),%rax
add    %rax,%rcx
add    %rax,%r9
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
xor    %esi,%esi
mov    0x1a0(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rsi,4),%xmm1
mulps  %xmm3,%xmm1
movups (%r11,%rsi,4),%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%r11,%rsi,4)
movups (%rbx,%rsi,4),%xmm1
movups (%r15,%rsi,4),%xmm5
mulps  %xmm7,%xmm1
addps  %xmm5,%xmm1
movups %xmm1,(%r15,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1d30 <dradbg+0xc10>
mov    0xc8(%rsp),%rbx
mov    0xc0(%rsp),%rbp
mov    %eax,%esi
cmp    %rax,0xb8(%rsp)
je     1bb0 <dradbg+0xa90>
jmp    1c04 <dradbg+0xae4>
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
mov    0x1a0(%rsp),%r14
jmp    1c04 <dradbg+0xae4>
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
mov    0x1b0(%rsp),%r8
mov    0x1a0(%rsp),%r14
mov    0x48(%rsp),%rcx
jmp    1c04 <dradbg+0xae4>
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
mov    0x68(%rsp),%r12d
jmp    1dd9 <dradbg+0xcb9>
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
mov    0x1b0(%rsp),%r8
mov    0x1a0(%rsp),%r14
mov    0x38(%rsp),%r9
mov    0x48(%rsp),%rcx
xor    %eax,%eax
jmp    1c04 <dradbg+0xae4>
nopw   0x0(%rax,%rax,1)
mov    0x148(%rsp),%rcx
mov    (%rsp),%rax
lea    (%rcx,%rax,4),%rax
mov    0x8(%rsp),%rdx
lea    (%rcx,%rdx,4),%rbp
cmp    %rbp,%r11
setb   0x38(%rsp)
cmp    %rax,%r15
setb   %r13b
mov    0xd0(%rsp),%rsi
cmp    %rsi,%r11
setb   %cl
cmp    %r8,%rax
mov    %r8,%r10
seta   %r8b
mov    0x158(%rsp),%rdi
cmp    %rdi,%r11
setb   %dl
mov    0x110(%rsp),%r9
cmp    %rax,%r9
setb   0x48(%rsp)
mov    0x150(%rsp),%r12
cmp    %r12,%r11
setb   %bl
mov    0x108(%rsp),%r14
cmp    %rax,%r14
setb   %al
cmp    %rsi,%r15
setb   %sil
cmp    %r10,%rbp
seta   0x58(%rsp)
cmp    %rdi,%r15
setb   %dil
cmp    %rbp,%r9
setb   %r9b
cmp    %r12,%r15
setb   %r10b
cmp    %rbp,%r14
setb   %bpl
test   %r13b,0x38(%rsp)
jne    208d <dradbg+0xf6d>
and    %r8b,%cl
jne    208d <dradbg+0xf6d>
and    0x48(%rsp),%dl
mov    0x1b0(%rsp),%r8
jne    2068 <dradbg+0xf48>
and    %al,%bl
jne    2068 <dradbg+0xf48>
and    0x58(%rsp),%sil
jne    2068 <dradbg+0xf48>
and    %r9b,%dil
mov    0x68(%rsp),%r12d
jne    1a97 <dradbg+0x977>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdx
mov    $0x0,%esi
mov    0x88(%rsp),%r14
mov    0x90(%rsp),%r9
and    %bpl,%r10b
jne    1ab2 <dradbg+0x992>
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
cmpq   $0x0,0x140(%rsp)
mov    0x110(%rsp),%rax
mov    0x108(%rsp),%rbp
je     204e <dradbg+0xf2e>
mov    0x128(%rsp),%rcx
mov    (%rsp),%rdx
lea    (%rcx,%rdx,4),%rdx
mov    0x8(%rsp),%rsi
lea    (%rcx,%rsi,4),%rsi
mov    0x130(%rsp),%rdi
xor    %ecx,%ecx
mov    0x1a0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r8,%rcx,4),%xmm3
movups (%rax,%rcx,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,-0x10(%rdx,%rcx,4)
movups 0x0(%rbp,%rcx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,-0x10(%rsi,%rcx,4)
movups 0x10(%r8,%rcx,4),%xmm3
movups 0x10(%rax,%rcx,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,(%rdx,%rcx,4)
movups 0x10(%rbp,%rcx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,(%rsi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1f70 <dradbg+0xe50>
testb  $0x1,0x138(%rsp)
01
je     200a <dradbg+0xeea>
mov    (%rsp),%rax
add    %rcx,%rax
mov    0x8(%rsp),%rdx
add    %rcx,%rdx
mov    0x88(%rsp),%rsi
add    %rcx,%rsi
movups (%r8,%rcx,4),%xmm3
add    0x90(%rsp),%rcx
movups (%r8,%rsi,4),%xmm6
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movups %xmm5,(%r14,%rax,4)
movups (%r8,%rcx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,(%r14,%rdx,4)
mov    0x100(%rsp),%rax
cmp    0xa8(%rsp),%rax
je     1b1a <dradbg+0x9fa>
mov    0x100(%rsp),%rsi
mov    (%rsp),%rax
lea    (%rsi,%rax,1),%rcx
mov    0x8(%rsp),%rax
lea    (%rsi,%rax,1),%rdx
mov    0x120(%rsp),%r14
mov    0x118(%rsp),%r9
jmp    1ab2 <dradbg+0x992>
xor    %ecx,%ecx
mov    0x1a0(%rsp),%r14
testb  $0x1,0x138(%rsp)
01
jne    1fc6 <dradbg+0xea6>
jmp    200a <dradbg+0xeea>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdx
xor    %esi,%esi
mov    0x88(%rsp),%r14
mov    0x90(%rsp),%r9
mov    0x68(%rsp),%r12d
jmp    1ab2 <dradbg+0x992>
mov    (%rsp),%rcx
mov    0x8(%rsp),%rdx
xor    %esi,%esi
mov    0x88(%rsp),%r14
mov    0x90(%rsp),%r9
mov    0x68(%rsp),%r12d
mov    0x1b0(%rsp),%r8
jmp    1ab2 <dradbg+0x992>
mov    0x98(%rsp),%rax
cmp    0x20(%rsp),%eax
jge    2480 <dradbg+0x1360>
cmpl   $0x3,0x30(%rsp)
mov    0x78(%rsp),%r13
jl     2982 <dradbg+0x1862>
mov    0x48(%rsp),%rax
lea    -0x2(%rax),%ecx
mov    %ecx,0x8(%rsp)
movslq 0x44(%rsp),%rdx
add    $0x2,%eax
mov    %eax,0x50(%rsp)
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    0x28(%rsp),%rax
imul   %eax,%ecx
add    $0x2,%ecx
mov    %ecx,0x38(%rsp)
movslq 0x10(%rsp),%rdi
mov    0x40(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%esi
cmovge %ecx,%esi
mov    %esi,0x70(%rsp)
add    $0x2,%eax
mov    %eax,0x58(%rsp)
shl    $0x2,%rdi
shl    $0x2,%rdx
mov    $0x1,%ecx
mov    0x20(%rsp),%rbx
jmp    216b <dradbg+0x104b>
xchg   %ax,%ax
mov    0x18(%rsp),%ecx
add    $0x1,%ecx
mov    0x48(%rsp),%rax
add    %eax,0x8(%rsp)
add    %eax,0x50(%rsp)
mov    0x28(%rsp),%rax
sub    %eax,0x38(%rsp)
add    %eax,0x58(%rsp)
cmp    0x70(%rsp),%ecx
je     1851 <dradbg+0x731>
mov    %ecx,0x18(%rsp)
cmpl   $0x3,0x10(%rsp)
jl     2140 <dradbg+0x1020>
mov    $0x2,%ebp
mov    0x58(%rsp),%r12d
mov    0x38(%rsp),%r13d
mov    0x50(%rsp),%r15d
mov    0x8(%rsp),%esi
jmp    21a8 <dradbg+0x1088>
add    $0x2,%ebp
add    $0xfffffffe,%esi
add    $0x2,%r15d
add    $0x2,%r13d
add    $0x2,%r12d
cmp    0x10(%rsp),%ebp
jge    2140 <dradbg+0x1020>
cmpl   $0x0,0x20(%rsp)
jle    2190 <dradbg+0x1070>
movslq %r12d,%rcx
movslq %r13d,%rax
movslq %r15d,%r8
movslq %esi,%r9
mov    %ebx,%r10d
mov    (%rsp),%r11
mov    0x1a8(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movss  -0x4(%r11,%r8,4),%xmm1
addss  -0x4(%r11,%r9,4),%xmm1
movss  %xmm1,-0x4(%r14,%rcx,4)
movss  -0x4(%r11,%r8,4),%xmm1
subss  -0x4(%r11,%r9,4),%xmm1
movss  %xmm1,-0x4(%r14,%rax,4)
movss  (%r11,%r8,4),%xmm1
subss  (%r11,%r9,4),%xmm1
movss  %xmm1,(%r14,%rcx,4)
movss  (%r11,%r8,4),%xmm1
addss  (%r11,%r9,4),%xmm1
movss  %xmm1,(%r14,%rax,4)
add    %rdi,%r14
add    %rdx,%r11
add    $0xffffffff,%r10d
jne    21d0 <dradbg+0x10b0>
jmp    2190 <dradbg+0x1070>
cmpl   $0x3,0x30(%rsp)
mov    0x10(%rsp),%rcx
jl     2734 <dradbg+0x1614>
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r12d
cmovge %eax,%r12d
mov    0xa8(%rsp),%r15
mov    %r15d,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%r10
mov    %r10,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r8,%rax
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
neg    %r15
lea    0x30(%rax),%rcx
mov    %rcx,0x18(%rsp)
lea    0x4(%rax),%r13
mov    $0x1,%esi
mov    0x68(%rsp),%eax
mov    %eax,%ecx
mov    0xd0(%rsp),%r9
jmp    22ae <dradbg+0x118e>
nopl   (%rax)
add    $0x1,%esi
add    %eax,%ecx
cmp    %r12d,%esi
je     25bd <dradbg+0x149d>
test   %eax,%eax
jle    22a0 <dradbg+0x1180>
movslq %ecx,%rdx
cmp    $0x8,%eax
jb     22db <dradbg+0x11bb>
lea    (%r9,%rdx,4),%rdi
mov    0x1b0(%rsp),%rbp
cmp    %rbp,%rdi
jbe    22f3 <dradbg+0x11d3>
lea    0x0(,%rdx,4),%rdi
add    %rbp,%rdi
cmp    %r9,%rdi
jae    22f3 <dradbg+0x11d3>
xor    %edi,%edi
testb  $0x1,0xa8(%rsp)
01
jne    23e0 <dradbg+0x12c0>
mov    %rdi,%rbx
jmp    2405 <dradbg+0x12e5>
test   %r10,%r10
je     246f <dradbg+0x134f>
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdx,4),%rbp
mov    %r8,%rdi
xor    %ebx,%ebx
mov    0x1b0(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rbp,%rbx,4),%xmm0
movups -0x20(%rbp,%rbx,4),%xmm1
movups (%r9,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r9,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%r9,%rbx,4),%xmm1
movups 0x30(%r9,%rbx,4),%xmm3
movups %xmm2,(%r9,%rbx,4)
movups %xmm0,0x10(%r9,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x0(%rbp,%rbx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%r9,%rbx,4)
movups %xmm1,0x30(%r9,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    2320 <dradbg+0x1200>
test   $0x1,%r11b
je     23ae <dradbg+0x128e>
lea    (%rbx,%rdx,1),%rdi
mov    0x1b0(%rsp),%rbp
movups 0x0(%rbp,%rdi,4),%xmm0
movups 0x10(%rbp,%rdi,4),%xmm1
movups 0x0(%rbp,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rbp,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rbx,4)
movups %xmm0,0x10(%rbp,%rbx,4)
cmp    0xa8(%rsp),%r14
mov    0xd0(%rsp),%r9
je     22a0 <dradbg+0x1180>
add    %r14,%rdx
mov    %r14,%rdi
testb  $0x1,0xa8(%rsp)
01
je     22eb <dradbg+0x11cb>
nopl   0x0(%rax,%rax,1)
mov    0x1b0(%rsp),%rbp
movss  0x0(%rbp,%rdx,4),%xmm0
add    $0x1,%rdx
addss  0x0(%rbp,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
mov    %rdi,%rbx
or     $0x1,%rbx
not    %rdi
cmp    %r15,%rdi
je     22a0 <dradbg+0x1180>
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
mov    0xa8(%rsp),%rdi
sub    %rbx,%rdi
lea    0x0(,%rbx,4),%rbx
add    %r13,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rdx,%rbp,4),%xmm0
addss  -0x4(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rbp,4)
movss  (%rdx,%rbp,4),%xmm0
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    2440 <dradbg+0x1320>
jmp    22a0 <dradbg+0x1180>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    237e <dradbg+0x125e>
jmp    23ae <dradbg+0x128e>
cmpl   $0x3,0x30(%rsp)
mov    0x78(%rsp),%r13
jl     2982 <dradbg+0x1862>
movslq 0x44(%rsp),%r12
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%r10d
mov    0x28(%rsp),%rcx
imul   %ecx,%r10d
movslq 0x10(%rsp),%r13
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
mov    0x1a8(%rsp),%rax
lea    0x8(%rax),%r9
shl    $0x2,%r13
shl    $0x2,%r12
mov    $0x1,%r15d
mov    %ecx,%r11d
mov    0x48(%rsp),%rax
mov    %eax,%r14d
jmp    250d <dradbg+0x13ed>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15d
add    0x48(%rsp),%r14d
mov    0x28(%rsp),%rax
sub    %eax,%r10d
add    %eax,%r11d
cmp    %r8d,%r15d
je     1851 <dradbg+0x731>
cmpl   $0x0,0x20(%rsp)
mov    0x10(%rsp),%rdx
jle    24f0 <dradbg+0x13d0>
movslq %r11d,%rax
lea    (%r9,%rax,4),%rbp
movslq %r10d,%rax
lea    (%r9,%rax,4),%rbx
movslq %r14d,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
xor    %ecx,%ecx
jmp    2552 <dradbg+0x1432>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ecx
add    %r13,%rbp
add    %r13,%rbx
add    %r12,%rdi
cmp    0x20(%rsp),%ecx
je     24f0 <dradbg+0x13d0>
cmp    $0x3,%edx
jl     2540 <dradbg+0x1420>
mov    $0xfffffffffffffffe,%rsi
xor    %eax,%eax
movss  0x4(%rdi,%rax,4),%xmm1
addss  -0x4(%rdi,%rsi,4),%xmm1
movss  %xmm1,-0x4(%rbp,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm1
subss  -0x4(%rdi,%rsi,4),%xmm1
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  0x8(%rdi,%rax,4),%xmm1
subss  (%rdi,%rsi,4),%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
movss  0x8(%rdi,%rax,4),%xmm1
addss  (%rdi,%rsi,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x2,%rax
add    $0xfffffffffffffffe,%rsi
lea    0x2(%rax),%edx
cmp    0x10(%rsp),%edx
mov    0x10(%rsp),%rdx
jl     2560 <dradbg+0x1440>
jmp    2540 <dradbg+0x1420>
cmpl   $0x3,0x30(%rsp)
mov    0x10(%rsp),%rcx
jl     2734 <dradbg+0x1614>
mov    0x28(%rsp),%rdx
mov    %edx,%r15d
imul   0x64(%rsp),%r15d
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
movslq %ecx,%rdi
mov    0x20(%rsp),%rax
and    $0xfffffffe,%eax
mov    %eax,0x50(%rsp)
mov    %rdi,(%rsp)
add    %rdi,%rdi
mov    $0x1,%r13d
mov    %edx,%r12d
mov    %esi,0x8(%rsp)
jmp    2628 <dradbg+0x1508>
nop
add    $0x1,%r13d
mov    0x28(%rsp),%rax
add    %eax,%r12d
sub    %eax,%r15d
cmp    %esi,%r13d
je     2734 <dradbg+0x1614>
cmpl   $0x0,0x20(%rsp)
jle    2610 <dradbg+0x14f0>
movslq %r15d,%rbp
movslq %r12d,%r14
cmpl   $0x1,0x20(%rsp)
je     26f6 <dradbg+0x15d6>
mov    (%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
lea    (%rcx,%r14,1),%r8
mov    0x78(%rsp),%r10
lea    (%r10,%rbp,4),%rcx
mov    0x1a8(%rsp),%r9
mov    %rbp,0x18(%rsp)
lea    (%r9,%rbp,4),%rbp
lea    (%r9,%rax,4),%rbx
lea    (%r10,%rax,4),%rax
lea    (%r10,%r14,4),%rdx
lea    (%r9,%r14,4),%rsi
lea    (%r9,%r8,4),%r9
lea    (%r10,%r8,4),%r10
mov    0x50(%rsp),%r11d
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx,%r8,4),%xmm0
subss  (%rcx,%r8,4),%xmm0
movss  %xmm0,(%rsi,%r8,4)
movss  (%rdx,%r8,4),%xmm0
addss  (%rcx,%r8,4),%xmm0
movss  %xmm0,0x0(%rbp,%r8,4)
movss  (%r10,%r8,4),%xmm0
subss  (%rax,%r8,4),%xmm0
movss  %xmm0,(%r9,%r8,4)
movss  (%r10,%r8,4),%xmm0
addss  (%rax,%r8,4),%xmm0
movss  %xmm0,(%rbx,%r8,4)
add    %rdi,%r8
add    $0xfffffffe,%r11d
jne    2690 <dradbg+0x1570>
mov    0x18(%rsp),%rbp
add    %r8,%rbp
add    %r8,%r14
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%esi
testb  $0x1,0x20(%rsp)
je     2610 <dradbg+0x14f0>
mov    0x78(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
subss  (%rax,%rbp,4),%xmm0
mov    0x1a8(%rsp),%rdx
movss  %xmm0,(%rdx,%r14,4)
movss  (%rax,%r14,4),%xmm0
addss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
jmp    2610 <dradbg+0x14f0>
cmp    $0x1,%ecx
mov    0x78(%rsp),%r13
je     30eb <dradbg+0x1fcb>
mov    0x20(%rsp),%r12
cmp    %r12d,0x98(%rsp)
jge    2870 <dradbg+0x1750>
cmpl   $0x3,0x30(%rsp)
jl     2982 <dradbg+0x1862>
mov    0x28(%rsp),%rcx
mov    0x64(%rsp),%r8d
imul   %ecx,%r8d
add    $0x2,%r8d
movslq 0x10(%rsp),%rax
lea    0x2(%rcx),%r9d
mov    0x40(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %edx,0x18(%rsp)
shl    $0x2,%rax
mov    $0x1,%r10d
jmp    27ba <dradbg+0x169a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10d
mov    0x28(%rsp),%rcx
sub    %ecx,%r8d
add    %ecx,%r9d
cmp    0x18(%rsp),%r10d
je     2982 <dradbg+0x1862>
cmpl   $0x3,0x10(%rsp)
jl     27a0 <dradbg+0x1680>
mov    $0x2,%r15d
mov    %r9d,%r11d
mov    %r8d,%r14d
jmp    27e3 <dradbg+0x16c3>
nop
add    $0x2,%r15d
add    $0x2,%r14d
add    $0x2,%r11d
cmp    0x10(%rsp),%r15d
jge    27a0 <dradbg+0x1680>
test   %r12d,%r12d
jle    27d0 <dradbg+0x16b0>
movslq %r11d,%rcx
lea    0x0(,%rcx,4),%rdx
add    %r13,%rdx
mov    0x1a8(%rsp),%rdi
lea    (%rdi,%rcx,4),%rbp
movslq %r14d,%rcx
lea    0x0(,%rcx,4),%rsi
add    %r13,%rsi
lea    (%rdi,%rcx,4),%rcx
mov    %r12d,%ebx
xor    %edi,%edi
nopl   0x0(%rax)
movss  -0x4(%rdx,%rdi,1),%xmm0
subss  (%rsi,%rdi,1),%xmm0
movss  %xmm0,-0x4(%rbp,%rdi,1)
movss  -0x4(%rdx,%rdi,1),%xmm0
addss  (%rsi,%rdi,1),%xmm0
movss  %xmm0,-0x4(%rcx,%rdi,1)
movss  (%rdx,%rdi,1),%xmm0
addss  -0x4(%rsi,%rdi,1),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,1)
movss  (%rdx,%rdi,1),%xmm0
subss  -0x4(%rsi,%rdi,1),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rax,%rdi
add    $0xffffffff,%ebx
jne    2820 <dradbg+0x1700>
jmp    27d0 <dradbg+0x16b0>
cmpl   $0x3,0x30(%rsp)
jl     2982 <dradbg+0x1862>
mov    0x28(%rsp),%rcx
mov    0x64(%rsp),%eax
imul   %ecx,%eax
mov    %eax,0x64(%rsp)
movslq 0x10(%rsp),%r15
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %edx,0x18(%rsp)
lea    0x8(%r13),%r9
shl    $0x2,%r15
mov    0x1a8(%rsp),%rax
lea    0x8(%rax),%r10
mov    $0x1,%r14d
mov    %ecx,%r11d
mov    0x10(%rsp),%r8
jmp    28eb <dradbg+0x17cb>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
mov    0x28(%rsp),%rax
sub    %eax,0x64(%rsp)
add    %eax,%r11d
cmp    0x18(%rsp),%r14d
je     2982 <dradbg+0x1862>
test   %r12d,%r12d
jle    28d0 <dradbg+0x17b0>
movslq %r11d,%rcx
lea    (%r9,%rcx,4),%rbp
lea    (%r10,%rcx,4),%rbx
movslq 0x64(%rsp),%rcx
lea    (%r10,%rcx,4),%rdx
lea    (%r9,%rcx,4),%rsi
xor    %ecx,%ecx
jmp    2924 <dradbg+0x1804>
nopl   0x0(%rax)
add    $0x1,%ecx
add    %r15,%rbp
add    %r15,%rbx
add    %r15,%rdx
add    %r15,%rsi
cmp    %r12d,%ecx
je     28d0 <dradbg+0x17b0>
cmp    $0x3,%r8d
jl     2910 <dradbg+0x17f0>
xor    %edi,%edi
nopl   0x0(%rax)
movss  -0x4(%rbp,%rdi,4),%xmm0
subss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rdi,4)
movss  -0x4(%rbp,%rdi,4),%xmm0
addss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rdi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
addss  -0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
movss  0x0(%rbp,%rdi,4),%xmm0
subss  -0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x2,%rdi
lea    0x2(%rdi),%eax
cmp    %r8d,%eax
jl     2930 <dradbg+0x1810>
jmp    2910 <dradbg+0x17f0>
mov    0x68(%rsp),%ecx
test   %ecx,%ecx
mov    0x1a8(%rsp),%r10
mov    0x1b0(%rsp),%rbx
mov    0x1a0(%rsp),%rax
jle    2b24 <dradbg+0x1a04>
mov    %ecx,%r9d
cmp    $0x8,%ecx
jb     29c4 <dradbg+0x18a4>
lea    (%rbx,%r9,4),%rcx
cmp    %rax,%rcx
jbe    2a3c <dradbg+0x191c>
lea    (%rax,%r9,4),%rcx
cmp    %rbx,%rcx
jbe    2a3c <dradbg+0x191c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     29f4 <dradbg+0x18d4>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    29e0 <dradbg+0x18c0>
cmp    $0x3,%rdx
jb     2b24 <dradbg+0x1a04>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    2a00 <dradbg+0x18e0>
jmp    2b24 <dradbg+0x1a04>
mov    %r9d,%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    2a60 <dradbg+0x1940>
xor    %edi,%edi
jmp    2ad8 <dradbg+0x19b8>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%rax,%rdi,4)
movups %xmm1,0x30(%rax,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%rax,%rdi,4)
movups %xmm1,0x50(%rax,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%rax,%rdi,4)
movups %xmm1,0x70(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    2a80 <dradbg+0x1960>
test   %rdx,%rdx
je     2b1b <dradbg+0x19fb>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%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    2b00 <dradbg+0x19e0>
cmp    %r9,%rcx
jne    29c6 <dradbg+0x18a6>
cmpl   $0x2,0x30(%rsp)
mov    0x10(%rsp),%rcx
jl     30eb <dradbg+0x1fcb>
mov    0x1b8(%rsp),%rax
movslq %ecx,%rdx
mov    0x20(%rsp),%rcx
lea    -0x1(%rcx),%esi
mov    %esi,(%rsp)
mov    %ecx,%esi
and    $0x3,%esi
mov    %esi,0x8(%rsp)
and    $0xfffffffc,%ecx
mov    %ecx,0x50(%rsp)
lea    0x0(,%rdx,4),%r12
lea    (%r12,%r12,2),%r14
lea    (%r14,%r13,1),%rcx
mov    %rcx,0x38(%rsp)
add    %r10,%r14
mov    %r13,%rcx
lea    0x0(%r13,%rdx,8),%r13
lea    (%r10,%rdx,8),%r8
lea    (%rcx,%rdx,4),%r11
lea    (%r10,%rdx,4),%rdi
mov    $0x1,%ebp
mov    0x28(%rsp),%rcx
mov    %ecx,%esi
jmp    2bb1 <dradbg+0x1a91>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%ebp
add    0x28(%rsp),%esi
cmp    0x30(%rsp),%ebp
je     2c79 <dradbg+0x1b59>
cmpl   $0x0,0x20(%rsp)
jle    2ba0 <dradbg+0x1a80>
mov    %esi,0x18(%rsp)
movslq %esi,%r9
cmpl   $0x3,(%rsp)
jae    2be0 <dradbg+0x1ac0>
mov    %r9,%rbx
mov    0x78(%rsp),%r10
mov    0x1a8(%rsp),%r15
jmp    2c46 <dradbg+0x1b26>
nopw   0x0(%rax,%rax,1)
mov    0x50(%rsp),%ecx
mov    0x78(%rsp),%r10
mov    0x1a8(%rsp),%r15
mov    0x38(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movss  (%r15,%r9,4),%xmm0
movss  %xmm0,(%r10,%r9,4)
lea    (%r9,%rdx,1),%rbx
movss  (%rdi,%r9,4),%xmm0
movss  %xmm0,(%r11,%r9,4)
add    %rdx,%rbx
movss  (%r8,%r9,4),%xmm0
movss  %xmm0,0x0(%r13,%r9,4)
add    %rdx,%rbx
movss  (%r14,%r9,4),%xmm0
movss  %xmm0,(%rsi,%r9,4)
add    %rdx,%rbx
mov    %rbx,%r9
add    $0xfffffffc,%ecx
jne    2c00 <dradbg+0x1ae0>
cmpl   $0x0,0x8(%rsp)
mov    0x18(%rsp),%esi
je     2ba0 <dradbg+0x1a80>
shl    $0x2,%rbx
mov    0x8(%rsp),%ecx
nopl   (%rax)
movss  (%r15,%rbx,1),%xmm0
movss  %xmm0,(%r10,%rbx,1)
add    %r12,%rbx
add    $0xffffffff,%ecx
jne    2c60 <dradbg+0x1b40>
jmp    2ba0 <dradbg+0x1a80>
mov    0x98(%rsp),%rcx
cmp    0x20(%rsp),%ecx
jle    3006 <dradbg+0x1ee6>
cmpl   $0x2,0x30(%rsp)
mov    0x78(%rsp),%rcx
mov    0x10(%rsp),%rsi
mov    0x1a8(%rsp),%rdi
jl     30eb <dradbg+0x1fcb>
add    $0xfffffffd,%esi
mov    %esi,%ebp
and    $0xfffffffe,%ebp
lea    0x4(%rax),%rbx
mov    %rbx,0xe0(%rsp)
lea    (%rax,%rbp,4),%rbx
add    $0xc,%rbx
mov    %rbx,0xa8(%rsp)
add    $0x3,%rbp
mov    %rbp,0xf0(%rsp)
mov    %esi,(%rsp)
shr    %esi
add    $0x1,%esi
mov    %rsi,0xc8(%rsp)
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,1),%rbp
mov    %rbp,0x80(%rsp)
mov    %rsi,0xc0(%rsp)
add    %esi,%esi
add    $0x2,%esi
mov    %esi,0xb8(%rsp)
lea    0x4(%rcx),%rsi
mov    %rsi,0xd8(%rsp)
lea    0x4(%rdi),%rsi
mov    %rsi,0x98(%rsp)
lea    0x8(%rdi),%rsi
mov    %rsi,0x50(%rsp)
add    $0x8,%rcx
mov    %rcx,0x38(%rsp)
add    $0x8,%rax
mov    $0x1,%esi
movl   $0xffffffff,0xa0(%rsp)
ff ff ff ff
mov    0x28(%rsp),%rcx
mov    %ecx,0xb0(%rsp)
jmp    2d95 <dradbg+0x1c75>
nopw   0x0(%rax,%rax,1)
mov    0x44(%rsp),%esi
add    $0x1,%esi
mov    0xa0(%rsp),%ecx
add    0x10(%rsp),%ecx
mov    %ecx,0xa0(%rsp)
mov    0xb0(%rsp),%ecx
add    0x28(%rsp),%ecx
mov    %ecx,0xb0(%rsp)
cmp    0x30(%rsp),%esi
je     30eb <dradbg+0x1fcb>
mov    %esi,0x44(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    2d60 <dradbg+0x1c40>
movslq 0xb0(%rsp),%r11
lea    0x1(%r11),%rcx
mov    %rcx,0x48(%rsp)
mov    0xf0(%rsp),%rcx
add    %r11,%rcx
mov    %rcx,0x58(%rsp)
movslq 0xa0(%rsp),%rsi
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rsi,4),%r10
mov    0xd8(%rsp),%rcx
lea    (%rcx,%r11,4),%r14
mov    0x98(%rsp),%rcx
lea    (%rcx,%r11,4),%r8
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x70(%rsp)
mov    0x80(%rsp),%rcx
mov    %rsi,0x8(%rsp)
add    %rsi,%rcx
mov    %rcx,0x68(%rsp)
xor    %r9d,%r9d
jmp    2e38 <dradbg+0x1d18>
nopl   0x0(%rax,%rax,1)
add    %rdx,%r11
add    $0x1,%r9
add    %r12,%r14
add    %r12,%r8
cmp    0x20(%rsp),%r9d
je     2d60 <dradbg+0x1c40>
cmpl   $0x3,0x10(%rsp)
jl     2e20 <dradbg+0x1d00>
movl   $0x2,0x18(%rsp)
cmpl   $0x6,(%rsp)
jae    2ee0 <dradbg+0x1dc0>
mov    %r11,%r15
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rbp
mov    0x50(%rsp),%rsi
lea    (%rsi,%r15,4),%rdi
mov    0x38(%rsp),%rsi
lea    (%rsi,%r15,4),%rbx
lea    (%rax,%rcx,4),%r13
mov    0x18(%rsp),%esi
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%r15,4),%xmm0
mulss  0x0(%r13,%r15,4),%xmm0
movss  -0x4(%r13,%r15,4),%xmm1
mulss  -0x4(%rdi,%r15,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rbx,%r15,4)
movss  0x0(%r13,%r15,4),%xmm0
mulss  -0x4(%rdi,%r15,4),%xmm0
movss  -0x4(%r13,%r15,4),%xmm1
mulss  (%rdi,%r15,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%r15,4)
add    $0x2,%r15
lea    (%r15,%rsi,1),%ecx
cmp    %ebp,%ecx
jl     2e80 <dradbg+0x1d60>
jmp    2e20 <dradbg+0x1d00>
nopl   0x0(%rax)
mov    %r9,%rcx
imul   %rdx,%rcx
mov    0x48(%rsp),%rsi
lea    (%rsi,%rcx,1),%rdi
add    0x58(%rsp),%rcx
mov    0x78(%rsp),%rsi
lea    (%rsi,%rdi,4),%rbx
lea    (%rsi,%rcx,4),%rsi
mov    0x1a8(%rsp),%rbp
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
cmp    0x70(%rsp),%rbx
setb   %r15b
cmp    %rsi,%r10
setb   %r13b
cmp    %rcx,%rbx
setb   %bl
cmp    %rsi,%rdi
setb   %dil
test   %r13b,%r15b
jne    2e51 <dradbg+0x1d31>
mov    %r11,%r15
mov    0x8(%rsp),%rcx
and    %dil,%bl
mov    0x10(%rsp),%rbp
jne    2e5e <dradbg+0x1d3e>
mov    0x80(%rsp),%rcx
lea    (%r11,%rcx,1),%r15
xor    %esi,%esi
mov    0xc0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r10,%rsi,8),%xmm0
movups 0x10(%r10,%rsi,8),%xmm1
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movups (%r8,%rsi,8),%xmm1
movups 0x10(%r8,%rsi,8),%xmm3
movaps %xmm1,%xmm4
shufps $0x88,%xmm3,%xmm4
shufps $0xdd,%xmm3,%xmm1
movaps %xmm1,%xmm3
mulps  %xmm0,%xmm3
mulps  %xmm2,%xmm1
mulps  %xmm4,%xmm2
subps  %xmm3,%xmm2
mulps  %xmm0,%xmm4
addps  %xmm4,%xmm1
movaps %xmm2,%xmm0
unpcklps %xmm1,%xmm0
unpckhps %xmm1,%xmm2
movups %xmm2,0x10(%r14,%rsi,8)
movups %xmm0,(%r14,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    2f80 <dradbg+0x1e60>
mov    0x68(%rsp),%rcx
mov    0xb8(%rsp),%esi
mov    %esi,0x18(%rsp)
cmp    0xc8(%rsp),%rdi
mov    0x10(%rsp),%rbp
je     2e20 <dradbg+0x1d00>
jmp    2e5e <dradbg+0x1d3e>
cmpl   $0x2,0x30(%rsp)
mov    0x78(%rsp),%rdx
mov    0x10(%rsp),%rcx
mov    0x1a8(%rsp),%rbp
jl     30eb <dradbg+0x1fcb>
mov    0x28(%rsp),%rsi
lea    0x2(%rsi),%r8d
mov    $0x1,%r10d
mov    $0xffffffff,%r9d
jmp    305c <dradbg+0x1f3c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10d
add    0x28(%rsp),%r8d
mov    0x10(%rsp),%rcx
add    %ecx,%r9d
cmp    0x30(%rsp),%r10d
je     30eb <dradbg+0x1fcb>
cmp    $0x3,%ecx
jl     3040 <dradbg+0x1f20>
movslq %r9d,%rdi
mov    $0x2,%r14d
mov    %r8d,%r11d
jmp    3082 <dradbg+0x1f62>
nop
add    $0x2,%r14d
add    $0x2,%r11d
mov    %rbx,%rdi
cmp    0x10(%rsp),%r14d
jge    3040 <dradbg+0x1f20>
lea    0x2(%rdi),%rbx
cmpl   $0x0,0x20(%rsp)
jle    3070 <dradbg+0x1f50>
movslq %r11d,%rsi
shl    $0x2,%rsi
mov    0x20(%rsp),%rcx
nopl   0x0(%rax)
movss  0x4(%rax,%rdi,4),%xmm0
movss  0x0(%rbp,%rsi,1),%xmm1
mulss  (%rax,%rbx,4),%xmm1
mulss  -0x4(%rbp,%rsi,1),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rdx,%rsi,1)
movss  0x4(%rax,%rdi,4),%xmm0
movss  (%rax,%rbx,4),%xmm1
mulss  -0x4(%rbp,%rsi,1),%xmm1
mulss  0x0(%rbp,%rsi,1),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rsi,1)
add    %r12,%rsi
add    $0xffffffff,%ecx
jne    30a0 <dradbg+0x1f80>
jmp    3070 <dradbg+0x1f50>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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