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
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
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    11eb <dradbg+0xcb>
jmp    128a <dradbg+0x16a>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1285 <dradbg+0x165>
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    1265 <dradbg+0x145>
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    121f <dradbg+0xff>
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    1200 <dradbg+0xe0>
jmp    1319 <dradbg+0x1f9>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1314 <dradbg+0x1f4>
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    12fd <dradbg+0x1dd>
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    12b7 <dradbg+0x197>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1298 <dradbg+0x178>
jmp    1319 <dradbg+0x1f9>
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    141d <dradbg+0x2fd>
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    1406 <dradbg+0x2e6>
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    1379 <dradbg+0x259>
mov    -0x60(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1340 <dradbg+0x220>
cmpl   $0x1,-0x4(%rbp)
jne    142c <dradbg+0x30c>
jmp    17ea <dradbg+0x6ca>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1440 <dradbg+0x320>
jmp    160b <dradbg+0x4eb>
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    1606 <dradbg+0x4e6>
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    15f3 <dradbg+0x4d3>
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    15ca <dradbg+0x4aa>
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    14d2 <dradbg+0x3b2>
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    14a7 <dradbg+0x387>
jmp    15f8 <dradbg+0x4d8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1462 <dradbg+0x342>
jmp    17ea <dradbg+0x6ca>
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    17e5 <dradbg+0x6c5>
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    17d2 <dradbg+0x6b2>
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    17bf <dradbg+0x69f>
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    16c7 <dradbg+0x5a7>
jmp    17c4 <dradbg+0x6a4>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1678 <dradbg+0x558>
jmp    17d7 <dradbg+0x6b7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    162d <dradbg+0x50d>
jmp    17ea <dradbg+0x6ca>
movss  0x180e(%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    1b43 <dradbg+0xa23>
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    1989 <dradbg+0x869>
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    18e7 <dradbg+0x7c7>
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    1b30 <dradbg+0xa10>
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    1b1d <dradbg+0x9fd>
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    1a80 <dradbg+0x960>
jmp    1b22 <dradbg+0xa02>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19d3 <dradbg+0x8b3>
jmp    1b35 <dradbg+0xa15>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    182d <dradbg+0x70d>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1bc9 <dradbg+0xaa9>
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    1bb6 <dradbg+0xa96>
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    1b73 <dradbg+0xa53>
jmp    1bbb <dradbg+0xa9b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b51 <dradbg+0xa31>
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    1ca4 <dradbg+0xb84>
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    1c91 <dradbg+0xb71>
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    1c17 <dradbg+0xaf7>
jmp    1c96 <dradbg+0xb76>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1be4 <dradbg+0xac4>
cmpl   $0x1,-0x4(%rbp)
jne    1cb3 <dradbg+0xb93>
jmp    1fe2 <dradbg+0xec2>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1cc7 <dradbg+0xba7>
jmp    1e52 <dradbg+0xd32>
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    1e4d <dradbg+0xd2d>
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    1e3a <dradbg+0xd1a>
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    1e1a <dradbg+0xcfa>
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    1d34 <dradbg+0xc14>
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    1d15 <dradbg+0xbf5>
jmp    1e3f <dradbg+0xd1f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ce2 <dradbg+0xbc2>
jmp    1fe2 <dradbg+0xec2>
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    1fdd <dradbg+0xebd>
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    1fca <dradbg+0xeaa>
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    1fb7 <dradbg+0xe97>
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    1ed1 <dradbg+0xdb1>
jmp    1fbc <dradbg+0xe9c>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ea0 <dradbg+0xd80>
jmp    1fcf <dradbg+0xeaf>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e6d <dradbg+0xd4d>
jmp    1fe2 <dradbg+0xec2>
cmpl   $0x1,-0x4(%rbp)
jne    1ff1 <dradbg+0xed1>
jmp    23a9 <dradbg+0x1289>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    202c <dradbg+0xf0c>
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    1ff8 <dradbg+0xed8>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    20a9 <dradbg+0xf89>
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    2096 <dradbg+0xf76>
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    2059 <dradbg+0xf39>
jmp    209b <dradbg+0xf7b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    203a <dradbg+0xf1a>
mov    -0x90(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    20bd <dradbg+0xf9d>
jmp    2238 <dradbg+0x1118>
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    2233 <dradbg+0x1113>
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    2220 <dradbg+0x1100>
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    220d <dradbg+0x10ed>
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    2132 <dradbg+0x1012>
jmp    2212 <dradbg+0x10f2>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2107 <dradbg+0xfe7>
jmp    2225 <dradbg+0x1105>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20d6 <dradbg+0xfb6>
jmp    23a9 <dradbg+0x1289>
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    23a9 <dradbg+0x1289>
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    2396 <dradbg+0x1276>
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    237f <dradbg+0x125f>
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    229b <dradbg+0x117b>
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    227c <dradbg+0x115c>
jmp    239b <dradbg+0x127b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2251 <dradbg+0x1131>
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,0x80(%rsp)
mov    %r8,0x8(%rsp)
mov    %ecx,0x70(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%ebx
mov    0x1a8(%rsp),%r15
mov    %esi,%eax
cvtsi2ss %esi,%xmm0
imul   %edi,%eax
mov    %eax,0x4c(%rsp)
movss  0x2e9a(%rip),%xmm1
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
lea    -0x1(%rbx),%eax
mov    %rax,0xa0(%rsp)
mov    %rbp,0x38(%rsp)
lea    0x1(%rbp),%eax
mov    %eax,0x48(%rsp)
cmp    %r14d,%ebx
mov    %r14,0x28(%rsp)
mov    %rbx,0x18(%rsp)
jge    13c8 <dradbg+0x2a8>
test   %ebx,%ebx
jle    1660 <dradbg+0x540>
mov    0x18(%rsp),%edx
movslq 0x4c(%rsp),%r11
mov    0x28(%rsp),%rax
lea    -0x1(%rax),%esi
mov    %esi,0x50(%rsp)
mov    %eax,%esi
and    $0x3,%esi
mov    %esi,0x40(%rsp)
and    $0xfffffffc,%eax
mov    %eax,0x88(%rsp)
mov    %r11,%r9
shl    $0x4,%r9
lea    (%r11,%r11,2),%rax
mov    0x8(%rsp),%rsi
lea    (%rsi,%rax,4),%rax
mov    %rax,0xa8(%rsp)
lea    (%rsi,%r11,8),%rax
mov    %rax,0x30(%rsp)
lea    (%rsi,%r11,4),%rax
mov    %rax,0xb8(%rsp)
mov    %rdx,%r10
shl    $0x4,%r10
lea    (%rdx,%rdx,2),%rsi
lea    (%r15,%rsi,4),%rsi
mov    %rsi,0xd8(%rsp)
lea    (%r15,%rdx,8),%rsi
mov    %rsi,0xd0(%rsp)
lea    (%r15,%rdx,4),%rsi
mov    %rsi,0xc8(%rsp)
lea    0x0(,%r11,4),%rbx
lea    0x0(,%rdx,4),%rax
xor    %ecx,%ecx
xor    %r14d,%r14d
mov    %rbx,0x60(%rsp)
mov    %rax,0x78(%rsp)
mov    %r10,0x10(%rsp)
jmp    1281 <dradbg+0x161>
add    $0x1,%r14
add    $0x4,%rcx
cmp    %rdx,%r14
je     1660 <dradbg+0x540>
cmpl   $0x0,0x28(%rsp)
jle    1270 <dradbg+0x150>
mov    %r14,%rsi
mov    %r14,0x58(%rsp)
mov    %r14,%r8
cmpl   $0x3,0x50(%rsp)
mov    %r9,%rax
jb     1370 <dradbg+0x250>
mov    0x88(%rsp),%r13d
mov    0xc8(%rsp),%rbp
mov    0xd0(%rsp),%r14
mov    0xd8(%rsp),%r15
mov    0x1a8(%rsp),%r12
mov    0xb8(%rsp),%r9
mov    0x30(%rsp),%r10
mov    0xa8(%rsp),%rbx
mov    0x8(%rsp),%rdi
mov    0x58(%rsp),%r8
mov    %r8,%rsi
mov    %rcx,0x20(%rsp)
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    0x10(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r14
add    %rax,%rbp
mov    %r11,%rax
mov    %rdx,%r11
mov    %rcx,%rdx
mov    0x20(%rsp),%rcx
add    $0xfffffffc,%r13d
jne    12f0 <dradbg+0x1d0>
cmpl   $0x0,0x40(%rsp)
mov    0x1a8(%rsp),%r15
mov    %rax,%r9
mov    0x60(%rsp),%rbx
mov    0x78(%rsp),%rax
mov    0x58(%rsp),%r14
je     1270 <dradbg+0x150>
mov    0x8(%rsp),%rdi
lea    (%rdi,%rsi,4),%rsi
lea    (%r15,%r8,4),%rdi
mov    0x40(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
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
jle    1660 <dradbg+0x540>
movslq 0x18(%rsp),%r13
movslq 0x4c(%rsp),%r12
mov    0xa0(%rsp),%rax
lea    0x1(%rax),%r8
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x78(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x88(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x8(%rsp),%rax
lea    0x30(%rax),%rdi
lea    0x0(,%r12,4),%rcx
mov    %rcx,0x20(%rsp)
lea    0x30(%r15),%r9
lea    0x0(,%r13,4),%rcx
mov    %rcx,0x10(%rsp)
add    $0xc,%rax
mov    %rax,0x40(%rsp)
lea    0xc(%r15),%rax
mov    %rax,0x50(%rsp)
xor    %edx,%edx
xor    %r10d,%r10d
xor    %r11d,%r11d
mov    %r8,0x58(%rsp)
jmp    148f <dradbg+0x36f>
cs nopw 0x0(%rax,%rax,1)
add    %r13,%r10
add    %r12,%rdx
add    $0x1,%r11d
add    0x20(%rsp),%rdi
add    0x10(%rsp),%r9
cmp    0x28(%rsp),%r11d
je     1660 <dradbg+0x540>
cmpl   $0x0,0x18(%rsp)
jle    1470 <dradbg+0x350>
xor    %eax,%eax
cmpl   $0x7,0xa0(%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    0x8(%rsp),%rbx
lea    (%rbx,%rcx,4),%rcx
cmp    %rcx,%rsi
jae    14e6 <dradbg+0x3c6>
lea    (%r8,%r10,1),%rcx
lea    (%r15,%rcx,4),%rcx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rdx,4),%rsi
mov    %rdx,%r14
mov    %r10,%rbp
cmp    %rcx,%rsi
jb     1580 <dradbg+0x460>
cmpq   $0x0,0x78(%rsp)
je     164b <dradbg+0x52b>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
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,0x88(%rsp)
01
je     155e <dradbg+0x43e>
lea    (%rdx,%rax,1),%rcx
add    %r10,%rax
mov    0x8(%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    0x60(%rsp),%r8
je     1470 <dradbg+0x350>
mov    0x60(%rsp),%rax
lea    (%rdx,%rax,1),%r14
lea    (%r10,%rax,1),%rbp
cs nopw 0x0(%rax,%rax,1)
mov    0x18(%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    0x8(%rsp),%rsi
lea    (%rsi,%r14,4),%rsi
lea    (%r15,%rbp,4),%r15
neg    %ecx
xor    %r13d,%r13d
nopl   0x0(%rax)
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    0x58(%rsp),%r8
cmp    $0x3,%ebx
jb     1470 <dradbg+0x350>
mov    0x40(%rsp),%rcx
lea    (%rcx,%r14,4),%rcx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rbp,4),%rsi
mov    0x18(%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,0x88(%rsp)
01
jne    153e <dradbg+0x41e>
jmp    155e <dradbg+0x43e>
mov    0x28(%rsp),%r11
mov    %r11d,%ecx
mov    0x18(%rsp),%rax
imul   %eax,%ecx
mov    %rcx,0x30(%rsp)
sarl   0x48(%rsp)
add    %eax,%eax
mov    %rax,0x50(%rsp)
cmpl   $0x3,0x38(%rsp)
jl     1834 <dradbg+0x714>
movslq 0x18(%rsp),%rcx
movslq 0x50(%rsp),%r10
movslq 0x4c(%rsp),%rdx
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%esi
mov    0x30(%rsp),%rbp
imul   %ebp,%esi
mov    0x48(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r12d
cmovge %eax,%r12d
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %eax,0x88(%rsp)
mov    %rcx,0x60(%rsp)
lea    (%rcx,%rcx,1),%rax
mov    0x8(%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,0x78(%rsp)
mov    %r12d,0x10(%rsp)
jmp    174f <dradbg+0x62f>
mov    %rbp,%r12
mov    0x8(%rsp),%rbp
movss  -0x4(%rbp,%rbx,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r15,%r12,4)
mov    0x10(%rsp),%r12d
movss  0x0(%rbp,%rbx,4),%xmm1
addss  %xmm1,%xmm1
mov    0x20(%rsp),%rbx
movss  %xmm1,(%r15,%rbx,4)
add    %r10,%r14
add    $0x1,%r8d
mov    0x30(%rsp),%rbp
add    %ebp,%r13d
sub    %ebp,%esi
add    %r10,%r9
cmp    %r12d,%r8d
je     1834 <dradbg+0x714>
test   %r11d,%r11d
jle    1732 <dradbg+0x612>
movslq %esi,%rbx
movslq %r13d,%rbp
cmp    $0x1,%r11d
mov    %rbx,0x20(%rsp)
jne    1770 <dradbg+0x650>
mov    %r14,%rbx
test   $0x1,%r11b
je     1732 <dradbg+0x612>
jmp    1700 <dradbg+0x5e0>
mov    %esi,0x58(%rsp)
mov    %rbp,%rsi
mov    0x60(%rsp),%rbp
lea    (%rbx,%rbp,1),%r10
lea    (%rsi,%rbp,1),%r12
lea    (%r15,%rbx,4),%rbp
lea    (%r15,%r10,4),%r10
mov    %rsi,0x40(%rsp)
lea    (%r15,%rsi,4),%r11
lea    (%r15,%r12,4),%r15
mov    0x88(%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,0x20(%rsp)
mov    0x78(%rsp),%r10
add    %r10,%rbx
mov    0x40(%rsp),%rbp
add    %rsi,%rbp
mov    0x28(%rsp),%r11
mov    0x1a8(%rsp),%r15
mov    0x58(%rsp),%esi
mov    0x10(%rsp),%r12d
test   $0x1,%r11b
je     1732 <dradbg+0x612>
jmp    1700 <dradbg+0x5e0>
mov    0xa0(%rsp),%rax
sar    %eax
mov    %rax,0xa0(%rsp)
cmpl   $0x1,0x18(%rsp)
jne    20ce <dradbg+0xfae>
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x6c(%rsp)
cmp    $0x3,%eax
mov    0x18(%rsp),%rcx
mov    0x1b0(%rsp),%r8
jl     2757 <dradbg+0x1637>
movsd  0xc0(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm9
cvtsd2ss %xmm0,%xmm10
mov    0x6c(%rsp),%edx
mov    0x70(%rsp),%r12d
imul   %r12d,%edx
movslq %edx,%r9
movslq %r12d,%rdi
mov    0x38(%rsp),%rax
add    $0xfffffffe,%eax
imul   %r12d,%eax
mov    %eax,0xfc(%rsp)
mov    0x48(%rsp),%eax
cmp    $0x4,%eax
mov    $0x3,%ecx
cmovge %eax,%ecx
mov    %ecx,0x20(%rsp)
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
mov    %ecx,0xe8(%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,%xmm9,%xmm9
shufps $0x0,%xmm10,%xmm10
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,0xc8(%rsp)
and    %rsi,%rax
mov    %rax,0xb8(%rsp)
movss  0x26a4(%rip),%xmm2
movaps 0x26a8(%rip),%xmm8
lea    (%rdi,%rdi,1),%eax
mov    %eax,0xf8(%rsp)
mov    0x1a0(%rsp),%r14
lea    0x4(%r14,%rbp,4),%rax
mov    %rax,0x160(%rsp)
mov    %rbp,0x58(%rsp)
lea    0x4(%r8,%rbp,4),%rax
mov    %rax,0xa8(%rsp)
lea    (%r14,%rbx,4),%rax
mov    %rax,0x148(%rsp)
mov    %rbx,0xb0(%rsp)
lea    (%r8,%rbx,4),%rax
mov    %rax,0xe0(%rsp)
lea    (%r8,%rdi,4),%rax
mov    %rax,0x110(%rsp)
lea    (%r8,%r9,4),%rax
mov    %rax,0x108(%rsp)
mov    %rdi,0x90(%rsp)
lea    (%rcx,%rdi,1),%rax
mov    %rax,0x120(%rsp)
mov    %r9,0x98(%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    1a48 <dradbg+0x928>
nopw   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%eax
add    $0x1,%eax
mov    0x4c(%rsp),%edx
sub    %r12d,%edx
mov    0xf0(%rsp),%ecx
add    %r12d,%ecx
cmp    0xe8(%rsp),%eax
je     224f <dradbg+0x112f>
mov    %eax,0xc0(%rsp)
mov    %edx,0x4c(%rsp)
movslq %edx,%rax
mov    %rax,0x10(%rsp)
lea    (%r14,%rax,4),%r15
mov    %ecx,0xf0(%rsp)
movslq %ecx,%rax
mov    %rax,0x8(%rsp)
lea    (%r14,%rax,4),%r11
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
xorps  %xmm8,%xmm3
unpcklps %xmm2,%xmm3
mulps  %xmm10,%xmm3
mulps  %xmm9,%xmm2
addps  %xmm3,%xmm2
movaps %xmm2,%xmm4
shufps $0x55,%xmm2,%xmm4
test   %r12d,%r12d
jle    1b2a <dradbg+0xa0a>
cmp    $0x4,%r12d
jae    1e10 <dradbg+0xcf0>
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%r14
mov    0x98(%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    0xb0(%rsp),%rdi
sub    %rsi,%rdi
lea    (%r8,%r14,4),%rax
mov    %rbp,%r14
lea    (%r8,%r9,4),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
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    1b00 <dradbg+0x9e0>
cmpl   $0x5,0x38(%rsp)
jb     1a20 <dradbg+0x900>
mov    0x160(%rsp),%rax
mov    0x8(%rsp),%rdx
lea    (%rax,%rdx,4),%rsi
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
xorps  %xmm8,%xmm4
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
mov    %rax,0x78(%rsp)
cmp    %rax,%r11
setb   %al
mov    %rsi,0x60(%rsp)
cmp    %rsi,%r15
setb   %bl
and    %al,%bl
mov    %bl,0x88(%rsp)
mov    0xb8(%rsp),%rax
add    %rax,%rdx
mov    %rdx,0xd8(%rsp)
add    %rcx,%rax
mov    %rax,0xd0(%rsp)
mov    $0x2,%r13d
mov    0xf8(%rsp),%r10d
mov    0xfc(%rsp),%edx
movaps %xmm2,%xmm6
jmp    1bd5 <dradbg+0xab5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13d
sub    %r12d,%edx
add    %r12d,%r10d
cmp    0x20(%rsp),%r13d
je     1a20 <dradbg+0x900>
movaps %xmm2,%xmm3
shufps $0x11,%xmm6,%xmm3
shufps $0xe2,%xmm6,%xmm3
movaps %xmm4,%xmm7
unpcklps %xmm6,%xmm7
mulps  %xmm3,%xmm7
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
test   %r12d,%r12d
jle    1bc0 <dradbg+0xaa0>
movslq %edx,%r9
movslq %r10d,%rcx
xor    %eax,%eax
movaps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm7
cmpl   $0x3,0x58(%rsp)
jae    1c70 <dradbg+0xb50>
mov    0x8(%rsp),%rbx
mov    0x10(%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),%xmm0
mulss  %xmm6,%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%rcx,%rax,4),%xmm0
mulss  %xmm7,%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %eax,%esi
jne    1c30 <dradbg+0xb10>
jmp    1bc0 <dradbg+0xaa0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r8,%r9,4),%rbx
lea    (%r8,%rcx,4),%rbp
mov    0xa8(%rsp),%rax
mov    %rcx,0x50(%rsp)
lea    (%rax,%rcx,4),%rcx
mov    %r9,0x40(%rsp)
lea    (%rax,%r9,4),%rsi
cmp    %rcx,%r11
setb   %al
mov    0x60(%rsp),%rdi
cmp    %rdi,%rbp
setb   %r12b
and    %al,%r12b
or     0x88(%rsp),%r12b
cmp    %rsi,%r11
setb   %al
cmp    %rdi,%rbx
setb   %r9b
cmp    %rcx,%r15
setb   %cl
mov    0x78(%rsp),%rdi
cmp    %rdi,%rbp
setb   %r8b
cmp    %rsi,%r15
setb   %sil
cmp    %rdi,%rbx
setb   %r14b
test   %r12b,%r12b
jne    1dd2 <dradbg+0xcb2>
and    %r9b,%al
mov    0x70(%rsp),%r12d
jne    1de3 <dradbg+0xcc3>
and    %r8b,%cl
mov    0x40(%rsp),%r9
mov    $0x0,%eax
jne    1dae <dradbg+0xc8e>
and    %r14b,%sil
mov    0x1b0(%rsp),%r8
mov    0x50(%rsp),%rcx
jne    1d97 <dradbg+0xc77>
mov    0xb8(%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),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%r11,%rsi,4)
movups (%rbx,%rsi,4),%xmm0
movups (%r15,%rsi,4),%xmm1
mulps  %xmm7,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%r15,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1d40 <dradbg+0xc20>
mov    0xd8(%rsp),%rbx
mov    0xd0(%rsp),%rbp
mov    %eax,%esi
cmp    %rax,0xc8(%rsp)
je     1bc0 <dradbg+0xaa0>
jmp    1c14 <dradbg+0xaf4>
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rbp
mov    0x1a0(%rsp),%r14
jmp    1c14 <dradbg+0xaf4>
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rbp
mov    0x1b0(%rsp),%r8
mov    0x1a0(%rsp),%r14
mov    0x50(%rsp),%rcx
jmp    1c14 <dradbg+0xaf4>
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rbp
mov    0x70(%rsp),%r12d
jmp    1ded <dradbg+0xccd>
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%rbp
mov    0x1b0(%rsp),%r8
mov    0x1a0(%rsp),%r14
mov    0x40(%rsp),%r9
mov    0x50(%rsp),%rcx
xor    %eax,%eax
jmp    1c14 <dradbg+0xaf4>
xchg   %ax,%ax
mov    0x148(%rsp),%rcx
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,4),%rax
mov    0x10(%rsp),%rdx
lea    (%rcx,%rdx,4),%rbp
cmp    %rbp,%r11
setb   0x40(%rsp)
cmp    %rax,%r15
setb   %r13b
mov    0xe0(%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   0x50(%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   0x60(%rsp)
cmp    %rdi,%r15
setb   %dil
cmp    %rbp,%r9
setb   %r9b
cmp    %r12,%r15
setb   %r10b
cmp    %rbp,%r14
setb   %bpl
test   %r13b,0x40(%rsp)
jne    20a0 <dradbg+0xf80>
and    %r8b,%cl
jne    20a0 <dradbg+0xf80>
and    0x50(%rsp),%dl
mov    0x1b0(%rsp),%r8
jne    207a <dradbg+0xf5a>
and    %al,%bl
jne    207a <dradbg+0xf5a>
and    0x60(%rsp),%sil
jne    207a <dradbg+0xf5a>
and    %r9b,%dil
mov    0x70(%rsp),%r12d
jne    1aa5 <dradbg+0x985>
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    $0x0,%esi
mov    0x90(%rsp),%r14
mov    0x98(%rsp),%r9
and    %bpl,%r10b
jne    1ac1 <dradbg+0x9a1>
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
cmpq   $0x0,0x140(%rsp)
mov    0x110(%rsp),%rax
mov    0x108(%rsp),%rbp
je     2060 <dradbg+0xf40>
mov    0x128(%rsp),%rcx
mov    0x8(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdx
mov    0x10(%rsp),%rsi
lea    (%rcx,%rsi,4),%rsi
mov    0x130(%rsp),%rdi
xor    %ecx,%ecx
mov    0x1a0(%rsp),%r14
nopw   0x0(%rax,%rax,1)
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    1f80 <dradbg+0xe60>
testb  $0x1,0x138(%rsp)
01
je     201b <dradbg+0xefb>
mov    0x8(%rsp),%rax
add    %rcx,%rax
mov    0x10(%rsp),%rdx
add    %rcx,%rdx
mov    0x90(%rsp),%rsi
add    %rcx,%rsi
movups (%r8,%rcx,4),%xmm3
add    0x98(%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    0xb0(%rsp),%rax
je     1b2a <dradbg+0xa0a>
mov    0x100(%rsp),%rsi
mov    0x8(%rsp),%rax
lea    (%rsi,%rax,1),%rcx
mov    0x10(%rsp),%rax
lea    (%rsi,%rax,1),%rdx
mov    0x120(%rsp),%r14
mov    0x118(%rsp),%r9
jmp    1ac1 <dradbg+0x9a1>
xor    %ecx,%ecx
mov    0x1a0(%rsp),%r14
testb  $0x1,0x138(%rsp)
01
jne    1fd6 <dradbg+0xeb6>
jmp    201b <dradbg+0xefb>
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%r14
mov    0x98(%rsp),%r9
mov    0x70(%rsp),%r12d
jmp    1ac1 <dradbg+0x9a1>
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%rdx
xor    %esi,%esi
mov    0x90(%rsp),%r14
mov    0x98(%rsp),%r9
mov    0x70(%rsp),%r12d
mov    0x1b0(%rsp),%r8
jmp    1ac1 <dradbg+0x9a1>
mov    0xa0(%rsp),%rax
cmp    0x28(%rsp),%eax
jge    24a0 <dradbg+0x1380>
cmpl   $0x3,0x38(%rsp)
mov    0x80(%rsp),%r13
jl     29a2 <dradbg+0x1882>
mov    0x50(%rsp),%rax
lea    -0x2(%rax),%ecx
mov    %ecx,0x10(%rsp)
movslq 0x4c(%rsp),%rdx
add    $0x2,%eax
mov    %eax,0x58(%rsp)
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    0x30(%rsp),%rax
imul   %eax,%ecx
add    $0x2,%ecx
mov    %ecx,0x40(%rsp)
movslq 0x18(%rsp),%rdi
mov    0x48(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%esi
cmovge %ecx,%esi
mov    %esi,0x78(%rsp)
add    $0x2,%eax
mov    %eax,0x60(%rsp)
shl    $0x2,%rdi
shl    $0x2,%rdx
mov    $0x1,%ecx
mov    0x28(%rsp),%rbx
jmp    218b <dradbg+0x106b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%ecx
add    $0x1,%ecx
mov    0x50(%rsp),%rax
add    %eax,0x10(%rsp)
add    %eax,0x58(%rsp)
mov    0x30(%rsp),%rax
sub    %eax,0x40(%rsp)
add    %eax,0x60(%rsp)
cmp    0x78(%rsp),%ecx
je     1851 <dradbg+0x731>
mov    %ecx,0x20(%rsp)
cmpl   $0x3,0x18(%rsp)
jl     2160 <dradbg+0x1040>
mov    $0x2,%ebp
mov    0x60(%rsp),%r12d
mov    0x40(%rsp),%r13d
mov    0x58(%rsp),%r15d
mov    0x10(%rsp),%esi
jmp    21c8 <dradbg+0x10a8>
add    $0x2,%ebp
add    $0xfffffffe,%esi
add    $0x2,%r15d
add    $0x2,%r13d
add    $0x2,%r12d
cmp    0x18(%rsp),%ebp
jge    2160 <dradbg+0x1040>
cmpl   $0x0,0x28(%rsp)
jle    21b0 <dradbg+0x1090>
movslq %r12d,%rcx
movslq %r13d,%rax
movslq %r15d,%r8
movslq %esi,%r9
mov    %ebx,%r10d
mov    0x8(%rsp),%r11
mov    0x1a8(%rsp),%r14
nopl   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    21f0 <dradbg+0x10d0>
jmp    21b0 <dradbg+0x1090>
cmpl   $0x3,0x38(%rsp)
mov    0x18(%rsp),%rcx
jl     2757 <dradbg+0x1637>
mov    0x48(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r12d
cmovge %eax,%r12d
mov    0xb0(%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,0x20(%rsp)
lea    0x4(%rax),%r13
mov    $0x1,%esi
mov    0x70(%rsp),%eax
mov    %eax,%ecx
mov    0xe0(%rsp),%r9
jmp    22ce <dradbg+0x11ae>
nopl   (%rax)
add    $0x1,%esi
add    %eax,%ecx
cmp    %r12d,%esi
je     25dd <dradbg+0x14bd>
test   %eax,%eax
jle    22c0 <dradbg+0x11a0>
movslq %ecx,%rdx
cmp    $0x8,%eax
jb     22fb <dradbg+0x11db>
lea    (%r9,%rdx,4),%rdi
mov    0x1b0(%rsp),%rbp
cmp    %rbp,%rdi
jbe    2313 <dradbg+0x11f3>
lea    0x0(,%rdx,4),%rdi
add    %rbp,%rdi
cmp    %r9,%rdi
jae    2313 <dradbg+0x11f3>
xor    %edi,%edi
testb  $0x1,0xb0(%rsp)
01
jne    2400 <dradbg+0x12e0>
mov    %rdi,%rbx
jmp    2425 <dradbg+0x1305>
test   %r10,%r10
je     248f <dradbg+0x136f>
mov    0x20(%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    2340 <dradbg+0x1220>
test   $0x1,%r11b
je     23ce <dradbg+0x12ae>
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    0xb0(%rsp),%r14
mov    0xe0(%rsp),%r9
je     22c0 <dradbg+0x11a0>
add    %r14,%rdx
mov    %r14,%rdi
testb  $0x1,0xb0(%rsp)
01
je     230b <dradbg+0x11eb>
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     22c0 <dradbg+0x11a0>
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
mov    0xb0(%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    2460 <dradbg+0x1340>
jmp    22c0 <dradbg+0x11a0>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    239e <dradbg+0x127e>
jmp    23ce <dradbg+0x12ae>
cmpl   $0x3,0x38(%rsp)
mov    0x80(%rsp),%r13
jl     29a2 <dradbg+0x1882>
movslq 0x4c(%rsp),%r12
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%r10d
mov    0x30(%rsp),%rcx
imul   %ecx,%r10d
movslq 0x18(%rsp),%r13
mov    0x48(%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    0x50(%rsp),%rax
mov    %eax,%r14d
jmp    252d <dradbg+0x140d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15d
add    0x50(%rsp),%r14d
mov    0x30(%rsp),%rax
sub    %eax,%r10d
add    %eax,%r11d
cmp    %r8d,%r15d
je     1851 <dradbg+0x731>
cmpl   $0x0,0x28(%rsp)
mov    0x18(%rsp),%rdx
jle    2510 <dradbg+0x13f0>
movslq %r11d,%rax
lea    (%r9,%rax,4),%rbp
movslq %r10d,%rax
lea    (%r9,%rax,4),%rbx
movslq %r14d,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
xor    %ecx,%ecx
jmp    2572 <dradbg+0x1452>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
add    %r13,%rbp
add    %r13,%rbx
add    %r12,%rdi
cmp    0x28(%rsp),%ecx
je     2510 <dradbg+0x13f0>
cmp    $0x3,%edx
jl     2560 <dradbg+0x1440>
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    0x18(%rsp),%edx
mov    0x18(%rsp),%rdx
jl     2580 <dradbg+0x1460>
jmp    2560 <dradbg+0x1440>
cmpl   $0x3,0x38(%rsp)
mov    0x18(%rsp),%rcx
jl     2757 <dradbg+0x1637>
mov    0x30(%rsp),%rdx
mov    %edx,%r15d
imul   0x6c(%rsp),%r15d
mov    0x48(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
movslq %ecx,%rdi
mov    0x28(%rsp),%rax
and    $0xfffffffe,%eax
mov    %eax,0x58(%rsp)
mov    %rdi,0x8(%rsp)
add    %rdi,%rdi
mov    $0x1,%r13d
mov    %edx,%r12d
mov    %esi,0x10(%rsp)
jmp    2648 <dradbg+0x1528>
add    $0x1,%r13d
mov    0x30(%rsp),%rax
add    %eax,%r12d
sub    %eax,%r15d
cmp    %esi,%r13d
je     2757 <dradbg+0x1637>
cmpl   $0x0,0x28(%rsp)
jle    2630 <dradbg+0x1510>
movslq %r15d,%rbp
movslq %r12d,%r14
cmpl   $0x1,0x28(%rsp)
je     2716 <dradbg+0x15f6>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
lea    (%rcx,%r14,1),%r8
mov    0x80(%rsp),%r10
lea    (%r10,%rbp,4),%rcx
mov    0x1a8(%rsp),%r9
mov    %rbp,0x20(%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    0x58(%rsp),%r11d
xor    %r8d,%r8d
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    26b0 <dradbg+0x1590>
mov    0x20(%rsp),%rbp
add    %r8,%rbp
add    %r8,%r14
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%esi
testb  $0x1,0x28(%rsp)
je     2630 <dradbg+0x1510>
mov    0x80(%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    2630 <dradbg+0x1510>
cmp    $0x1,%ecx
mov    0x80(%rsp),%r13
je     310b <dradbg+0x1feb>
mov    0x28(%rsp),%r12
cmp    %r12d,0xa0(%rsp)
jge    2890 <dradbg+0x1770>
cmpl   $0x3,0x38(%rsp)
jl     29a2 <dradbg+0x1882>
mov    0x30(%rsp),%rcx
mov    0x6c(%rsp),%r8d
imul   %ecx,%r8d
add    $0x2,%r8d
movslq 0x18(%rsp),%rax
lea    0x2(%rcx),%r9d
mov    0x48(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%edx
cmovge %ecx,%edx
mov    %edx,0x20(%rsp)
shl    $0x2,%rax
mov    $0x1,%r10d
jmp    27da <dradbg+0x16ba>
add    $0x1,%r10d
mov    0x30(%rsp),%rcx
sub    %ecx,%r8d
add    %ecx,%r9d
cmp    0x20(%rsp),%r10d
je     29a2 <dradbg+0x1882>
cmpl   $0x3,0x18(%rsp)
jl     27c0 <dradbg+0x16a0>
mov    $0x2,%r15d
mov    %r9d,%r11d
mov    %r8d,%r14d
jmp    2803 <dradbg+0x16e3>
nop
add    $0x2,%r15d
add    $0x2,%r14d
add    $0x2,%r11d
cmp    0x18(%rsp),%r15d
jge    27c0 <dradbg+0x16a0>
test   %r12d,%r12d
jle    27f0 <dradbg+0x16d0>
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    2840 <dradbg+0x1720>
jmp    27f0 <dradbg+0x16d0>
cmpl   $0x3,0x38(%rsp)
jl     29a2 <dradbg+0x1882>
mov    0x30(%rsp),%rcx
mov    0x6c(%rsp),%eax
imul   %ecx,%eax
mov    %eax,0x6c(%rsp)
movslq 0x18(%rsp),%r15
mov    0x48(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %edx,0x20(%rsp)
lea    0x8(%r13),%r9
shl    $0x2,%r15
mov    0x1a8(%rsp),%rax
lea    0x8(%rax),%r10
mov    $0x1,%r14d
mov    %ecx,%r11d
mov    0x18(%rsp),%r8
jmp    290b <dradbg+0x17eb>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
mov    0x30(%rsp),%rax
sub    %eax,0x6c(%rsp)
add    %eax,%r11d
cmp    0x20(%rsp),%r14d
je     29a2 <dradbg+0x1882>
test   %r12d,%r12d
jle    28f0 <dradbg+0x17d0>
movslq %r11d,%rcx
lea    (%r9,%rcx,4),%rbp
lea    (%r10,%rcx,4),%rbx
movslq 0x6c(%rsp),%rcx
lea    (%r10,%rcx,4),%rdx
lea    (%r9,%rcx,4),%rsi
xor    %ecx,%ecx
jmp    2944 <dradbg+0x1824>
nopl   0x0(%rax)
add    $0x1,%ecx
add    %r15,%rbp
add    %r15,%rbx
add    %r15,%rdx
add    %r15,%rsi
cmp    %r12d,%ecx
je     28f0 <dradbg+0x17d0>
cmp    $0x3,%r8d
jl     2930 <dradbg+0x1810>
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     2950 <dradbg+0x1830>
jmp    2930 <dradbg+0x1810>
mov    0x70(%rsp),%ecx
test   %ecx,%ecx
mov    0x1a8(%rsp),%r10
mov    0x1b0(%rsp),%rbx
mov    0x1a0(%rsp),%rax
jle    2b44 <dradbg+0x1a24>
mov    %ecx,%r9d
cmp    $0x8,%ecx
jb     29e4 <dradbg+0x18c4>
lea    (%rbx,%r9,4),%rcx
cmp    %rax,%rcx
jbe    2a5c <dradbg+0x193c>
lea    (%rax,%r9,4),%rcx
cmp    %rbx,%rcx
jbe    2a5c <dradbg+0x193c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     2a14 <dradbg+0x18f4>
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2a00 <dradbg+0x18e0>
cmp    $0x3,%rdx
jb     2b44 <dradbg+0x1a24>
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    2a20 <dradbg+0x1900>
jmp    2b44 <dradbg+0x1a24>
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    2a80 <dradbg+0x1960>
xor    %edi,%edi
jmp    2af8 <dradbg+0x19d8>
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    2aa0 <dradbg+0x1980>
test   %rdx,%rdx
je     2b3b <dradbg+0x1a1b>
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    2b20 <dradbg+0x1a00>
cmp    %r9,%rcx
jne    29e6 <dradbg+0x18c6>
cmpl   $0x2,0x38(%rsp)
mov    0x18(%rsp),%rcx
jl     310b <dradbg+0x1feb>
mov    0x1b8(%rsp),%rax
movslq %ecx,%rdx
mov    0x28(%rsp),%rcx
lea    -0x1(%rcx),%esi
mov    %esi,0x8(%rsp)
mov    %ecx,%esi
and    $0x3,%esi
mov    %esi,0x10(%rsp)
and    $0xfffffffc,%ecx
mov    %ecx,0x58(%rsp)
lea    0x0(,%rdx,4),%r12
lea    (%r12,%r12,2),%r14
lea    (%r14,%r13,1),%rcx
mov    %rcx,0x40(%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    0x30(%rsp),%rcx
mov    %ecx,%esi
jmp    2bd1 <dradbg+0x1ab1>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%ebp
add    0x30(%rsp),%esi
cmp    0x38(%rsp),%ebp
je     2c99 <dradbg+0x1b79>
cmpl   $0x0,0x28(%rsp)
jle    2bc0 <dradbg+0x1aa0>
mov    %esi,0x20(%rsp)
movslq %esi,%r9
cmpl   $0x3,0x8(%rsp)
jae    2c00 <dradbg+0x1ae0>
mov    %r9,%rbx
mov    0x80(%rsp),%r10
mov    0x1a8(%rsp),%r15
jmp    2c66 <dradbg+0x1b46>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%ecx
mov    0x80(%rsp),%r10
mov    0x1a8(%rsp),%r15
mov    0x40(%rsp),%rsi
nopl   0x0(%rax)
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    2c20 <dradbg+0x1b00>
cmpl   $0x0,0x10(%rsp)
mov    0x20(%rsp),%esi
je     2bc0 <dradbg+0x1aa0>
shl    $0x2,%rbx
mov    0x10(%rsp),%ecx
nopl   (%rax)
movss  (%r15,%rbx,1),%xmm0
movss  %xmm0,(%r10,%rbx,1)
add    %r12,%rbx
add    $0xffffffff,%ecx
jne    2c80 <dradbg+0x1b60>
jmp    2bc0 <dradbg+0x1aa0>
mov    0xa0(%rsp),%rcx
cmp    0x28(%rsp),%ecx
jle    3026 <dradbg+0x1f06>
cmpl   $0x2,0x38(%rsp)
mov    0x80(%rsp),%rcx
mov    0x18(%rsp),%rsi
mov    0x1a8(%rsp),%rdi
jl     310b <dradbg+0x1feb>
add    $0xfffffffd,%esi
mov    %esi,%ebp
and    $0xfffffffe,%ebp
lea    0x4(%rax),%rbx
mov    %rbx,0xf0(%rsp)
lea    (%rax,%rbp,4),%rbx
add    $0xc,%rbx
mov    %rbx,0xb0(%rsp)
add    $0x3,%rbp
mov    %rbp,0xc0(%rsp)
mov    %esi,0x8(%rsp)
shr    %esi
add    $0x1,%esi
mov    %rsi,0xd8(%rsp)
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,1),%rbp
mov    %rbp,0x88(%rsp)
mov    %rsi,0xd0(%rsp)
add    %esi,%esi
add    $0x2,%esi
mov    %esi,0xc8(%rsp)
lea    0x4(%rcx),%rsi
mov    %rsi,0xe8(%rsp)
lea    0x4(%rdi),%rsi
mov    %rsi,0xa0(%rsp)
lea    0x8(%rdi),%rsi
mov    %rsi,0x58(%rsp)
add    $0x8,%rcx
mov    %rcx,0x40(%rsp)
add    $0x8,%rax
mov    $0x1,%esi
movl   $0xffffffff,0xa8(%rsp)
ff ff ff ff
mov    0x30(%rsp),%rcx
mov    %ecx,0xb8(%rsp)
jmp    2db5 <dradbg+0x1c95>
nopl   0x0(%rax,%rax,1)
mov    0x4c(%rsp),%esi
add    $0x1,%esi
mov    0xa8(%rsp),%ecx
add    0x18(%rsp),%ecx
mov    %ecx,0xa8(%rsp)
mov    0xb8(%rsp),%ecx
add    0x30(%rsp),%ecx
mov    %ecx,0xb8(%rsp)
cmp    0x38(%rsp),%esi
je     310b <dradbg+0x1feb>
mov    %esi,0x4c(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    2d80 <dradbg+0x1c60>
movslq 0xb8(%rsp),%r11
lea    0x1(%r11),%rcx
mov    %rcx,0x50(%rsp)
mov    0xc0(%rsp),%rcx
add    %r11,%rcx
mov    %rcx,0x60(%rsp)
movslq 0xa8(%rsp),%rsi
mov    0xf0(%rsp),%rcx
lea    (%rcx,%rsi,4),%r10
mov    0xe8(%rsp),%rcx
lea    (%rcx,%r11,4),%r14
mov    0xa0(%rsp),%rcx
lea    (%rcx,%r11,4),%r8
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,0x78(%rsp)
mov    0x88(%rsp),%rcx
mov    %rsi,0x10(%rsp)
add    %rsi,%rcx
mov    %rcx,0x70(%rsp)
xor    %r9d,%r9d
jmp    2e58 <dradbg+0x1d38>
nopl   0x0(%rax,%rax,1)
add    %rdx,%r11
add    $0x1,%r9
add    %r12,%r14
add    %r12,%r8
cmp    0x28(%rsp),%r9d
je     2d80 <dradbg+0x1c60>
cmpl   $0x3,0x18(%rsp)
jl     2e40 <dradbg+0x1d20>
movl   $0x2,0x20(%rsp)
cmpl   $0x6,0x8(%rsp)
jae    2f00 <dradbg+0x1de0>
mov    %r11,%r15
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%rbp
mov    0x58(%rsp),%rsi
lea    (%rsi,%r15,4),%rdi
mov    0x40(%rsp),%rsi
lea    (%rsi,%r15,4),%rbx
lea    (%rax,%rcx,4),%r13
mov    0x20(%rsp),%esi
xor    %r15d,%r15d
nopl   0x0(%rax)
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     2ea0 <dradbg+0x1d80>
jmp    2e40 <dradbg+0x1d20>
nopl   0x0(%rax)
mov    %r9,%rcx
imul   %rdx,%rcx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rcx,1),%rdi
add    0x60(%rsp),%rcx
mov    0x80(%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    0x78(%rsp),%rbx
setb   %r15b
cmp    %rsi,%r10
setb   %r13b
cmp    %rcx,%rbx
setb   %bl
cmp    %rsi,%rdi
setb   %dil
test   %r13b,%r15b
jne    2e72 <dradbg+0x1d52>
mov    %r11,%r15
mov    0x10(%rsp),%rcx
and    %dil,%bl
mov    0x18(%rsp),%rbp
jne    2e7f <dradbg+0x1d5f>
mov    0x88(%rsp),%rcx
lea    (%r11,%rcx,1),%r15
xor    %esi,%esi
mov    0xd0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
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    2fa0 <dradbg+0x1e80>
mov    0x70(%rsp),%rcx
mov    0xc8(%rsp),%esi
mov    %esi,0x20(%rsp)
cmp    0xd8(%rsp),%rdi
mov    0x18(%rsp),%rbp
je     2e40 <dradbg+0x1d20>
jmp    2e7f <dradbg+0x1d5f>
cmpl   $0x2,0x38(%rsp)
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x1a8(%rsp),%rbp
jl     310b <dradbg+0x1feb>
mov    0x30(%rsp),%rsi
lea    0x2(%rsi),%r8d
mov    $0x1,%r10d
mov    $0xffffffff,%r9d
jmp    307c <dradbg+0x1f5c>
nopl   (%rax)
add    $0x1,%r10d
add    0x30(%rsp),%r8d
mov    0x18(%rsp),%rcx
add    %ecx,%r9d
cmp    0x38(%rsp),%r10d
je     310b <dradbg+0x1feb>
cmp    $0x3,%ecx
jl     3060 <dradbg+0x1f40>
movslq %r9d,%rdi
mov    $0x2,%r14d
mov    %r8d,%r11d
jmp    30a2 <dradbg+0x1f82>
nop
add    $0x2,%r14d
add    $0x2,%r11d
mov    %rbx,%rdi
cmp    0x18(%rsp),%r14d
jge    3060 <dradbg+0x1f40>
lea    0x2(%rdi),%rbx
cmpl   $0x0,0x28(%rsp)
jle    3090 <dradbg+0x1f70>
movslq %r11d,%rsi
shl    $0x2,%rsi
mov    0x28(%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    30c0 <dradbg+0x1fa0>
jmp    3090 <dradbg+0x1f70>
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 = fpext float %65 to double
%67 = call double @cos(double %66)
%68 = fptrunc double %67 to float
store float %68, float* %49
%69 = load float, float* %50
%70 = fpext float %69 to double
%71 = call double @sin(double %70)
%72 = fptrunc double %71 to float
store float %72, float* %51
%73 = load i32, i32* %11
%74 = sub nsw i32 %73, 1
%75 = ashr i32 %74, 1
store i32 %75, i32* %48
%76 = load i32, i32* %12
store i32 %76, i32* %54
%77 = load i32, i32* %12
%78 = add nsw i32 %77, 1
%79 = ashr i32 %78, 1
store i32 %79, i32* %22
%80 = load i32, i32* %11
%81 = load i32, i32* %13
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %84
83: ; preds = %10
br label %124
84: ; preds = %10
store i32 0, i32* %30
store i32 0, i32* %31
store i32 0, i32* %25
br label %85
85: ; preds = %120, %84
%86 = load i32, i32* %25
%87 = load i32, i32* %13
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %123
89: ; preds = %85
%90 = load i32, i32* %30
store i32 %90, i32* %32
%91 = load i32, i32* %31
store i32 %91, i32* %33
store i32 0, i32* %23
br label %92
92: ; preds = %110, %89
%93 = load i32, i32* %23
%94 = load i32, i32* %11
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %113
96: ; preds = %92
%97 = load float*, float** %15
%98 = load i32, i32* %33
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %97, i64 %99
%101 = load float, float* %100
%102 = load float*, float** %18
%103 = load i32, i32* %32
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
store float %101, float* %105
%106 = load i32, i32* %32
%107 = add nsw i32 %106, 1
store i32 %107, i32* %32
%108 = load i32, i32* %33
%109 = add nsw i32 %108, 1
store i32 %109, i32* %33
br label %110
110: ; preds = %96
%111 = load i32, i32* %23
%112 = add nsw i32 %111, 1
store i32 %112, i32* %23
br label %92
113: ; preds = %92
%114 = load i32, i32* %11
%115 = load i32, i32* %30
%116 = add nsw i32 %115, %114
store i32 %116, i32* %30
%117 = load i32, i32* %39
%118 = load i32, i32* %31
%119 = add nsw i32 %118, %117
store i32 %119, i32* %31
br label %120
120: ; preds = %113
%121 = load i32, i32* %25
%122 = add nsw i32 %121, 1
store i32 %122, i32* %25
br label %85
123: ; preds = %85
br label %162
124: ; preds = %83
store i32 0, i32* %30
store i32 0, i32* %23
br label %125
125: ; preds = %158, %124
%126 = load i32, i32* %23
%127 = load i32, i32* %11
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %161
129: ; preds = %125
%130 = load i32, i32* %30
store i32 %130, i32* %31
%131 = load i32, i32* %30
store i32 %131, i32* %32
store i32 0, i32* %25
br label %132
132: ; preds = %152, %129
%133 = load i32, i32* %25
%134 = load i32, i32* %13
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %155
136: ; preds = %132
%137 = load float*, float** %15
%138 = load i32, i32* %32
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float, float* %137, i64 %139
%141 = load float, float* %140
%142 = load float*, float** %18
%143 = load i32, i32* %31
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %142, i64 %144
store float %141, float* %145
%146 = load i32, i32* %11
%147 = load i32, i32* %31
%148 = add nsw i32 %147, %146
store i32 %148, i32* %31
%149 = load i32, i32* %39
%150 = load i32, i32* %32
%151 = add nsw i32 %150, %149
store i32 %151, i32* %32
br label %152
152: ; preds = %136
%153 = load i32, i32* %25
%154 = add nsw i32 %153, 1
store i32 %154, i32* %25
br label %132
155: ; preds = %132
%156 = load i32, i32* %30
%157 = add nsw i32 %156, 1
store i32 %157, i32* %30
br label %158
158: ; preds = %155
%159 = load i32, i32* %23
%160 = add nsw i32 %159, 1
store i32 %160, i32* %23
br label %125
161: ; preds = %125
br label %162
162: ; preds = %161, %123
store i32 0, i32* %30
%163 = load i32, i32* %54
%164 = load i32, i32* %29
%165 = mul nsw i32 %163, %164
store i32 %165, i32* %31
%166 = load i32, i32* %11
%167 = shl i32 %166, 1
store i32 %167, i32* %34
store i32 %167, i32* %36
store i32 1, i32* %24
br label %168
168: ; preds = %235, %162
%169 = load i32, i32* %24
%170 = load i32, i32* %22
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %238
172: ; preds = %168
%173 = load i32, i32* %29
%174 = load i32, i32* %30
%175 = add nsw i32 %174, %173
store i32 %175, i32* %30
%176 = load i32, i32* %29
%177 = load i32, i32* %31
%178 = sub nsw i32 %177, %176
store i32 %178, i32* %31
%179 = load i32, i32* %30
store i32 %179, i32* %32
%180 = load i32, i32* %31
store i32 %180, i32* %33
%181 = load i32, i32* %34
store i32 %181, i32* %35
store i32 0, i32* %25
br label %182
182: ; preds = %228, %172
%183 = load i32, i32* %25
%184 = load i32, i32* %13
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %231
186: ; preds = %182
%187 = load float*, float** %15
%188 = load i32, i32* %35
%189 = sub nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %187, i64 %190
%192 = load float, float* %191
%193 = load float*, float** %15
%194 = load i32, i32* %35
%195 = sub nsw i32 %194, 1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %193, i64 %196
%198 = load float, float* %197
%199 = fadd float %192, %198
%200 = load float*, float** %18
%201 = load i32, i32* %32
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %200, i64 %202
store float %199, float* %203
%204 = load float*, float** %15
%205 = load i32, i32* %35
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = load float*, float** %15
%210 = load i32, i32* %35
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
%214 = fadd float %208, %213
%215 = load float*, float** %18
%216 = load i32, i32* %33
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %215, i64 %217
store float %214, float* %218
%219 = load i32, i32* %11
%220 = load i32, i32* %32
%221 = add nsw i32 %220, %219
store i32 %221, i32* %32
%222 = load i32, i32* %11
%223 = load i32, i32* %33
%224 = add nsw i32 %223, %222
store i32 %224, i32* %33
%225 = load i32, i32* %39
%226 = load i32, i32* %35
%227 = add nsw i32 %226, %225
store i32 %227, i32* %35
br label %228
228: ; preds = %186
%229 = load i32, i32* %25
%230 = add nsw i32 %229, 1
store i32 %230, i32* %25
br label %182
231: ; preds = %182
%232 = load i32, i32* %36
%233 = load i32, i32* %34
%234 = add nsw i32 %233, %232
store i32 %234, i32* %34
br label %235
235: ; preds = %231
%236 = load i32, i32* %24
%237 = add nsw i32 %236, 1
store i32 %237, i32* %24
br label %168
238: ; preds = %168
%239 = load i32, i32* %11
%240 = icmp eq i32 %239, 1
br i1 %240, label %241, label %242
241: ; preds = %238
br label %513
242: ; preds = %238
%243 = load i32, i32* %48
%244 = load i32, i32* %13
%245 = icmp slt i32 %243, %244
br i1 %245, label %246, label %247
246: ; preds = %242
br label %378
247: ; preds = %242
store i32 0, i32* %30
%248 = load i32, i32* %54
%249 = load i32, i32* %29
%250 = mul nsw i32 %248, %249
store i32 %250, i32* %31
store i32 0, i32* %36
store i32 1, i32* %24
br label %251
251: ; preds = %374, %247
%252 = load i32, i32* %24
%253 = load i32, i32* %22
%254 = icmp slt i32 %252, %253
br i1 %254, label %255, label %377
255: ; preds = %251
%256 = load i32, i32* %29
%257 = load i32, i32* %30
%258 = add nsw i32 %257, %256
store i32 %258, i32* %30
%259 = load i32, i32* %29
%260 = load i32, i32* %31
%261 = sub nsw i32 %260, %259
store i32 %261, i32* %31
%262 = load i32, i32* %30
store i32 %262, i32* %32
%263 = load i32, i32* %31
store i32 %263, i32* %33
%264 = load i32, i32* %11
%265 = shl i32 %264, 1
%266 = load i32, i32* %36
%267 = add nsw i32 %266, %265
store i32 %267, i32* %36
%268 = load i32, i32* %36
store i32 %268, i32* %37
store i32 0, i32* %25
br label %269
269: ; preds = %370, %255
%270 = load i32, i32* %25
%271 = load i32, i32* %13
%272 = icmp slt i32 %270, %271
br i1 %272, label %273, label %373
273: ; preds = %269
%274 = load i32, i32* %32
store i32 %274, i32* %34
%275 = load i32, i32* %33
store i32 %275, i32* %35
%276 = load i32, i32* %37
store i32 %276, i32* %38
%277 = load i32, i32* %37
store i32 %277, i32* %40
store i32 2, i32* %23
br label %278
278: ; preds = %357, %273
%279 = load i32, i32* %23
%280 = load i32, i32* %11
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %360
282: ; preds = %278
%283 = load i32, i32* %34
%284 = add nsw i32 %283, 2
store i32 %284, i32* %34
%285 = load i32, i32* %35
%286 = add nsw i32 %285, 2
store i32 %286, i32* %35
%287 = load i32, i32* %38
%288 = add nsw i32 %287, 2
store i32 %288, i32* %38
%289 = load i32, i32* %40
%290 = sub nsw i32 %289, 2
store i32 %290, i32* %40
%291 = load float*, float** %15
%292 = load i32, i32* %38
%293 = sub nsw i32 %292, 1
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %291, i64 %294
%296 = load float, float* %295
%297 = load float*, float** %15
%298 = load i32, i32* %40
%299 = sub nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float, float* %297, i64 %300
%302 = load float, float* %301
%303 = fadd float %296, %302
%304 = load float*, float** %18
%305 = load i32, i32* %34
%306 = sub nsw i32 %305, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %304, i64 %307
store float %303, float* %308
%309 = load float*, float** %15
%310 = load i32, i32* %38
%311 = sub nsw i32 %310, 1
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float, float* %309, i64 %312
%314 = load float, float* %313
%315 = load float*, float** %15
%316 = load i32, i32* %40
%317 = sub nsw i32 %316, 1
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %315, i64 %318
%320 = load float, float* %319
%321 = fsub float %314, %320
%322 = load float*, float** %18
%323 = load i32, i32* %35
%324 = sub nsw i32 %323, 1
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds float, float* %322, i64 %325
store float %321, float* %326
%327 = load float*, float** %15
%328 = load i32, i32* %38
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float, float* %327, i64 %329
%331 = load float, float* %330
%332 = load float*, float** %15
%333 = load i32, i32* %40
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %332, i64 %334
%336 = load float, float* %335
%337 = fsub float %331, %336
%338 = load float*, float** %18
%339 = load i32, i32* %34
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float, float* %338, i64 %340
store float %337, float* %341
%342 = load float*, float** %15
%343 = load i32, i32* %38
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float, float* %342, i64 %344
%346 = load float, float* %345
%347 = load float*, float** %15
%348 = load i32, i32* %40
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %347, i64 %349
%351 = load float, float* %350
%352 = fadd float %346, %351
%353 = load float*, float** %18
%354 = load i32, i32* %35
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds float, float* %353, i64 %355
store float %352, float* %356
br label %357
357: ; preds = %282
%358 = load i32, i32* %23
%359 = add nsw i32 %358, 2
store i32 %359, i32* %23
br label %278
360: ; preds = %278
%361 = load i32, i32* %11
%362 = load i32, i32* %32
%363 = add nsw i32 %362, %361
store i32 %363, i32* %32
%364 = load i32, i32* %11
%365 = load i32, i32* %33
%366 = add nsw i32 %365, %364
store i32 %366, i32* %33
%367 = load i32, i32* %39
%368 = load i32, i32* %37
%369 = add nsw i32 %368, %367
store i32 %369, i32* %37
br label %370
370: ; preds = %360
%371 = load i32, i32* %25
%372 = add nsw i32 %371, 1
store i32 %372, i32* %25
br label %269
373: ; preds = %269
br label %374
374: ; preds = %373
%375 = load i32, i32* %24
%376 = add nsw i32 %375, 1
store i32 %376, i32* %24
br label %251
377: ; preds = %251
br label %513
378: ; preds = %246
store i32 0, i32* %30
%379 = load i32, i32* %54
%380 = load i32, i32* %29
%381 = mul nsw i32 %379, %380
store i32 %381, i32* %31
store i32 0, i32* %36
store i32 1, i32* %24
br label %382
382: ; preds = %509, %378
%383 = load i32, i32* %24
%384 = load i32, i32* %22
%385 = icmp slt i32 %383, %384
br i1 %385, label %386, label %512
386: ; preds = %382
%387 = load i32, i32* %29
%388 = load i32, i32* %30
%389 = add nsw i32 %388, %387
store i32 %389, i32* %30
%390 = load i32, i32* %29
%391 = load i32, i32* %31
%392 = sub nsw i32 %391, %390
store i32 %392, i32* %31
%393 = load i32, i32* %30
store i32 %393, i32* %32
%394 = load i32, i32* %31
store i32 %394, i32* %33
%395 = load i32, i32* %11
%396 = shl i32 %395, 1
%397 = load i32, i32* %36
%398 = add nsw i32 %397, %396
store i32 %398, i32* %36
%399 = load i32, i32* %36
store i32 %399, i32* %37
%400 = load i32, i32* %36
store i32 %400, i32* %38
store i32 2, i32* %23
br label %401
401: ; preds = %505, %386
%402 = load i32, i32* %23
%403 = load i32, i32* %11
%404 = icmp slt i32 %402, %403
br i1 %404, label %405, label %508
405: ; preds = %401
%406 = load i32, i32* %32
%407 = add nsw i32 %406, 2
store i32 %407, i32* %32
%408 = load i32, i32* %33
%409 = add nsw i32 %408, 2
store i32 %409, i32* %33
%410 = load i32, i32* %37
%411 = add nsw i32 %410, 2
store i32 %411, i32* %37
%412 = load i32, i32* %38
%413 = sub nsw i32 %412, 2
store i32 %413, i32* %38
%414 = load i32, i32* %32
store i32 %414, i32* %34
%415 = load i32, i32* %33
store i32 %415, i32* %35
%416 = load i32, i32* %37
store i32 %416, i32* %40
%417 = load i32, i32* %38
store i32 %417, i32* %41
store i32 0, i32* %25
br label %418
418: ; preds = %501, %405
%419 = load i32, i32* %25
%420 = load i32, i32* %13
%421 = icmp slt i32 %419, %420
br i1 %421, label %422, label %504
422: ; preds = %418
%423 = load float*, float** %15
%424 = load i32, i32* %40
%425 = sub nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %423, i64 %426
%428 = load float, float* %427
%429 = load float*, float** %15
%430 = load i32, i32* %41
%431 = sub nsw i32 %430, 1
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float, float* %429, i64 %432
%434 = load float, float* %433
%435 = fadd float %428, %434
%436 = load float*, float** %18
%437 = load i32, i32* %34
%438 = sub nsw i32 %437, 1
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds float, float* %436, i64 %439
store float %435, float* %440
%441 = load float*, float** %15
%442 = load i32, i32* %40
%443 = sub nsw i32 %442, 1
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float, float* %441, i64 %444
%446 = load float, float* %445
%447 = load float*, float** %15
%448 = load i32, i32* %41
%449 = sub nsw i32 %448, 1
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %447, i64 %450
%452 = load float, float* %451
%453 = fsub float %446, %452
%454 = load float*, float** %18
%455 = load i32, i32* %35
%456 = sub nsw i32 %455, 1
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds float, float* %454, i64 %457
store float %453, float* %458
%459 = load float*, float** %15
%460 = load i32, i32* %40
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float, float* %459, i64 %461
%463 = load float, float* %462
%464 = load float*, float** %15
%465 = load i32, i32* %41
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds float, float* %464, i64 %466
%468 = load float, float* %467
%469 = fsub float %463, %468
%470 = load float*, float** %18
%471 = load i32, i32* %34
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %470, i64 %472
store float %469, float* %473
%474 = load float*, float** %15
%475 = load i32, i32* %40
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds float, float* %474, i64 %476
%478 = load float, float* %477
%479 = load float*, float** %15
%480 = load i32, i32* %41
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds float, float* %479, i64 %481
%483 = load float, float* %482
%484 = fadd float %478, %483
%485 = load float*, float** %18
%486 = load i32, i32* %35
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %485, i64 %487
store float %484, float* %488
%489 = load i32, i32* %11
%490 = load i32, i32* %34
%491 = add nsw i32 %490, %489
store i32 %491, i32* %34
%492 = load i32, i32* %11
%493 = load i32, i32* %35
%494 = add nsw i32 %493, %492
store i32 %494, i32* %35
%495 = load i32, i32* %39
%496 = load i32, i32* %40
%497 = add nsw i32 %496, %495
store i32 %497, i32* %40
%498 = load i32, i32* %39
%499 = load i32, i32* %41
%500 = add nsw i32 %499, %498
store i32 %500, i32* %41
br label %501
501: ; preds = %422
%502 = load i32, i32* %25
%503 = add nsw i32 %502, 1
store i32 %503, i32* %25
br label %418
504: ; preds = %418
br label %505
505: ; preds = %504
%506 = load i32, i32* %23
%507 = add nsw i32 %506, 2
store i32 %507, i32* %23
br label %401
508: ; preds = %401
br label %509
509: ; preds = %508
%510 = load i32, i32* %24
%511 = add nsw i32 %510, 1
store i32 %511, i32* %24
br label %382
512: ; preds = %382
br label %513
513: ; preds = %512, %377, %241
store float 1.000000e+00, float* %45
store float 0.000000e+00, float* %43
store i32 0, i32* %30
%514 = load i32, i32* %54
%515 = load i32, i32* %14
%516 = mul nsw i32 %514, %515
store i32 %516, i32* %31
store i32 %516, i32* %38
%517 = load i32, i32* %12
%518 = sub nsw i32 %517, 1
%519 = load i32, i32* %14
%520 = mul nsw i32 %518, %519
store i32 %520, i32* %32
store i32 1, i32* %26
br label %521
521: ; preds = %669, %513
%522 = load i32, i32* %26
%523 = load i32, i32* %22
%524 = icmp slt i32 %522, %523
br i1 %524, label %525, label %672
525: ; preds = %521
%526 = load i32, i32* %14
%527 = load i32, i32* %30
%528 = add nsw i32 %527, %526
store i32 %528, i32* %30
%529 = load i32, i32* %14
%530 = load i32, i32* %31
%531 = sub nsw i32 %530, %529
store i32 %531, i32* %31
%532 = load float, float* %49
%533 = load float, float* %45
%534 = load float, float* %51
%535 = load float, float* %43
%536 = fmul float %534, %535
%537 = fneg float %536
%538 = call float @llvm.fmuladd.f32(float %532, float %533, float %537)
store float %538, float* %52
%539 = load float, float* %49
%540 = load float, float* %43
%541 = load float, float* %51
%542 = load float, float* %45
%543 = fmul float %541, %542
%544 = call float @llvm.fmuladd.f32(float %539, float %540, float %543)
store float %544, float* %43
%545 = load float, float* %52
store float %545, float* %45
%546 = load i32, i32* %30
store i32 %546, i32* %33
%547 = load i32, i32* %31
store i32 %547, i32* %34
store i32 0, i32* %35
%548 = load i32, i32* %14
store i32 %548, i32* %36
%549 = load i32, i32* %32
store i32 %549, i32* %37
store i32 0, i32* %27
br label %550
550: ; preds = %587, %525
%551 = load i32, i32* %27
%552 = load i32, i32* %14
%553 = icmp slt i32 %551, %552
br i1 %553, label %554, label %590
554: ; preds = %550
%555 = load float*, float** %19
%556 = load i32, i32* %35
%557 = add nsw i32 %556, 1
store i32 %557, i32* %35
%558 = sext i32 %556 to i64
%559 = getelementptr inbounds float, float* %555, i64 %558
%560 = load float, float* %559
%561 = load float, float* %45
%562 = load float*, float** %19
%563 = load i32, i32* %36
%564 = add nsw i32 %563, 1
store i32 %564, i32* %36
%565 = sext i32 %563 to i64
%566 = getelementptr inbounds float, float* %562, i64 %565
%567 = load float, float* %566
%568 = call float @llvm.fmuladd.f32(float %561, float %567, float %560)
%569 = load float*, float** %17
%570 = load i32, i32* %33
%571 = add nsw i32 %570, 1
store i32 %571, i32* %33
%572 = sext i32 %570 to i64
%573 = getelementptr inbounds float, float* %569, i64 %572
store float %568, float* %573
%574 = load float, float* %43
%575 = load float*, float** %19
%576 = load i32, i32* %37
%577 = add nsw i32 %576, 1
store i32 %577, i32* %37
%578 = sext i32 %576 to i64
%579 = getelementptr inbounds float, float* %575, i64 %578
%580 = load float, float* %579
%581 = fmul float %574, %580
%582 = load float*, float** %17
%583 = load i32, i32* %34
%584 = add nsw i32 %583, 1
store i32 %584, i32* %34
%585 = sext i32 %583 to i64
%586 = getelementptr inbounds float, float* %582, i64 %585
store float %581, float* %586
br label %587
587: ; preds = %554
%588 = load i32, i32* %27
%589 = add nsw i32 %588, 1
store i32 %589, i32* %27
br label %550
590: ; preds = %550
%591 = load float, float* %45
store float %591, float* %42
%592 = load float, float* %43
store float %592, float* %47
%593 = load float, float* %45
store float %593, float* %46
%594 = load float, float* %43
store float %594, float* %44
%595 = load i32, i32* %14
store i32 %595, i32* %35
%596 = load i32, i32* %38
%597 = load i32, i32* %14
%598 = sub nsw i32 %596, %597
store i32 %598, i32* %36
store i32 2, i32* %24
br label %599
599: ; preds = %665, %590
%600 = load i32, i32* %24
%601 = load i32, i32* %22
%602 = icmp slt i32 %600, %601
br i1 %602, label %603, label %668
603: ; preds = %599
%604 = load i32, i32* %14
%605 = load i32, i32* %35
%606 = add nsw i32 %605, %604
store i32 %606, i32* %35
%607 = load i32, i32* %14
%608 = load i32, i32* %36
%609 = sub nsw i32 %608, %607
store i32 %609, i32* %36
%610 = load float, float* %42
%611 = load float, float* %46
%612 = load float, float* %47
%613 = load float, float* %44
%614 = fmul float %612, %613
%615 = fneg float %614
%616 = call float @llvm.fmuladd.f32(float %610, float %611, float %615)
store float %616, float* %53
%617 = load float, float* %42
%618 = load float, float* %44
%619 = load float, float* %47
%620 = load float, float* %46
%621 = fmul float %619, %620
%622 = call float @llvm.fmuladd.f32(float %617, float %618, float %621)
store float %622, float* %44
%623 = load float, float* %53
store float %623, float* %46
%624 = load i32, i32* %30
store i32 %624, i32* %33
%625 = load i32, i32* %31
store i32 %625, i32* %34
%626 = load i32, i32* %35
store i32 %626, i32* %40
%627 = load i32, i32* %36
store i32 %627, i32* %41
store i32 0, i32* %27
br label %628
628: ; preds = %661, %603
%629 = load i32, i32* %27
%630 = load i32, i32* %14
%631 = icmp slt i32 %629, %630
br i1 %631, label %632, label %664
632: ; preds = %628
%633 = load float, float* %46
%634 = load float*, float** %19
%635 = load i32, i32* %40
%636 = add nsw i32 %635, 1
store i32 %636, i32* %40
%637 = sext i32 %635 to i64
%638 = getelementptr inbounds float, float* %634, i64 %637
%639 = load float, float* %638
%640 = load float*, float** %17
%641 = load i32, i32* %33
%642 = add nsw i32 %641, 1
store i32 %642, i32* %33
%643 = sext i32 %641 to i64
%644 = getelementptr inbounds float, float* %640, i64 %643
%645 = load float, float* %644
%646 = call float @llvm.fmuladd.f32(float %633, float %639, float %645)
store float %646, float* %644
%647 = load float, float* %44
%648 = load float*, float** %19
%649 = load i32, i32* %41
%650 = add nsw i32 %649, 1
store i32 %650, i32* %41
%651 = sext i32 %649 to i64
%652 = getelementptr inbounds float, float* %648, i64 %651
%653 = load float, float* %652
%654 = load float*, float** %17
%655 = load i32, i32* %34
%656 = add nsw i32 %655, 1
store i32 %656, i32* %34
%657 = sext i32 %655 to i64
%658 = getelementptr inbounds float, float* %654, i64 %657
%659 = load float, float* %658
%660 = call float @llvm.fmuladd.f32(float %647, float %653, float %659)
store float %660, float* %658
br label %661
661: ; preds = %632
%662 = load i32, i32* %27
%663 = add nsw i32 %662, 1
store i32 %663, i32* %27
br label %628
664: ; preds = %628
br label %665
665: ; preds = %664
%666 = load i32, i32* %24
%667 = add nsw i32 %666, 1
store i32 %667, i32* %24
br label %599
668: ; preds = %599
br label %669
669: ; preds = %668
%670 = load i32, i32* %26
%671 = add nsw i32 %670, 1
store i32 %671, i32* %26
br label %521
672: ; preds = %521
store i32 0, i32* %30
store i32 1, i32* %24
br label %673
673: ; preds = %703, %672
%674 = load i32, i32* %24
%675 = load i32, i32* %22
%676 = icmp slt i32 %674, %675
br i1 %676, label %677, label %706
677: ; preds = %673
%678 = load i32, i32* %14
%679 = load i32, i32* %30
%680 = add nsw i32 %679, %678
store i32 %680, i32* %30
%681 = load i32, i32* %30
store i32 %681, i32* %31
store i32 0, i32* %27
br label %682
682: ; preds = %699, %677
%683 = load i32, i32* %27
%684 = load i32, i32* %14
%685 = icmp slt i32 %683, %684
br i1 %685, label %686, label %702
686: ; preds = %682
%687 = load float*, float** %19
%688 = load i32, i32* %31
%689 = add nsw i32 %688, 1
store i32 %689, i32* %31
%690 = sext i32 %688 to i64
%691 = getelementptr inbounds float, float* %687, i64 %690
%692 = load float, float* %691
%693 = load float*, float** %19
%694 = load i32, i32* %27
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds float, float* %693, i64 %695
%697 = load float, float* %696
%698 = fadd float %697, %692
store float %698, float* %696
br label %699
699: ; preds = %686
%700 = load i32, i32* %27
%701 = add nsw i32 %700, 1
store i32 %701, i32* %27
br label %682
702: ; preds = %682
br label %703
703: ; preds = %702
%704 = load i32, i32* %24
%705 = add nsw i32 %704, 1
store i32 %705, i32* %24
br label %673
706: ; preds = %673
store i32 0, i32* %30
%707 = load i32, i32* %54
%708 = load i32, i32* %29
%709 = mul nsw i32 %707, %708
store i32 %709, i32* %31
store i32 1, i32* %24
br label %710
710: ; preds = %768, %706
%711 = load i32, i32* %24
%712 = load i32, i32* %22
%713 = icmp slt i32 %711, %712
br i1 %713, label %714, label %771
714: ; preds = %710
%715 = load i32, i32* %29
%716 = load i32, i32* %30
%717 = add nsw i32 %716, %715
store i32 %717, i32* %30
%718 = load i32, i32* %29
%719 = load i32, i32* %31
%720 = sub nsw i32 %719, %718
store i32 %720, i32* %31
%721 = load i32, i32* %30
store i32 %721, i32* %32
%722 = load i32, i32* %31
store i32 %722, i32* %33
store i32 0, i32* %25
br label %723
723: ; preds = %764, %714
%724 = load i32, i32* %25
%725 = load i32, i32* %13
%726 = icmp slt i32 %724, %725
br i1 %726, label %727, label %767
727: ; preds = %723
%728 = load float*, float** %16
%729 = load i32, i32* %32
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %728, i64 %730
%732 = load float, float* %731
%733 = load float*, float** %16
%734 = load i32, i32* %33
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds float, float* %733, i64 %735
%737 = load float, float* %736
%738 = fsub float %732, %737
%739 = load float*, float** %18
%740 = load i32, i32* %32
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds float, float* %739, i64 %741
store float %738, float* %742
%743 = load float*, float** %16
%744 = load i32, i32* %32
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds float, float* %743, i64 %745
%747 = load float, float* %746
%748 = load float*, float** %16
%749 = load i32, i32* %33
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float, float* %748, i64 %750
%752 = load float, float* %751
%753 = fadd float %747, %752
%754 = load float*, float** %18
%755 = load i32, i32* %33
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds float, float* %754, i64 %756
store float %753, float* %757
%758 = load i32, i32* %11
%759 = load i32, i32* %32
%760 = add nsw i32 %759, %758
store i32 %760, i32* %32
%761 = load i32, i32* %11
%762 = load i32, i32* %33
%763 = add nsw i32 %762, %761
store i32 %763, i32* %33
br label %764
764: ; preds = %727
%765 = load i32, i32* %25
%766 = add nsw i32 %765, 1
store i32 %766, i32* %25
br label %723
767: ; preds = %723
br label %768
768: ; preds = %767
%769 = load i32, i32* %24
%770 = add nsw i32 %769, 1
store i32 %770, i32* %24
br label %710
771: ; preds = %710
%772 = load i32, i32* %11
%773 = icmp eq i32 %772, 1
br i1 %773, label %774, label %775
774: ; preds = %771
br label %1014
775: ; preds = %771
%776 = load i32, i32* %48
%777 = load i32, i32* %13
%778 = icmp slt i32 %776, %777
br i1 %778, label %779, label %780
779: ; preds = %775
br label %897
780: ; preds = %775
store i32 0, i32* %30
%781 = load i32, i32* %54
%782 = load i32, i32* %29
%783 = mul nsw i32 %781, %782
store i32 %783, i32* %31
store i32 1, i32* %24
br label %784
784: ; preds = %893, %780
%785 = load i32, i32* %24
%786 = load i32, i32* %22
%787 = icmp slt i32 %785, %786
br i1 %787, label %788, label %896
788: ; preds = %784
%789 = load i32, i32* %29
%790 = load i32, i32* %30
%791 = add nsw i32 %790, %789
store i32 %791, i32* %30
%792 = load i32, i32* %29
%793 = load i32, i32* %31
%794 = sub nsw i32 %793, %792
store i32 %794, i32* %31
%795 = load i32, i32* %30
store i32 %795, i32* %32
%796 = load i32, i32* %31
store i32 %796, i32* %33
store i32 0, i32* %25
br label %797
797: ; preds = %889, %788
%798 = load i32, i32* %25
%799 = load i32, i32* %13
%800 = icmp slt i32 %798, %799
br i1 %800, label %801, label %892
801: ; preds = %797
%802 = load i32, i32* %32
store i32 %802, i32* %34
%803 = load i32, i32* %33
store i32 %803, i32* %35
store i32 2, i32* %23
br label %804
804: ; preds = %879, %801
%805 = load i32, i32* %23
%806 = load i32, i32* %11
%807 = icmp slt i32 %805, %806
br i1 %807, label %808, label %882
808: ; preds = %804
%809 = load i32, i32* %34
%810 = add nsw i32 %809, 2
store i32 %810, i32* %34
%811 = load i32, i32* %35
%812 = add nsw i32 %811, 2
store i32 %812, i32* %35
%813 = load float*, float** %16
%814 = load i32, i32* %34
%815 = sub nsw i32 %814, 1
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds float, float* %813, i64 %816
%818 = load float, float* %817
%819 = load float*, float** %16
%820 = load i32, i32* %35
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds float, float* %819, i64 %821
%823 = load float, float* %822
%824 = fsub float %818, %823
%825 = load float*, float** %18
%826 = load i32, i32* %34
%827 = sub nsw i32 %826, 1
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float, float* %825, i64 %828
store float %824, float* %829
%830 = load float*, float** %16
%831 = load i32, i32* %34
%832 = sub nsw i32 %831, 1
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %830, i64 %833
%835 = load float, float* %834
%836 = load float*, float** %16
%837 = load i32, i32* %35
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float, float* %836, i64 %838
%840 = load float, float* %839
%841 = fadd float %835, %840
%842 = load float*, float** %18
%843 = load i32, i32* %35
%844 = sub nsw i32 %843, 1
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds float, float* %842, i64 %845
store float %841, float* %846
%847 = load float*, float** %16
%848 = load i32, i32* %34
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds float, float* %847, i64 %849
%851 = load float, float* %850
%852 = load float*, float** %16
%853 = load i32, i32* %35
%854 = sub nsw i32 %853, 1
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds float, float* %852, i64 %855
%857 = load float, float* %856
%858 = fadd float %851, %857
%859 = load float*, float** %18
%860 = load i32, i32* %34
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds float, float* %859, i64 %861
store float %858, float* %862
%863 = load float*, float** %16
%864 = load i32, i32* %34
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds float, float* %863, i64 %865
%867 = load float, float* %866
%868 = load float*, float** %16
%869 = load i32, i32* %35
%870 = sub nsw i32 %869, 1
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds float, float* %868, i64 %871
%873 = load float, float* %872
%874 = fsub float %867, %873
%875 = load float*, float** %18
%876 = load i32, i32* %35
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds float, float* %875, i64 %877
store float %874, float* %878
br label %879
879: ; preds = %808
%880 = load i32, i32* %23
%881 = add nsw i32 %880, 2
store i32 %881, i32* %23
br label %804
882: ; preds = %804
%883 = load i32, i32* %11
%884 = load i32, i32* %32
%885 = add nsw i32 %884, %883
store i32 %885, i32* %32
%886 = load i32, i32* %11
%887 = load i32, i32* %33
%888 = add nsw i32 %887, %886
store i32 %888, i32* %33
br label %889
889: ; preds = %882
%890 = load i32, i32* %25
%891 = add nsw i32 %890, 1
store i32 %891, i32* %25
br label %797
892: ; preds = %797
br label %893
893: ; preds = %892
%894 = load i32, i32* %24
%895 = add nsw i32 %894, 1
store i32 %895, i32* %24
br label %784
896: ; preds = %784
br label %1014
897: ; preds = %779
store i32 0, i32* %30
%898 = load i32, i32* %54
%899 = load i32, i32* %29
%900 = mul nsw i32 %898, %899
store i32 %900, i32* %31
store i32 1, i32* %24
br label %901
901: ; preds = %1010, %897
%902 = load i32, i32* %24
%903 = load i32, i32* %22
%904 = icmp slt i32 %902, %903
br i1 %904, label %905, label %1013
905: ; preds = %901
%906 = load i32, i32* %29
%907 = load i32, i32* %30
%908 = add nsw i32 %907, %906
store i32 %908, i32* %30
%909 = load i32, i32* %29
%910 = load i32, i32* %31
%911 = sub nsw i32 %910, %909
store i32 %911, i32* %31
%912 = load i32, i32* %30
store i32 %912, i32* %32
%913 = load i32, i32* %31
store i32 %913, i32* %33
store i32 2, i32* %23
br label %914
914: ; preds = %1006, %905
%915 = load i32, i32* %23
%916 = load i32, i32* %11
%917 = icmp slt i32 %915, %916
br i1 %917, label %918, label %1009
918: ; preds = %914
%919 = load i32, i32* %32
%920 = add nsw i32 %919, 2
store i32 %920, i32* %32
%921 = load i32, i32* %33
%922 = add nsw i32 %921, 2
store i32 %922, i32* %33
%923 = load i32, i32* %32
store i32 %923, i32* %34
%924 = load i32, i32* %33
store i32 %924, i32* %35
store i32 0, i32* %25
br label %925
925: ; preds = %1002, %918
%926 = load i32, i32* %25
%927 = load i32, i32* %13
%928 = icmp slt i32 %926, %927
br i1 %928, label %929, label %1005
929: ; preds = %925
%930 = load float*, float** %16
%931 = load i32, i32* %34
%932 = sub nsw i32 %931, 1
%933 = sext i32 %932 to i64
%934 = getelementptr inbounds float, float* %930, i64 %933
%935 = load float, float* %934
%936 = load float*, float** %16
%937 = load i32, i32* %35
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds float, float* %936, i64 %938
%940 = load float, float* %939
%941 = fsub float %935, %940
%942 = load float*, float** %18
%943 = load i32, i32* %34
%944 = sub nsw i32 %943, 1
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds float, float* %942, i64 %945
store float %941, float* %946
%947 = load float*, float** %16
%948 = load i32, i32* %34
%949 = sub nsw i32 %948, 1
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds float, float* %947, i64 %950
%952 = load float, float* %951
%953 = load float*, float** %16
%954 = load i32, i32* %35
%955 = sext i32 %954 to i64
%956 = getelementptr inbounds float, float* %953, i64 %955
%957 = load float, float* %956
%958 = fadd float %952, %957
%959 = load float*, float** %18
%960 = load i32, i32* %35
%961 = sub nsw i32 %960, 1
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds float, float* %959, i64 %962
store float %958, float* %963
%964 = load float*, float** %16
%965 = load i32, i32* %34
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds float, float* %964, i64 %966
%968 = load float, float* %967
%969 = load float*, float** %16
%970 = load i32, i32* %35
%971 = sub nsw i32 %970, 1
%972 = sext i32 %971 to i64
%973 = getelementptr inbounds float, float* %969, i64 %972
%974 = load float, float* %973
%975 = fadd float %968, %974
%976 = load float*, float** %18
%977 = load i32, i32* %34
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds float, float* %976, i64 %978
store float %975, float* %979
%980 = load float*, float** %16
%981 = load i32, i32* %34
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds float, float* %980, i64 %982
%984 = load float, float* %983
%985 = load float*, float** %16
%986 = load i32, i32* %35
%987 = sub nsw i32 %986, 1
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds float, float* %985, i64 %988
%990 = load float, float* %989
%991 = fsub float %984, %990
%992 = load float*, float** %18
%993 = load i32, i32* %35
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds float, float* %992, i64 %994
store float %991, float* %995
%996 = load i32, i32* %11
%997 = load i32, i32* %34
%998 = add nsw i32 %997, %996
store i32 %998, i32* %34
%999 = load i32, i32* %11
%1000 = load i32, i32* %35
%1001 = add nsw i32 %1000, %999
store i32 %1001, i32* %35
br label %1002
1002: ; preds = %929
%1003 = load i32, i32* %25
%1004 = add nsw i32 %1003, 1
store i32 %1004, i32* %25
br label %925
1005: ; preds = %925
br label %1006
1006: ; preds = %1005
%1007 = load i32, i32* %23
%1008 = add nsw i32 %1007, 2
store i32 %1008, i32* %23
br label %914
1009: ; preds = %914
br label %1010
1010: ; preds = %1009
%1011 = load i32, i32* %24
%1012 = add nsw i32 %1011, 1
store i32 %1012, i32* %24
br label %901
1013: ; preds = %901
br label %1014
1014: ; preds = %1013, %896, %774
%1015 = load i32, i32* %11
%1016 = icmp eq i32 %1015, 1
br i1 %1016, label %1017, label %1018
1017: ; preds = %1014
br label %1283
1018: ; preds = %1014
store i32 0, i32* %27
br label %1019
1019: ; preds = %1033, %1018
%1020 = load i32, i32* %27
%1021 = load i32, i32* %14
%1022 = icmp slt i32 %1020, %1021
br i1 %1022, label %1023, label %1036
1023: ; preds = %1019
%1024 = load float*, float** %19
%1025 = load i32, i32* %27
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds float, float* %1024, i64 %1026
%1028 = load float, float* %1027
%1029 = load float*, float** %17
%1030 = load i32, i32* %27
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds float, float* %1029, i64 %1031
store float %1028, float* %1032
br label %1033
1033: ; preds = %1023
%1034 = load i32, i32* %27
%1035 = add nsw i32 %1034, 1
store i32 %1035, i32* %27
br label %1019
1036: ; preds = %1019
store i32 0, i32* %30
store i32 1, i32* %24
br label %1037
1037: ; preds = %1066, %1036
%1038 = load i32, i32* %24
%1039 = load i32, i32* %12
%1040 = icmp slt i32 %1038, %1039
br i1 %1040, label %1041, label %1069
1041: ; preds = %1037
%1042 = load i32, i32* %29
%1043 = load i32, i32* %30
%1044 = add nsw i32 %1043, %1042
store i32 %1044, i32* %30
store i32 %1044, i32* %31
store i32 0, i32* %25
br label %1045
1045: ; preds = %1062, %1041
%1046 = load i32, i32* %25
%1047 = load i32, i32* %13
%1048 = icmp slt i32 %1046, %1047
br i1 %1048, label %1049, label %1065
1049: ; preds = %1045
%1050 = load float*, float** %18
%1051 = load i32, i32* %31
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds float, float* %1050, i64 %1052
%1054 = load float, float* %1053
%1055 = load float*, float** %16
%1056 = load i32, i32* %31
%1057 = sext i32 %1056 to i64
%1058 = getelementptr inbounds float, float* %1055, i64 %1057
store float %1054, float* %1058
%1059 = load i32, i32* %11
%1060 = load i32, i32* %31
%1061 = add nsw i32 %1060, %1059
store i32 %1061, i32* %31
br label %1062
1062: ; preds = %1049
%1063 = load i32, i32* %25
%1064 = add nsw i32 %1063, 1
store i32 %1064, i32* %25
br label %1045
1065: ; preds = %1045
br label %1066
1066: ; preds = %1065
%1067 = load i32, i32* %24
%1068 = add nsw i32 %1067, 1
store i32 %1068, i32* %24
br label %1037
1069: ; preds = %1037
%1070 = load i32, i32* %48
%1071 = load i32, i32* %13
%1072 = icmp sgt i32 %1070, %1071
br i1 %1072, label %1073, label %1074
1073: ; preds = %1069
br label %1179
1074: ; preds = %1069
%1075 = load i32, i32* %11
%1076 = sub nsw i32 0, %1075
%1077 = sub nsw i32 %1076, 1
store i32 %1077, i32* %28
store i32 0, i32* %30
store i32 1, i32* %24
br label %1078
1078: ; preds = %1175, %1074
%1079 = load i32, i32* %24
%1080 = load i32, i32* %12
%1081 = icmp slt i32 %1079, %1080
br i1 %1081, label %1082, label %1178
1082: ; preds = %1078
%1083 = load i32, i32* %11
%1084 = load i32, i32* %28
%1085 = add nsw i32 %1084, %1083
store i32 %1085, i32* %28
%1086 = load i32, i32* %29
%1087 = load i32, i32* %30
%1088 = add nsw i32 %1087, %1086
store i32 %1088, i32* %30
%1089 = load i32, i32* %28
store i32 %1089, i32* %21
%1090 = load i32, i32* %30
store i32 %1090, i32* %31
store i32 2, i32* %23
br label %1091
1091: ; preds = %1171, %1082
%1092 = load i32, i32* %23
%1093 = load i32, i32* %11
%1094 = icmp slt i32 %1092, %1093
br i1 %1094, label %1095, label %1174
1095: ; preds = %1091
%1096 = load i32, i32* %31
%1097 = add nsw i32 %1096, 2
store i32 %1097, i32* %31
%1098 = load i32, i32* %21
%1099 = add nsw i32 %1098, 2
store i32 %1099, i32* %21
%1100 = load i32, i32* %31
store i32 %1100, i32* %32
store i32 0, i32* %25
br label %1101
1101: ; preds = %1167, %1095
%1102 = load i32, i32* %25
%1103 = load i32, i32* %13
%1104 = icmp slt i32 %1102, %1103
br i1 %1104, label %1105, label %1170
1105: ; preds = %1101
%1106 = load float*, float** %20
%1107 = load i32, i32* %21
%1108 = sub nsw i32 %1107, 1
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds float, float* %1106, i64 %1109
%1111 = load float, float* %1110
%1112 = load float*, float** %18
%1113 = load i32, i32* %32
%1114 = sub nsw i32 %1113, 1
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds float, float* %1112, i64 %1115
%1117 = load float, float* %1116
%1118 = load float*, float** %20
%1119 = load i32, i32* %21
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds float, float* %1118, i64 %1120
%1122 = load float, float* %1121
%1123 = load float*, float** %18
%1124 = load i32, i32* %32
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds float, float* %1123, i64 %1125
%1127 = load float, float* %1126
%1128 = fmul float %1122, %1127
%1129 = fneg float %1128
%1130 = call float @llvm.fmuladd.f32(float %1111, float %1117, float %1129)
%1131 = load float*, float** %16
%1132 = load i32, i32* %32
%1133 = sub nsw i32 %1132, 1
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds float, float* %1131, i64 %1134
store float %1130, float* %1135
%1136 = load float*, float** %20
%1137 = load i32, i32* %21
%1138 = sub nsw i32 %1137, 1
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds float, float* %1136, i64 %1139
%1141 = load float, float* %1140
%1142 = load float*, float** %18
%1143 = load i32, i32* %32
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds float, float* %1142, i64 %1144
%1146 = load float, float* %1145
%1147 = load float*, float** %20
%1148 = load i32, i32* %21
%1149 = sext i32 %1148 to i64
%1150 = getelementptr inbounds float, float* %1147, i64 %1149
%1151 = load float, float* %1150
%1152 = load float*, float** %18
%1153 = load i32, i32* %32
%1154 = sub nsw i32 %1153, 1
%1155 = sext i32 %1154 to i64
%1156 = getelementptr inbounds float, float* %1152, i64 %1155
%1157 = load float, float* %1156
%1158 = fmul float %1151, %1157
%1159 = call float @llvm.fmuladd.f32(float %1141, float %1146, float %1158)
%1160 = load float*, float** %16
%1161 = load i32, i32* %32
%1162 = sext i32 %1161 to i64
%1163 = getelementptr inbounds float, float* %1160, i64 %1162
store float %1159, float* %1163
%1164 = load i32, i32* %11
%1165 = load i32, i32* %32
%1166 = add nsw i32 %1165, %1164
store i32 %1166, i32* %32
br label %1167
1167: ; preds = %1105
%1168 = load i32, i32* %25
%1169 = add nsw i32 %1168, 1
store i32 %1169, i32* %25
br label %1101
1170: ; preds = %1101
br label %1171
1171: ; preds = %1170
%1172 = load i32, i32* %23
%1173 = add nsw i32 %1172, 2
store i32 %1173, i32* %23
br label %1091
1174: ; preds = %1091
br label %1175
1175: ; preds = %1174
%1176 = load i32, i32* %24
%1177 = add nsw i32 %1176, 1
store i32 %1177, i32* %24
br label %1078
1178: ; preds = %1078
br label %1283
1179: ; preds = %1073
%1180 = load i32, i32* %11
%1181 = sub nsw i32 0, %1180
%1182 = sub nsw i32 %1181, 1
store i32 %1182, i32* %28
store i32 0, i32* %30
store i32 1, i32* %24
br label %1183
1183: ; preds = %1280, %1179
%1184 = load i32, i32* %24
%1185 = load i32, i32* %12
%1186 = icmp slt i32 %1184, %1185
br i1 %1186, label %1187, label %1283
1187: ; preds = %1183
%1188 = load i32, i32* %11
%1189 = load i32, i32* %28
%1190 = add nsw i32 %1189, %1188
store i32 %1190, i32* %28
%1191 = load i32, i32* %29
%1192 = load i32, i32* %30
%1193 = add nsw i32 %1192, %1191
store i32 %1193, i32* %30
%1194 = load i32, i32* %30
store i32 %1194, i32* %31
store i32 0, i32* %25
br label %1195
1195: ; preds = %1276, %1187
%1196 = load i32, i32* %25
%1197 = load i32, i32* %13
%1198 = icmp slt i32 %1196, %1197
br i1 %1198, label %1199, label %1279
1199: ; preds = %1195
%1200 = load i32, i32* %28
store i32 %1200, i32* %21
%1201 = load i32, i32* %31
store i32 %1201, i32* %32
store i32 2, i32* %23
br label %1202
1202: ; preds = %1269, %1199
%1203 = load i32, i32* %23
%1204 = load i32, i32* %11
%1205 = icmp slt i32 %1203, %1204
br i1 %1205, label %1206, label %1272
1206: ; preds = %1202
%1207 = load i32, i32* %21
%1208 = add nsw i32 %1207, 2
store i32 %1208, i32* %21
%1209 = load i32, i32* %32
%1210 = add nsw i32 %1209, 2
store i32 %1210, i32* %32
%1211 = load float*, float** %20
%1212 = load i32, i32* %21
%1213 = sub nsw i32 %1212, 1
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds float, float* %1211, i64 %1214
%1216 = load float, float* %1215
%1217 = load float*, float** %18
%1218 = load i32, i32* %32
%1219 = sub nsw i32 %1218, 1
%1220 = sext i32 %1219 to i64
%1221 = getelementptr inbounds float, float* %1217, i64 %1220
%1222 = load float, float* %1221
%1223 = load float*, float** %20
%1224 = load i32, i32* %21
%1225 = sext i32 %1224 to i64
%1226 = getelementptr inbounds float, float* %1223, i64 %1225
%1227 = load float, float* %1226
%1228 = load float*, float** %18
%1229 = load i32, i32* %32
%1230 = sext i32 %1229 to i64
%1231 = getelementptr inbounds float, float* %1228, i64 %1230
%1232 = load float, float* %1231
%1233 = fmul float %1227, %1232
%1234 = fneg float %1233
%1235 = call float @llvm.fmuladd.f32(float %1216, float %1222, float %1234)
%1236 = load float*, float** %16
%1237 = load i32, i32* %32
%1238 = sub nsw i32 %1237, 1
%1239 = sext i32 %1238 to i64
%1240 = getelementptr inbounds float, float* %1236, i64 %1239
store float %1235, float* %1240
%1241 = load float*, float** %20
%1242 = load i32, i32* %21
%1243 = sub nsw i32 %1242, 1
%1244 = sext i32 %1243 to i64
%1245 = getelementptr inbounds float, float* %1241, i64 %1244
%1246 = load float, float* %1245
%1247 = load float*, float** %18
%1248 = load i32, i32* %32
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds float, float* %1247, i64 %1249
%1251 = load float, float* %1250
%1252 = load float*, float** %20
%1253 = load i32, i32* %21
%1254 = sext i32 %1253 to i64
%1255 = getelementptr inbounds float, float* %1252, i64 %1254
%1256 = load float, float* %1255
%1257 = load float*, float** %18
%1258 = load i32, i32* %32
%1259 = sub nsw i32 %1258, 1
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds float, float* %1257, i64 %1260
%1262 = load float, float* %1261
%1263 = fmul float %1256, %1262
%1264 = call float @llvm.fmuladd.f32(float %1246, float %1251, float %1263)
%1265 = load float*, float** %16
%1266 = load i32, i32* %32
%1267 = sext i32 %1266 to i64
%1268 = getelementptr inbounds float, float* %1265, i64 %1267
store float %1264, float* %1268
br label %1269
1269: ; preds = %1206
%1270 = load i32, i32* %23
%1271 = add nsw i32 %1270, 2
store i32 %1271, i32* %23
br label %1202
1272: ; preds = %1202
%1273 = load i32, i32* %11
%1274 = load i32, i32* %31
%1275 = add nsw i32 %1274, %1273
store i32 %1275, i32* %31
br label %1276
1276: ; preds = %1272
%1277 = load i32, i32* %25
%1278 = add nsw i32 %1277, 1
store i32 %1278, i32* %25
br label %1195
1279: ; preds = %1195
br label %1280
1280: ; preds = %1279
%1281 = load i32, i32* %24
%1282 = add nsw i32 %1281, 1
store i32 %1282, i32* %24
br label %1183
1283: ; preds = %1017, %1178, %1183
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 = fpext float %14 to double
%16 = tail call double @cos(double %15)
%17 = fptrunc double %16 to float
%18 = tail call double @sin(double %15)
%19 = fptrunc double %18 to float
%20 = add nsw i32 %0, -1
%21 = ashr i32 %20, 1
%22 = add nsw i32 %1, 1
%23 = ashr i32 %22, 1
%24 = icmp slt i32 %0, %2
br i1 %24, label %48, label %25
25: ; preds = %10
%26 = icmp sgt i32 %2, 0
br i1 %26, label %27, label %229
27: ; preds = %25
%28 = icmp sgt i32 %0, 0
%29 = sext i32 %0 to i64
%30 = sext i32 %11 to i64
%31 = add i32 %0, -1
%32 = zext i32 %31 to i64
%33 = add nuw nsw i64 %32, 1
%34 = zext i32 %31 to i64
%35 = add nuw nsw i64 %34, 1
%36 = and i64 %35, 8589934584
%37 = add nsw i64 %36, -8
%38 = lshr exact i64 %37, 3
%39 = add nuw nsw i64 %38, 1
%40 = icmp ult i32 %31, 7
%41 = and i64 %35, 8589934584
%42 = trunc i64 %41 to i32
%43 = and i64 %39, 1
%44 = icmp eq i64 %37, 0
%45 = and i64 %39, 4611686018427387902
%46 = icmp eq i64 %43, 0
%47 = icmp eq i64 %35, %41
br label %60
48: ; preds = %10
%49 = icmp sgt i32 %0, 0
br i1 %49, label %50, label %229
50: ; preds = %48
%51 = icmp sgt i32 %2, 0
%52 = zext i32 %0 to i64
%53 = sext i32 %11 to i64
%54 = zext i32 %0 to i64
%55 = add i32 %2, -1
%56 = and i32 %2, 3
%57 = icmp ult i32 %55, 3
%58 = and i32 %2, -4
%59 = icmp eq i32 %56, 0
br label %183
60: ; preds = %27, %178
%61 = phi i64 [ 0, %27 ], [ %180, %178 ]
%62 = phi i64 [ 0, %27 ], [ %179, %178 ]
%63 = phi i32 [ 0, %27 ], [ %181, %178 ]
%64 = getelementptr float, float* %7, i64 %62
%65 = add i64 %33, %62
%66 = getelementptr float, float* %7, i64 %65
%67 = getelementptr float, float* %4, i64 %61
%68 = add i64 %33, %61
%69 = getelementptr float, float* %4, i64 %68
br i1 %28, label %70, label %178
70: ; preds = %60
br i1 %40, label %125, label %71
71: ; preds = %70
%72 = icmp ult float* %64, %69
%73 = icmp ult float* %67, %66
%74 = and i1 %72, %73
br i1 %74, label %125, label %75
75: ; preds = %71
%76 = add i64 %61, %41
%77 = add i64 %62, %41
br i1 %44, label %109, label %78
78: ; preds = %75, %78
%79 = phi i64 [ %106, %78 ], [ 0, %75 ]
%80 = phi i64 [ %107, %78 ], [ 0, %75 ]
%81 = add i64 %61, %79
%82 = add i64 %62, %79
%83 = getelementptr inbounds float, float* %4, i64 %81
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = getelementptr inbounds float, float* %83, i64 4
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = getelementptr inbounds float, float* %7, i64 %82
%90 = bitcast float* %89 to <4 x float>*
store <4 x float> %85, <4 x float>* %90
%91 = getelementptr inbounds float, float* %89, i64 4
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %88, <4 x float>* %92
%93 = or i64 %79, 8
%94 = add i64 %61, %93
%95 = add i64 %62, %93
%96 = getelementptr inbounds float, float* %4, i64 %94
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = getelementptr inbounds float, float* %96, i64 4
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = getelementptr inbounds float, float* %7, i64 %95
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> %98, <4 x float>* %103
%104 = getelementptr inbounds float, float* %102, i64 4
%105 = bitcast float* %104 to <4 x float>*
store <4 x float> %101, <4 x float>* %105
%106 = add nuw i64 %79, 16
%107 = add i64 %80, 2
%108 = icmp eq i64 %107, %45
br i1 %108, label %109, label %78
109: ; preds = %78, %75
%110 = phi i64 [ 0, %75 ], [ %106, %78 ]
br i1 %46, label %124, label %111
111: ; preds = %109
%112 = add i64 %61, %110
%113 = add i64 %62, %110
%114 = getelementptr inbounds float, float* %4, i64 %112
%115 = bitcast float* %114 to <4 x float>*
%116 = load <4 x float>, <4 x float>* %115
%117 = getelementptr inbounds float, float* %114, i64 4
%118 = bitcast float* %117 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = getelementptr inbounds float, float* %7, i64 %113
%121 = bitcast float* %120 to <4 x float>*
store <4 x float> %116, <4 x float>* %121
%122 = getelementptr inbounds float, float* %120, i64 4
%123 = bitcast float* %122 to <4 x float>*
store <4 x float> %119, <4 x float>* %123
br label %124
124: ; preds = %109, %111
br i1 %47, label %178, label %125
125: ; preds = %71, %70, %124
%126 = phi i64 [ %61, %71 ], [ %61, %70 ], [ %76, %124 ]
%127 = phi i64 [ %62, %71 ], [ %62, %70 ], [ %77, %124 ]
%128 = phi i32 [ 0, %71 ], [ 0, %70 ], [ %42, %124 ]
%129 = sub i32 %0, %128
%130 = xor i32 %128, -1
%131 = add i32 %130, %0
%132 = and i32 %129, 3
%133 = icmp eq i32 %132, 0
br i1 %133, label %147, label %134
134: ; preds = %125, %134
%135 = phi i64 [ %143, %134 ], [ %126, %125 ]
%136 = phi i64 [ %142, %134 ], [ %127, %125 ]
%137 = phi i32 [ %144, %134 ], [ %128, %125 ]
%138 = phi i32 [ %145, %134 ], [ 0, %125 ]
%139 = getelementptr inbounds float, float* %4, i64 %135
%140 = load float, float* %139
%141 = getelementptr inbounds float, float* %7, i64 %136
store float %140, float* %141
%142 = add nsw i64 %136, 1
%143 = add nsw i64 %135, 1
%144 = add nuw nsw i32 %137, 1
%145 = add i32 %138, 1
%146 = icmp eq i32 %145, %132
br i1 %146, label %147, label %134
147: ; preds = %134, %125
%148 = phi i64 [ %126, %125 ], [ %143, %134 ]
%149 = phi i64 [ %127, %125 ], [ %142, %134 ]
%150 = phi i32 [ %128, %125 ], [ %144, %134 ]
%151 = icmp ult i32 %131, 3
br i1 %151, label %178, label %152
152: ; preds = %147, %152
%153 = phi i64 [ %175, %152 ], [ %148, %147 ]
%154 = phi i64 [ %174, %152 ], [ %149, %147 ]
%155 = phi i32 [ %176, %152 ], [ %150, %147 ]
%156 = getelementptr inbounds float, float* %4, i64 %153
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %7, i64 %154
store float %157, float* %158
%159 = add nsw i64 %154, 1
%160 = add nsw i64 %153, 1
%161 = getelementptr inbounds float, float* %4, i64 %160
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %7, i64 %159
store float %162, float* %163
%164 = add nsw i64 %154, 2
%165 = add nsw i64 %153, 2
%166 = getelementptr inbounds float, float* %4, i64 %165
%167 = load float, float* %166
%168 = getelementptr inbounds float, float* %7, i64 %164
store float %167, float* %168
%169 = add nsw i64 %154, 3
%170 = add nsw i64 %153, 3
%171 = getelementptr inbounds float, float* %4, i64 %170
%172 = load float, float* %171
%173 = getelementptr inbounds float, float* %7, i64 %169
store float %172, float* %173
%174 = add nsw i64 %154, 4
%175 = add nsw i64 %153, 4
%176 = add nuw nsw i32 %155, 4
%177 = icmp eq i32 %176, %0
br i1 %177, label %178, label %152
178: ; preds = %147, %152, %124, %60
%179 = add nsw i64 %62, %29
%180 = add nsw i64 %61, %30
%181 = add nuw nsw i32 %63, 1
%182 = icmp eq i32 %181, %2
br i1 %182, label %229, label %60
183: ; preds = %50, %226
%184 = phi i64 [ 0, %50 ], [ %227, %226 ]
br i1 %51, label %185, label %226
185: ; preds = %183
br i1 %57, label %212, label %186
186: ; preds = %185, %186
%187 = phi i64 [ %209, %186 ], [ %184, %185 ]
%188 = phi i64 [ %208, %186 ], [ %184, %185 ]
%189 = phi i32 [ %210, %186 ], [ 0, %185 ]
%190 = getelementptr inbounds float, float* %4, i64 %187
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %7, i64 %188
store float %191, float* %192
%193 = add nuw nsw i64 %188, %52
%194 = add nsw i64 %187, %53
%195 = getelementptr inbounds float, float* %4, i64 %194
%196 = load float, float* %195
%197 = getelementptr inbounds float, float* %7, i64 %193
store float %196, float* %197
%198 = add nuw nsw i64 %193, %52
%199 = add nsw i64 %194, %53
%200 = getelementptr inbounds float, float* %4, i64 %199
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %7, i64 %198
store float %201, float* %202
%203 = add nuw nsw i64 %198, %52
%204 = add nsw i64 %199, %53
%205 = getelementptr inbounds float, float* %4, i64 %204
%206 = load float, float* %205
%207 = getelementptr inbounds float, float* %7, i64 %203
store float %206, float* %207
%208 = add nuw nsw i64 %203, %52
%209 = add nsw i64 %204, %53
%210 = add i32 %189, 4
%211 = icmp eq i32 %210, %58
br i1 %211, label %212, label %186
212: ; preds = %186, %185
%213 = phi i64 [ %184, %185 ], [ %209, %186 ]
%214 = phi i64 [ %184, %185 ], [ %208, %186 ]
br i1 %59, label %226, label %215
215: ; preds = %212, %215
%216 = phi i64 [ %223, %215 ], [ %213, %212 ]
%217 = phi i64 [ %222, %215 ], [ %214, %212 ]
%218 = phi i32 [ %224, %215 ], [ 0, %212 ]
%219 = getelementptr inbounds float, float* %4, i64 %216
%220 = load float, float* %219
%221 = getelementptr inbounds float, float* %7, i64 %217
store float %220, float* %221
%222 = add nuw nsw i64 %217, %52
%223 = add nsw i64 %216, %53
%224 = add i32 %218, 1
%225 = icmp eq i32 %224, %56
br i1 %225, label %226, label %215
226: ; preds = %212, %215, %183
%227 = add nuw nsw i64 %184, 1
%228 = icmp eq i64 %227, %54
br i1 %228, label %229, label %183
229: ; preds = %178, %226, %25, %48
%230 = shl i32 %0, 1
%231 = icmp sgt i32 %1, 2
br i1 %231, label %232, label %303
232: ; preds = %229
%233 = icmp sgt i32 %2, 0
%234 = sext i32 %0 to i64
%235 = sext i32 %230 to i64
%236 = sext i32 %11 to i64
%237 = add nsw i32 %1, -1
%238 = mul i32 %12, %237
%239 = call i32 @llvm.smax.i32(i32 %23, i32 2)
%240 = and i32 %2, 1
%241 = icmp eq i32 %2, 1
%242 = and i32 %2, -2
%243 = icmp eq i32 %240, 0
br label %244
244: ; preds = %232, %297
%245 = phi i32 [ %238, %232 ], [ %301, %297 ]
%246 = phi i64 [ %235, %232 ], [ %298, %297 ]
%247 = phi i32 [ %12, %232 ], [ %300, %297 ]
%248 = phi i32 [ 1, %232 ], [ %299, %297 ]
br i1 %233, label %249, label %297
249: ; preds = %244
%250 = sext i32 %245 to i64
%251 = sext i32 %247 to i64
br i1 %241, label %283, label %252
252: ; preds = %249, %252
%253 = phi i64 [ %279, %252 ], [ %250, %249 ]
%254 = phi i64 [ %280, %252 ], [ %246, %249 ]
%255 = phi i64 [ %278, %252 ], [ %251, %249 ]
%256 = phi i32 [ %281, %252 ], [ 0, %249 ]
%257 = add nsw i64 %254, -1
%258 = getelementptr inbounds float, float* %4, i64 %257
%259 = load float, float* %258
%260 = fadd float %259, %259
%261 = getelementptr inbounds float, float* %7, i64 %255
store float %260, float* %261
%262 = getelementptr inbounds float, float* %4, i64 %254
%263 = load float, float* %262
%264 = fadd float %263, %263
%265 = getelementptr inbounds float, float* %7, i64 %253
store float %264, float* %265
%266 = add i64 %255, %234
%267 = add i64 %253, %234
%268 = add i64 %254, %236
%269 = add nsw i64 %268, -1
%270 = getelementptr inbounds float, float* %4, i64 %269
%271 = load float, float* %270
%272 = fadd float %271, %271
%273 = getelementptr inbounds float, float* %7, i64 %266
store float %272, float* %273
%274 = getelementptr inbounds float, float* %4, i64 %268
%275 = load float, float* %274
%276 = fadd float %275, %275
%277 = getelementptr inbounds float, float* %7, i64 %267
store float %276, float* %277
%278 = add i64 %266, %234
%279 = add i64 %267, %234
%280 = add i64 %268, %236
%281 = add i32 %256, 2
%282 = icmp eq i32 %281, %242
br i1 %282, label %283, label %252
283: ; preds = %252, %249
%284 = phi i64 [ %250, %249 ], [ %279, %252 ]
%285 = phi i64 [ %246, %249 ], [ %280, %252 ]
%286 = phi i64 [ %251, %249 ], [ %278, %252 ]
br i1 %243, label %297, label %287
287: ; preds = %283
%288 = add nsw i64 %285, -1
%289 = getelementptr inbounds float, float* %4, i64 %288
%290 = load float, float* %289
%291 = fadd float %290, %290
%292 = getelementptr inbounds float, float* %7, i64 %286
store float %291, float* %292
%293 = getelementptr inbounds float, float* %4, i64 %285
%294 = load float, float* %293
%295 = fadd float %294, %294
%296 = getelementptr inbounds float, float* %7, i64 %284
store float %295, float* %296
br label %297
297: ; preds = %287, %283, %244
%298 = add i64 %246, %235
%299 = add nuw nsw i32 %248, 1
%300 = add i32 %247, %12
%301 = sub i32 %245, %12
%302 = icmp eq i32 %299, %239
br i1 %302, label %303, label %244
303: ; preds = %297, %229
%304 = icmp eq i32 %0, 1
br i1 %304, label %458, label %305
305: ; preds = %303
%306 = icmp slt i32 %21, %2
br i1 %306, label %316, label %307
307: ; preds = %305
br i1 %231, label %308, label %1110
308: ; preds = %307
%309 = icmp sgt i32 %2, 0
%310 = icmp sgt i32 %0, 2
%311 = sext i32 %11 to i64
%312 = add nsw i32 %1, -1
%313 = mul i32 %12, %312
%314 = sext i32 %0 to i64
%315 = call i32 @llvm.smax.i32(i32 %23, i32 2)
br label %329
316: ; preds = %305
br i1 %231, label %317, label %1110
317: ; preds = %316
%318 = icmp sgt i32 %0, 2
%319 = icmp sgt i32 %2, 0
%320 = add i32 %230, -2
%321 = sext i32 %11 to i64
%322 = add i32 %230, 2
%323 = add nsw i32 %1, -1
%324 = mul i32 %12, %323
%325 = add i32 %324, 2
%326 = sext i32 %0 to i64
%327 = add i32 %12, 2
%328 = call i32 @llvm.smax.i32(i32 %23, i32 2)
br label %391
329: ; preds = %308, %385
%330 = phi i32 [ %12, %308 ], [ %389, %385 ]
%331 = phi i32 [ %313, %308 ], [ %388, %385 ]
%332 = phi i32 [ %230, %308 ], [ %387, %385 ]
%333 = phi i32 [ 1, %308 ], [ %386, %385 ]
br i1 %309, label %334, label %385
334: ; preds = %329
%335 = sext i32 %330 to i64
%336 = sext i32 %331 to i64
%337 = sext i32 %332 to i64
br label %338
338: ; preds = %334, %379
%339 = phi i64 [ %335, %334 ], [ %380, %379 ]
%340 = phi i64 [ %336, %334 ], [ %381, %379 ]
%341 = phi i64 [ %337, %334 ], [ %382, %379 ]
%342 = phi i32 [ 0, %334 ], [ %383, %379 ]
br i1 %310, label %343, label %379
343: ; preds = %338, %343
%344 = phi i64 [ %349, %343 ], [ %339, %338 ]
%345 = phi i64 [ %350, %343 ], [ %340, %338 ]
%346 = phi i64 [ %351, %343 ], [ %341, %338 ]
%347 = phi i64 [ %352, %343 ], [ %341, %338 ]
%348 = phi i32 [ %377, %343 ], [ 2, %338 ]
%349 = add nsw i64 %344, 2
%350 = add nsw i64 %345, 2
%351 = add nsw i64 %346, 2
%352 = add nsw i64 %347, -2
%353 = add nsw i64 %346, 1
%354 = getelementptr inbounds float, float* %4, i64 %353
%355 = load float, float* %354
%356 = add nsw i64 %347, -3
%357 = getelementptr inbounds float, float* %4, i64 %356
%358 = load float, float* %357
%359 = fadd float %355, %358
%360 = add nsw i64 %344, 1
%361 = getelementptr inbounds float, float* %7, i64 %360
store float %359, float* %361
%362 = load float, float* %354
%363 = load float, float* %357
%364 = fsub float %362, %363
%365 = add nsw i64 %345, 1
%366 = getelementptr inbounds float, float* %7, i64 %365
store float %364, float* %366
%367 = getelementptr inbounds float, float* %4, i64 %351
%368 = load float, float* %367
%369 = getelementptr inbounds float, float* %4, i64 %352
%370 = load float, float* %369
%371 = fsub float %368, %370
%372 = getelementptr inbounds float, float* %7, i64 %349
store float %371, float* %372
%373 = load float, float* %367
%374 = load float, float* %369
%375 = fadd float %373, %374
%376 = getelementptr inbounds float, float* %7, i64 %350
store float %375, float* %376
%377 = add nuw nsw i32 %348, 2
%378 = icmp slt i32 %377, %0
br i1 %378, label %343, label %379
379: ; preds = %343, %338
%380 = add i64 %339, %314
%381 = add i64 %340, %314
%382 = add i64 %341, %311
%383 = add nuw nsw i32 %342, 1
%384 = icmp eq i32 %383, %2
br i1 %384, label %385, label %338
385: ; preds = %379, %329
%386 = add nuw nsw i32 %333, 1
%387 = add i32 %332, %230
%388 = sub i32 %331, %12
%389 = add i32 %330, %12
%390 = icmp eq i32 %386, %315
br i1 %390, label %458, label %329
391: ; preds = %317, %451
%392 = phi i32 [ %327, %317 ], [ %456, %451 ]
%393 = phi i32 [ %325, %317 ], [ %455, %451 ]
%394 = phi i32 [ %322, %317 ], [ %454, %451 ]
%395 = phi i32 [ %320, %317 ], [ %453, %451 ]
%396 = phi i32 [ 1, %317 ], [ %452, %451 ]
br i1 %318, label %397, label %451
397: ; preds = %391, %444
%398 = phi i32 [ %450, %444 ], [ %392, %391 ]
%399 = phi i32 [ %449, %444 ], [ %393, %391 ]
%400 = phi i32 [ %448, %444 ], [ %394, %391 ]
%401 = phi i32 [ %447, %444 ], [ %395, %391 ]
%402 = phi i32 [ %445, %444 ], [ 2, %391 ]
br i1 %319, label %403, label %444
403: ; preds = %397
%404 = sext i32 %398 to i64
%405 = sext i32 %399 to i64
%406 = sext i32 %400 to i64
%407 = sext i32 %401 to i64
br label %408
408: ; preds = %403, %408
%409 = phi i64 [ %404, %403 ], [ %438, %408 ]
%410 = phi i64 [ %405, %403 ], [ %439, %408 ]
%411 = phi i64 [ %406, %403 ], [ %440, %408 ]
%412 = phi i64 [ %407, %403 ], [ %441, %408 ]
%413 = phi i32 [ 0, %403 ], [ %442, %408 ]
%414 = add nsw i64 %411, -1
%415 = getelementptr inbounds float, float* %4, i64 %414
%416 = load float, float* %415
%417 = add nsw i64 %412, -1
%418 = getelementptr inbounds float, float* %4, i64 %417
%419 = load float, float* %418
%420 = fadd float %416, %419
%421 = add nsw i64 %409, -1
%422 = getelementptr inbounds float, float* %7, i64 %421
store float %420, float* %422
%423 = load float, float* %415
%424 = load float, float* %418
%425 = fsub float %423, %424
%426 = add nsw i64 %410, -1
%427 = getelementptr inbounds float, float* %7, i64 %426
store float %425, float* %427
%428 = getelementptr inbounds float, float* %4, i64 %411
%429 = load float, float* %428
%430 = getelementptr inbounds float, float* %4, i64 %412
%431 = load float, float* %430
%432 = fsub float %429, %431
%433 = getelementptr inbounds float, float* %7, i64 %409
store float %432, float* %433
%434 = load float, float* %428
%435 = load float, float* %430
%436 = fadd float %434, %435
%437 = getelementptr inbounds float, float* %7, i64 %410
store float %436, float* %437
%438 = add i64 %409, %326
%439 = add i64 %410, %326
%440 = add i64 %411, %321
%441 = add i64 %412, %321
%442 = add nuw nsw i32 %413, 1
%443 = icmp eq i32 %442, %2
br i1 %443, label %444, label %408
444: ; preds = %408, %397
%445 = add nuw nsw i32 %402, 2
%446 = icmp slt i32 %445, %0
%447 = add i32 %401, -2
%448 = add i32 %400, 2
%449 = add i32 %399, 2
%450 = add i32 %398, 2
br i1 %446, label %397, label %451
451: ; preds = %444, %391
%452 = add nuw nsw i32 %396, 1
%453 = add i32 %395, %230
%454 = add i32 %394, %230
%455 = sub i32 %393, %12
%456 = add i32 %392, %12
%457 = icmp eq i32 %452, %328
br i1 %457, label %458, label %391
458: ; preds = %385, %451, %303
%459 = add i32 %1, -1
%460 = mul i32 %459, %3
br i1 %231, label %461, label %989
461: ; preds = %458
%462 = icmp sgt i32 %3, 0
%463 = icmp ugt i32 %1, 4
%464 = sext i32 %460 to i64
%465 = sext i32 %3 to i64
%466 = add nsw i32 %1, -2
%467 = mul i32 %466, %3
%468 = shl i32 %3, 1
%469 = call i32 @llvm.smax.i32(i32 %23, i32 3)
%470 = call i32 @llvm.smax.i32(i32 %23, i32 2)
%471 = zext i32 %3 to i64
%472 = add i32 %3, -1
%473 = zext i32 %472 to i64
%474 = add nuw nsw i64 %473, 1
%475 = getelementptr float, float* %6, i64 %474
%476 = getelementptr float, float* %6, i64 %474
%477 = getelementptr float, float* %8, i64 %474
%478 = getelementptr float, float* %8, i64 %474
%479 = add i32 %3, -1
%480 = zext i32 %479 to i64
%481 = add nuw nsw i64 %480, 1
%482 = getelementptr float, float* %6, i64 %471
%483 = getelementptr float, float* %6, i64 %471
%484 = getelementptr float, float* %8, i64 %471
%485 = getelementptr float, float* %8, i64 %465
%486 = add nsw i64 %465, %471
%487 = getelementptr float, float* %8, i64 %486
%488 = getelementptr float, float* %8, i64 %464
%489 = add nsw i64 %464, %471
%490 = getelementptr float, float* %8, i64 %489
%491 = insertelement <2 x float> poison, float %17, i64 0
%492 = shufflevector <2 x float> %491, <2 x float> poison, <2 x i32> zeroinitializer
%493 = insertelement <2 x float> poison, float %17, i64 0
%494 = shufflevector <2 x float> %493, <2 x float> poison, <2 x i32> zeroinitializer
%495 = insertelement <2 x float> poison, float %19, i64 0
%496 = shufflevector <2 x float> %495, <2 x float> poison, <2 x i32> zeroinitializer
%497 = and i64 %471, 4294967292
%498 = add nsw i64 %497, -4
%499 = lshr exact i64 %498, 2
%500 = add nuw nsw i64 %499, 1
%501 = icmp ult i32 %3, 4
%502 = and i64 %471, 4294967292
%503 = add nsw i64 %502, %465
%504 = add nsw i64 %502, %464
%505 = and i64 %500, 1
%506 = icmp eq i64 %498, 0
%507 = and i64 %500, 9223372036854775806
%508 = icmp eq i64 %505, 0
%509 = icmp eq i64 %502, %471
%510 = icmp ult i32 %479, 3
%511 = and i64 %481, 8589934588
%512 = trunc i64 %511 to i32
%513 = icmp eq i64 %481, %511
br label %535
514: ; preds = %804
br i1 %231, label %515, label %989
515: ; preds = %514
%516 = icmp sgt i32 %3, 0
%517 = call i32 @llvm.smax.i32(i32 %23, i32 2)
%518 = zext i32 %3 to i64
%519 = getelementptr float, float* %8, i64 %471
%520 = getelementptr float, float* %8, i64 %471
%521 = and i64 %471, 4294967288
%522 = add nsw i64 %521, -8
%523 = lshr exact i64 %522, 3
%524 = add nuw nsw i64 %523, 1
%525 = icmp ult i32 %3, 8
%526 = and i64 %471, 4294967288
%527 = and i64 %524, 1
%528 = icmp eq i64 %522, 0
%529 = and i64 %524, 4611686018427387902
%530 = icmp eq i64 %527, 0
%531 = icmp eq i64 %526, %471
%532 = and i64 %471, 1
%533 = icmp eq i64 %532, 0
%534 = sub nsw i64 0, %471
br label %819
535: ; preds = %461, %804
%536 = phi i32 [ %3, %461 ], [ %807, %804 ]
%537 = phi i32 [ %460, %461 ], [ %806, %804 ]
%538 = phi i32 [ 1, %461 ], [ %805, %804 ]
%539 = phi <2 x float> [ <float 1.000000e+00, float 0.000000e+00>, %461 ], [ %559, %804 ]
%540 = sext i32 %536 to i64
%541 = getelementptr float, float* %6, i64 %540
%542 = getelementptr float, float* %482, i64 %540
%543 = sext i32 %537 to i64
%544 = getelementptr float, float* %6, i64 %543
%545 = getelementptr float, float* %483, i64 %543
%546 = sext i32 %536 to i64
%547 = getelementptr float, float* %6, i64 %546
%548 = getelementptr float, float* %475, i64 %546
%549 = sext i32 %537 to i64
%550 = getelementptr float, float* %6, i64 %549
%551 = getelementptr float, float* %476, i64 %549
%552 = sext i32 %537 to i64
%553 = sext i32 %536 to i64
%554 = extractelement <2 x float> %539, i64 1
%555 = fneg float %554
%556 = insertelement <2 x float> poison, float %555, i64 0
%557 = shufflevector <2 x float> %556, <2 x float> %539, <2 x i32> <i32 0, i32 2>
%558 = fmul <2 x float> %496, %557
%559 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %494, <2 x float> %539, <2 x float> %558)
%560 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %492, <2 x float> %539, <2 x float> %558)
br i1 %462, label %561, label %693
561: ; preds = %535
br i1 %501, label %663, label %562
562: ; preds = %561
%563 = icmp ult float* %541, %545
%564 = icmp ult float* %544, %542
%565 = and i1 %563, %564
%566 = icmp ult float* %541, %484
%567 = icmp ugt float* %542, %8
%568 = and i1 %566, %567
%569 = or i1 %565, %568
%570 = icmp ult float* %541, %487
%571 = icmp ult float* %485, %542
%572 = and i1 %570, %571
%573 = or i1 %569, %572
%574 = icmp ult float* %541, %490
%575 = icmp ult float* %488, %542
%576 = and i1 %574, %575
%577 = or i1 %573, %576
%578 = icmp ult float* %544, %484
%579 = icmp ugt float* %545, %8
%580 = and i1 %578, %579
%581 = or i1 %577, %580
%582 = icmp ult float* %544, %487
%583 = icmp ult float* %485, %545
%584 = and i1 %582, %583
%585 = or i1 %581, %584
%586 = icmp ult float* %544, %490
%587 = icmp ult float* %488, %545
%588 = and i1 %586, %587
%589 = or i1 %585, %588
br i1 %589, label %663, label %590
590: ; preds = %562
%591 = add nsw i64 %502, %553
%592 = add nsw i64 %502, %552
%593 = shufflevector <2 x float> %560, <2 x float> undef, <4 x i32> zeroinitializer
%594 = shufflevector <2 x float> %560, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
br i1 %506, label %640, label %595
595: ; preds = %590, %595
%596 = phi i64 [ %637, %595 ], [ 0, %590 ]
%597 = phi i64 [ %638, %595 ], [ 0, %590 ]
%598 = add i64 %596, %553
%599 = add i64 %596, %552
%600 = add i64 %596, %465
%601 = add i64 %596, %464
%602 = getelementptr inbounds float, float* %8, i64 %596
%603 = bitcast float* %602 to <4 x float>*
%604 = load <4 x float>, <4 x float>* %603
%605 = getelementptr inbounds float, float* %8, i64 %600
%606 = bitcast float* %605 to <4 x float>*
%607 = load <4 x float>, <4 x float>* %606
%608 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %593, <4 x float> %607, <4 x float> %604)
%609 = getelementptr inbounds float, float* %6, i64 %598
%610 = bitcast float* %609 to <4 x float>*
store <4 x float> %608, <4 x float>* %610
%611 = getelementptr inbounds float, float* %8, i64 %601
%612 = bitcast float* %611 to <4 x float>*
%613 = load <4 x float>, <4 x float>* %612
%614 = fmul <4 x float> %594, %613
%615 = getelementptr inbounds float, float* %6, i64 %599
%616 = bitcast float* %615 to <4 x float>*
store <4 x float> %614, <4 x float>* %616
%617 = or i64 %596, 4
%618 = add i64 %617, %553
%619 = add i64 %617, %552
%620 = add i64 %617, %465
%621 = add i64 %617, %464
%622 = getelementptr inbounds float, float* %8, i64 %617
%623 = bitcast float* %622 to <4 x float>*
%624 = load <4 x float>, <4 x float>* %623
%625 = getelementptr inbounds float, float* %8, i64 %620
%626 = bitcast float* %625 to <4 x float>*
%627 = load <4 x float>, <4 x float>* %626
%628 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %593, <4 x float> %627, <4 x float> %624)
%629 = getelementptr inbounds float, float* %6, i64 %618
%630 = bitcast float* %629 to <4 x float>*
store <4 x float> %628, <4 x float>* %630
%631 = getelementptr inbounds float, float* %8, i64 %621
%632 = bitcast float* %631 to <4 x float>*
%633 = load <4 x float>, <4 x float>* %632
%634 = fmul <4 x float> %594, %633
%635 = getelementptr inbounds float, float* %6, i64 %619
%636 = bitcast float* %635 to <4 x float>*
store <4 x float> %634, <4 x float>* %636
%637 = add nuw i64 %596, 8
%638 = add i64 %597, 2
%639 = icmp eq i64 %638, %507
br i1 %639, label %640, label %595
640: ; preds = %595, %590
%641 = phi i64 [ 0, %590 ], [ %637, %595 ]
br i1 %508, label %662, label %642
642: ; preds = %640
%643 = add i64 %641, %553
%644 = add i64 %641, %552
%645 = add i64 %641, %465
%646 = add i64 %641, %464
%647 = getelementptr inbounds float, float* %8, i64 %641
%648 = bitcast float* %647 to <4 x float>*
%649 = load <4 x float>, <4 x float>* %648
%650 = getelementptr inbounds float, float* %8, i64 %645
%651 = bitcast float* %650 to <4 x float>*
%652 = load <4 x float>, <4 x float>* %651
%653 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %593, <4 x float> %652, <4 x float> %649)
%654 = getelementptr inbounds float, float* %6, i64 %643
%655 = bitcast float* %654 to <4 x float>*
store <4 x float> %653, <4 x float>* %655
%656 = getelementptr inbounds float, float* %8, i64 %646
%657 = bitcast float* %656 to <4 x float>*
%658 = load <4 x float>, <4 x float>* %657
%659 = fmul <4 x float> %594, %658
%660 = getelementptr inbounds float, float* %6, i64 %644
%661 = bitcast float* %660 to <4 x float>*
store <4 x float> %659, <4 x float>* %661
br label %662
662: ; preds = %640, %642
br i1 %509, label %693, label %663
663: ; preds = %562, %561, %662
%664 = phi i64 [ %553, %562 ], [ %553, %561 ], [ %591, %662 ]
%665 = phi i64 [ %552, %562 ], [ %552, %561 ], [ %592, %662 ]
%666 = phi i64 [ 0, %562 ], [ 0, %561 ], [ %502, %662 ]
%667 = phi i64 [ %465, %562 ], [ %465, %561 ], [ %503, %662 ]
%668 = phi i64 [ %464, %562 ], [ %464, %561 ], [ %504, %662 ]
%669 = extractelement <2 x float> %560, i64 0
%670 = extractelement <2 x float> %560, i64 1
br label %671
671: ; preds = %663, %671
%672 = phi i64 [ %684, %671 ], [ %664, %663 ]
%673 = phi i64 [ %690, %671 ], [ %665, %663 ]
%674 = phi i64 [ %677, %671 ], [ %666, %663 ]
%675 = phi i64 [ %680, %671 ], [ %667, %663 ]
%676 = phi i64 [ %686, %671 ], [ %668, %663 ]
%677 = add nuw nsw i64 %674, 1
%678 = getelementptr inbounds float, float* %8, i64 %674
%679 = load float, float* %678
%680 = add nsw i64 %675, 1
%681 = getelementptr inbounds float, float* %8, i64 %675
%682 = load float, float* %681
%683 = tail call float @llvm.fmuladd.f32(float %669, float %682, float %679)
%684 = add nsw i64 %672, 1
%685 = getelementptr inbounds float, float* %6, i64 %672
store float %683, float* %685
%686 = add nsw i64 %676, 1
%687 = getelementptr inbounds float, float* %8, i64 %676
%688 = load float, float* %687
%689 = fmul float %670, %688
%690 = add nsw i64 %673, 1
%691 = getelementptr inbounds float, float* %6, i64 %673
store float %689, float* %691
%692 = icmp eq i64 %677, %471
br i1 %692, label %693, label %671
693: ; preds = %671, %662, %535
br i1 %463, label %694, label %804
694: ; preds = %693
%695 = extractelement <2 x float> %560, i64 1
%696 = fneg float %695
%697 = insertelement <2 x float> poison, float %696, i64 0
%698 = shufflevector <2 x float> %560, <2 x float> undef, <2 x i32> zeroinitializer
%699 = icmp ult float* %547, %551
%700 = icmp ult float* %550, %548
%701 = and i1 %699, %700
%702 = add nsw i64 %511, %553
%703 = add nsw i64 %511, %552
br label %704
704: ; preds = %694, %799
%705 = phi i32 [ %468, %694 ], [ %802, %799 ]
%706 = phi i32 [ %467, %694 ], [ %801, %799 ]
%707 = phi i32 [ 2, %694 ], [ %800, %799 ]
%708 = phi <2 x float> [ %560, %694 ], [ %718, %799 ]
%709 = sext i32 %705 to i64
%710 = getelementptr float, float* %8, i64 %709
%711 = getelementptr float, float* %477, i64 %709
%712 = sext i32 %706 to i64
%713 = getelementptr float, float* %8, i64 %712
%714 = getelementptr float, float* %478, i64 %712
%715 = shufflevector <2 x float> %708, <2 x float> %560, <2 x i32> <i32 1, i32 3>
%716 = shufflevector <2 x float> %697, <2 x float> %708, <2 x i32> <i32 0, i32 2>
%717 = fmul <2 x float> %715, %716
%718 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %698, <2 x float> %708, <2 x float> %717)
br i1 %462, label %719, label %799
719: ; preds = %704
%720 = sext i32 %705 to i64
%721 = sext i32 %706 to i64
br i1 %510, label %769, label %722
722: ; preds = %719
%723 = icmp ult float* %547, %711
%724 = icmp ult float* %710, %548
%725 = and i1 %723, %724
%726 = or i1 %701, %725
%727 = icmp ult float* %547, %714
%728 = icmp ult float* %713, %548
%729 = and i1 %727, %728
%730 = or i1 %726, %729
%731 = icmp ult float* %550, %711
%732 = icmp ult float* %710, %551
%733 = and i1 %731, %732
%734 = or i1 %730, %733
%735 = icmp ult float* %550, %714
%736 = icmp ult float* %713, %551
%737 = and i1 %735, %736
%738 = or i1 %734, %737
br i1 %738, label %769, label %739
739: ; preds = %722
%740 = add nsw i64 %511, %720
%741 = add nsw i64 %511, %721
%742 = shufflevector <2 x float> %718, <2 x float> undef, <4 x i32> zeroinitializer
%743 = shufflevector <2 x float> %718, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
br label %744
744: ; preds = %744, %739
%745 = phi i64 [ 0, %739 ], [ %766, %744 ]
%746 = add i64 %745, %553
%747 = add i64 %745, %552
%748 = add i64 %745, %720
%749 = add i64 %745, %721
%750 = getelementptr inbounds float, float* %8, i64 %748
%751 = bitcast float* %750 to <4 x float>*
%752 = load <4 x float>, <4 x float>* %751
%753 = getelementptr inbounds float, float* %6, i64 %746
%754 = bitcast float* %753 to <4 x float>*
%755 = load <4 x float>, <4 x float>* %754
%756 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %742, <4 x float> %752, <4 x float> %755)
%757 = bitcast float* %753 to <4 x float>*
store <4 x float> %756, <4 x float>* %757
%758 = getelementptr inbounds float, float* %8, i64 %749
%759 = bitcast float* %758 to <4 x float>*
%760 = load <4 x float>, <4 x float>* %759
%761 = getelementptr inbounds float, float* %6, i64 %747
%762 = bitcast float* %761 to <4 x float>*
%763 = load <4 x float>, <4 x float>* %762
%764 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %743, <4 x float> %760, <4 x float> %763)
%765 = bitcast float* %761 to <4 x float>*
store <4 x float> %764, <4 x float>* %765
%766 = add nuw i64 %745, 4
%767 = icmp eq i64 %766, %511
br i1 %767, label %768, label %744
768: ; preds = %744
br i1 %513, label %799, label %769
769: ; preds = %722, %719, %768
%770 = phi i64 [ %553, %722 ], [ %553, %719 ], [ %702, %768 ]
%771 = phi i64 [ %552, %722 ], [ %552, %719 ], [ %703, %768 ]
%772 = phi i64 [ %720, %722 ], [ %720, %719 ], [ %740, %768 ]
%773 = phi i64 [ %721, %722 ], [ %721, %719 ], [ %741, %768 ]
%774 = phi i32 [ 0, %722 ], [ 0, %719 ], [ %512, %768 ]
%775 = extractelement <2 x float> %718, i64 0
%776 = extractelement <2 x float> %718, i64 1
br label %777
777: ; preds = %769, %777
%778 = phi i64 [ %786, %777 ], [ %770, %769 ]
%779 = phi i64 [ %793, %777 ], [ %771, %769 ]
%780 = phi i64 [ %783, %777 ], [ %772, %769 ]
%781 = phi i64 [ %790, %777 ], [ %773, %769 ]
%782 = phi i32 [ %797, %777 ], [ %774, %769 ]
%783 = add nsw i64 %780, 1
%784 = getelementptr inbounds float, float* %8, i64 %780
%785 = load float, float* %784
%786 = add nsw i64 %778, 1
%787 = getelementptr inbounds float, float* %6, i64 %778
%788 = load float, float* %787
%789 = tail call float @llvm.fmuladd.f32(float %775, float %785, float %788)
store float %789, float* %787
%790 = add nsw i64 %781, 1
%791 = getelementptr inbounds float, float* %8, i64 %781
%792 = load float, float* %791
%793 = add nsw i64 %779, 1
%794 = getelementptr inbounds float, float* %6, i64 %779
%795 = load float, float* %794
%796 = tail call float @llvm.fmuladd.f32(float %776, float %792, float %795)
store float %796, float* %794
%797 = add nuw nsw i32 %782, 1
%798 = icmp eq i32 %797, %3
br i1 %798, label %799, label %777
799: ; preds = %777, %768, %704
%800 = add nuw nsw i32 %707, 1
%801 = sub i32 %706, %3
%802 = add i32 %705, %3
%803 = icmp eq i32 %800, %469
br i1 %803, label %804, label %704
804: ; preds = %799, %693
%805 = add nuw nsw i32 %538, 1
%806 = sub i32 %537, %3
%807 = add i32 %536, %3
%808 = icmp eq i32 %805, %470
br i1 %808, label %514, label %535
809: ; preds = %929
br i1 %231, label %810, label %989
810: ; preds = %809
%811 = icmp sgt i32 %2, 0
%812 = sext i32 %0 to i64
%813 = mul i32 %12, %459
%814 = call i32 @llvm.smax.i32(i32 %23, i32 2)
%815 = and i32 %2, 1
%816 = icmp eq i32 %2, 1
%817 = and i32 %2, -2
%818 = icmp eq i32 %815, 0
br label %933
819: ; preds = %515, %929
%820 = phi i32 [ %3, %515 ], [ %931, %929 ]
%821 = phi i32 [ 1, %515 ], [ %930, %929 ]
%822 = sext i32 %820 to i64
%823 = getelementptr float, float* %8, i64 %822
%824 = getelementptr float, float* %520, i64 %822
br i1 %516, label %825, label %929
825: ; preds = %819
%826 = sext i32 %820 to i64
br i1 %525, label %895, label %827
827: ; preds = %825
%828 = icmp ugt float* %824, %8
%829 = icmp ult float* %823, %519
%830 = and i1 %828, %829
br i1 %830, label %895, label %831
831: ; preds = %827
%832 = add nsw i64 %526, %826
br i1 %528, label %874, label %833
833: ; preds = %831, %833
%834 = phi i64 [ %871, %833 ], [ 0, %831 ]
%835 = phi i64 [ %872, %833 ], [ 0, %831 ]
%836 = add i64 %834, %826
%837 = getelementptr inbounds float, float* %8, i64 %836
%838 = bitcast float* %837 to <4 x float>*
%839 = load <4 x float>, <4 x float>* %838
%840 = getelementptr inbounds float, float* %837, i64 4
%841 = bitcast float* %840 to <4 x float>*
%842 = load <4 x float>, <4 x float>* %841
%843 = getelementptr inbounds float, float* %8, i64 %834
%844 = bitcast float* %843 to <4 x float>*
%845 = load <4 x float>, <4 x float>* %844
%846 = getelementptr inbounds float, float* %843, i64 4
%847 = bitcast float* %846 to <4 x float>*
%848 = load <4 x float>, <4 x float>* %847
%849 = fadd <4 x float> %839, %845
%850 = fadd <4 x float> %842, %848
%851 = bitcast float* %843 to <4 x float>*
store <4 x float> %849, <4 x float>* %851
%852 = bitcast float* %846 to <4 x float>*
store <4 x float> %850, <4 x float>* %852
%853 = or i64 %834, 8
%854 = add i64 %853, %826
%855 = getelementptr inbounds float, float* %8, i64 %854
%856 = bitcast float* %855 to <4 x float>*
%857 = load <4 x float>, <4 x float>* %856
%858 = getelementptr inbounds float, float* %855, i64 4
%859 = bitcast float* %858 to <4 x float>*
%860 = load <4 x float>, <4 x float>* %859
%861 = getelementptr inbounds float, float* %8, i64 %853
%862 = bitcast float* %861 to <4 x float>*
%863 = load <4 x float>, <4 x float>* %862
%864 = getelementptr inbounds float, float* %861, i64 4
%865 = bitcast float* %864 to <4 x float>*
%866 = load <4 x float>, <4 x float>* %865
%867 = fadd <4 x float> %857, %863
%868 = fadd <4 x float> %860, %866
%869 = bitcast float* %861 to <4 x float>*
store <4 x float> %867, <4 x float>* %869
%870 = bitcast float* %864 to <4 x float>*
store <4 x float> %868, <4 x float>* %870
%871 = add nuw i64 %834, 16
%872 = add i64 %835, 2
%873 = icmp eq i64 %872, %529
br i1 %873, label %874, label %833
874: ; preds = %833, %831
%875 = phi i64 [ 0, %831 ], [ %871, %833 ]
br i1 %530, label %894, label %876
876: ; preds = %874
%877 = add i64 %875, %826
%878 = getelementptr inbounds float, float* %8, i64 %877
%879 = bitcast float* %878 to <4 x float>*
%880 = load <4 x float>, <4 x float>* %879
%881 = getelementptr inbounds float, float* %878, i64 4
%882 = bitcast float* %881 to <4 x float>*
%883 = load <4 x float>, <4 x float>* %882
%884 = getelementptr inbounds float, float* %8, i64 %875
%885 = bitcast float* %884 to <4 x float>*
%886 = load <4 x float>, <4 x float>* %885
%887 = getelementptr inbounds float, float* %884, i64 4
%888 = bitcast float* %887 to <4 x float>*
%889 = load <4 x float>, <4 x float>* %888
%890 = fadd <4 x float> %880, %886
%891 = fadd <4 x float> %883, %889
%892 = bitcast float* %884 to <4 x float>*
store <4 x float> %890, <4 x float>* %892
%893 = bitcast float* %887 to <4 x float>*
store <4 x float> %891, <4 x float>* %893
br label %894
894: ; preds = %874, %876
br i1 %531, label %929, label %895
895: ; preds = %827, %825, %894
%896 = phi i64 [ %826, %827 ], [ %826, %825 ], [ %832, %894 ]
%897 = phi i64 [ 0, %827 ], [ 0, %825 ], [ %526, %894 ]
%898 = xor i64 %897, -1
br i1 %533, label %907, label %899
899: ; preds = %895
%900 = add nsw i64 %896, 1
%901 = getelementptr inbounds float, float* %8, i64 %896
%902 = load float, float* %901
%903 = getelementptr inbounds float, float* %8, i64 %897
%904 = load float, float* %903
%905 = fadd float %902, %904
store float %905, float* %903
%906 = or i64 %897, 1
br label %907
907: ; preds = %899, %895
%908 = phi i64 [ %896, %895 ], [ %900, %899 ]
%909 = phi i64 [ %897, %895 ], [ %906, %899 ]
%910 = icmp eq i64 %898, %534
br i1 %910, label %929, label %911
911: ; preds = %907, %911
%912 = phi i64 [ %921, %911 ], [ %908, %907 ]
%913 = phi i64 [ %927, %911 ], [ %909, %907 ]
%914 = add nsw i64 %912, 1
%915 = getelementptr inbounds float, float* %8, i64 %912
%916 = load float, float* %915
%917 = getelementptr inbounds float, float* %8, i64 %913
%918 = load float, float* %917
%919 = fadd float %916, %918
store float %919, float* %917
%920 = add nuw nsw i64 %913, 1
%921 = add nsw i64 %912, 2
%922 = getelementptr inbounds float, float* %8, i64 %914
%923 = load float, float* %922
%924 = getelementptr inbounds float, float* %8, i64 %920
%925 = load float, float* %924
%926 = fadd float %923, %925
store float %926, float* %924
%927 = add nuw nsw i64 %913, 2
%928 = icmp eq i64 %927, %518
br i1 %928, label %929, label %911
929: ; preds = %907, %911, %894, %819
%930 = add nuw nsw i32 %821, 1
%931 = add i32 %820, %3
%932 = icmp eq i32 %930, %517
br i1 %932, label %809, label %819
933: ; preds = %810, %984
%934 = phi i32 [ %813, %810 ], [ %987, %984 ]
%935 = phi i32 [ %12, %810 ], [ %986, %984 ]
%936 = phi i32 [ 1, %810 ], [ %985, %984 ]
br i1 %811, label %937, label %984
937: ; preds = %933
%938 = sext i32 %934 to i64
%939 = sext i32 %935 to i64
br i1 %816, label %970, label %940
940: ; preds = %937, %940
%941 = phi i64 [ %967, %940 ], [ %938, %937 ]
%942 = phi i64 [ %966, %940 ], [ %939, %937 ]
%943 = phi i32 [ %968, %940 ], [ 0, %937 ]
%944 = getelementptr inbounds float, float* %5, i64 %942
%945 = load float, float* %944
%946 = getelementptr inbounds float, float* %5, i64 %941
%947 = load float, float* %946
%948 = fsub float %945, %947
%949 = getelementptr inbounds float, float* %7, i64 %942
store float %948, float* %949
%950 = load float, float* %944
%951 = load float, float* %946
%952 = fadd float %950, %951
%953 = getelementptr inbounds float, float* %7, i64 %941
store float %952, float* %953
%954 = add i64 %942, %812
%955 = add i64 %941, %812
%956 = getelementptr inbounds float, float* %5, i64 %954
%957 = load float, float* %956
%958 = getelementptr inbounds float, float* %5, i64 %955
%959 = load float, float* %958
%960 = fsub float %957, %959
%961 = getelementptr inbounds float, float* %7, i64 %954
store float %960, float* %961
%962 = load float, float* %956
%963 = load float, float* %958
%964 = fadd float %962, %963
%965 = getelementptr inbounds float, float* %7, i64 %955
store float %964, float* %965
%966 = add i64 %954, %812
%967 = add i64 %955, %812
%968 = add i32 %943, 2
%969 = icmp eq i32 %968, %817
br i1 %969, label %970, label %940
970: ; preds = %940, %937
%971 = phi i64 [ %938, %937 ], [ %967, %940 ]
%972 = phi i64 [ %939, %937 ], [ %966, %940 ]
br i1 %818, label %984, label %973
973: ; preds = %970
%974 = getelementptr inbounds float, float* %5, i64 %972
%975 = load float, float* %974
%976 = getelementptr inbounds float, float* %5, i64 %971
%977 = load float, float* %976
%978 = fsub float %975, %977
%979 = getelementptr inbounds float, float* %7, i64 %972
store float %978, float* %979
%980 = load float, float* %974
%981 = load float, float* %976
%982 = fadd float %980, %981
%983 = getelementptr inbounds float, float* %7, i64 %971
store float %982, float* %983
br label %984
984: ; preds = %973, %970, %933
%985 = add nuw nsw i32 %936, 1
%986 = add i32 %935, %12
%987 = sub i32 %934, %12
%988 = icmp eq i32 %985, %814
br i1 %988, label %989, label %933
989: ; preds = %984, %458, %514, %809
br i1 %304, label %1489, label %990
990: ; preds = %989
%991 = icmp slt i32 %21, %2
br i1 %991, label %999, label %992
992: ; preds = %990
br i1 %231, label %993, label %1110
993: ; preds = %992
%994 = icmp sgt i32 %2, 0
%995 = icmp sgt i32 %0, 2
%996 = mul i32 %12, %459
%997 = sext i32 %0 to i64
%998 = call i32 @llvm.smax.i32(i32 %23, i32 2)
br label %1008
999: ; preds = %990
br i1 %231, label %1000, label %1110
1000: ; preds = %999
%1001 = icmp sgt i32 %0, 2
%1002 = icmp sgt i32 %2, 0
%1003 = mul i32 %12, %459
%1004 = add i32 %1003, 2
%1005 = sext i32 %0 to i64
%1006 = add i32 %12, 2
%1007 = call i32 @llvm.smax.i32(i32 %23, i32 2)
br label %1059
1008: ; preds = %993, %1054
%1009 = phi i32 [ %12, %993 ], [ %1057, %1054 ]
%1010 = phi i32 [ %996, %993 ], [ %1056, %1054 ]
%1011 = phi i32 [ 1, %993 ], [ %1055, %1054 ]
br i1 %994, label %1012, label %1054
1012: ; preds = %1008
%1013 = sext i32 %1009 to i64
%1014 = sext i32 %1010 to i64
br label %1015
1015: ; preds = %1012, %1049
%1016 = phi i64 [ %1013, %1012 ], [ %1050, %1049 ]
%1017 = phi i64 [ %1014, %1012 ], [ %1051, %1049 ]
%1018 = phi i32 [ 0, %1012 ], [ %1052, %1049 ]
br i1 %995, label %1019, label %1049
1019: ; preds = %1015, %1019
%1020 = phi i64 [ %1023, %1019 ], [ %1016, %1015 ]
%1021 = phi i64 [ %1024, %1019 ], [ %1017, %1015 ]
%1022 = phi i32 [ %1047, %1019 ], [ 2, %1015 ]
%1023 = add nsw i64 %1020, 2
%1024 = add nsw i64 %1021, 2
%1025 = add nsw i64 %1020, 1
%1026 = getelementptr inbounds float, float* %5, i64 %1025
%1027 = load float, float* %1026
%1028 = getelementptr inbounds float, float* %5, i64 %1024
%1029 = load float, float* %1028
%1030 = fsub float %1027, %1029
%1031 = getelementptr inbounds float, float* %7, i64 %1025
store float %1030, float* %1031
%1032 = load float, float* %1026
%1033 = load float, float* %1028
%1034 = fadd float %1032, %1033
%1035 = add nsw i64 %1021, 1
%1036 = getelementptr inbounds float, float* %7, i64 %1035
store float %1034, float* %1036
%1037 = getelementptr inbounds float, float* %5, i64 %1023
%1038 = load float, float* %1037
%1039 = getelementptr inbounds float, float* %5, i64 %1035
%1040 = load float, float* %1039
%1041 = fadd float %1038, %1040
%1042 = getelementptr inbounds float, float* %7, i64 %1023
store float %1041, float* %1042
%1043 = load float, float* %1037
%1044 = load float, float* %1039
%1045 = fsub float %1043, %1044
%1046 = getelementptr inbounds float, float* %7, i64 %1024
store float %1045, float* %1046
%1047 = add nuw nsw i32 %1022, 2
%1048 = icmp slt i32 %1047, %0
br i1 %1048, label %1019, label %1049
1049: ; preds = %1019, %1015
%1050 = add i64 %1016, %997
%1051 = add i64 %1017, %997
%1052 = add nuw nsw i32 %1018, 1
%1053 = icmp eq i32 %1052, %2
br i1 %1053, label %1054, label %1015
1054: ; preds = %1049, %1008
%1055 = add nuw nsw i32 %1011, 1
%1056 = sub i32 %1010, %12
%1057 = add i32 %1009, %12
%1058 = icmp eq i32 %1055, %998
br i1 %1058, label %1110, label %1008
1059: ; preds = %1000, %1105
%1060 = phi i32 [ %1006, %1000 ], [ %1108, %1105 ]
%1061 = phi i32 [ %1004, %1000 ], [ %1107, %1105 ]
%1062 = phi i32 [ 1, %1000 ], [ %1106, %1105 ]
br i1 %1001, label %1063, label %1105
1063: ; preds = %1059, %1100
%1064 = phi i32 [ %1104, %1100 ], [ %1060, %1059 ]
%1065 = phi i32 [ %1103, %1100 ], [ %1061, %1059 ]
%1066 = phi i32 [ %1101, %1100 ], [ 2, %1059 ]
br i1 %1002, label %1067, label %1100
1067: ; preds = %1063
%1068 = sext i32 %1064 to i64
%1069 = sext i32 %1065 to i64
br label %1070
1070: ; preds = %1067, %1070
%1071 = phi i64 [ %1068, %1067 ], [ %1096, %1070 ]
%1072 = phi i64 [ %1069, %1067 ], [ %1097, %1070 ]
%1073 = phi i32 [ 0, %1067 ], [ %1098, %1070 ]
%1074 = add nsw i64 %1071, -1
%1075 = getelementptr inbounds float, float* %5, i64 %1074
%1076 = load float, float* %1075
%1077 = getelementptr inbounds float, float* %5, i64 %1072
%1078 = load float, float* %1077
%1079 = fsub float %1076, %1078
%1080 = getelementptr inbounds float, float* %7, i64 %1074
store float %1079, float* %1080
%1081 = load float, float* %1075
%1082 = load float, float* %1077
%1083 = fadd float %1081, %1082
%1084 = add nsw i64 %1072, -1
%1085 = getelementptr inbounds float, float* %7, i64 %1084
store float %1083, float* %1085
%1086 = getelementptr inbounds float, float* %5, i64 %1071
%1087 = load float, float* %1086
%1088 = getelementptr inbounds float, float* %5, i64 %1084
%1089 = load float, float* %1088
%1090 = fadd float %1087, %1089
%1091 = getelementptr inbounds float, float* %7, i64 %1071
store float %1090, float* %1091
%1092 = load float, float* %1086
%1093 = load float, float* %1088
%1094 = fsub float %1092, %1093
%1095 = getelementptr inbounds float, float* %7, i64 %1072
store float %1094, float* %1095
%1096 = add i64 %1071, %1005
%1097 = add i64 %1072, %1005
%1098 = add nuw nsw i32 %1073, 1
%1099 = icmp eq i32 %1098, %2
br i1 %1099, label %1100, label %1070
1100: ; preds = %1070, %1063
%1101 = add nuw nsw i32 %1066, 2
%1102 = icmp slt i32 %1101, %0
%1103 = add i32 %1065, 2
%1104 = add i32 %1064, 2
br i1 %1102, label %1063, label %1105
1105: ; preds = %1100, %1059
%1106 = add nuw nsw i32 %1062, 1
%1107 = sub i32 %1061, %12
%1108 = add i32 %1060, %12
%1109 = icmp eq i32 %1106, %1007
br i1 %1109, label %1110, label %1059
1110: ; preds = %1054, %1105, %316, %307, %992, %999
%1111 = icmp sgt i32 %3, 0
br i1 %1111, label %1112, label %1218
1112: ; preds = %1110
%1113 = zext i32 %3 to i64
%1114 = icmp ult i32 %3, 8
br i1 %1114, label %1200, label %1115
1115: ; preds = %1112
%1116 = getelementptr float, float* %6, i64 %1113
%1117 = getelementptr float, float* %8, i64 %1113
%1118 = icmp ugt float* %1117, %6
%1119 = icmp ugt float* %1116, %8
%1120 = and i1 %1118, %1119
br i1 %1120, label %1200, label %1121
1121: ; preds = %1115
%1122 = and i64 %1113, 4294967288
%1123 = add nsw i64 %1122, -8
%1124 = lshr exact i64 %1123, 3
%1125 = add nuw nsw i64 %1124, 1
%1126 = and i64 %1125, 3
%1127 = icmp ult i64 %1123, 24
br i1 %1127, label %1179, label %1128
1128: ; preds = %1121
%1129 = and i64 %1125, 4611686018427387900
br label %1130
1130: ; preds = %1130, %1128
%1131 = phi i64 [ 0, %1128 ], [ %1176, %1130 ]
%1132 = phi i64 [ 0, %1128 ], [ %1177, %1130 ]
%1133 = getelementptr inbounds float, float* %8, i64 %1131
%1134 = bitcast float* %1133 to <4 x float>*
%1135 = load <4 x float>, <4 x float>* %1134
%1136 = getelementptr inbounds float, float* %1133, i64 4
%1137 = bitcast float* %1136 to <4 x float>*
%1138 = load <4 x float>, <4 x float>* %1137
%1139 = getelementptr inbounds float, float* %6, i64 %1131
%1140 = bitcast float* %1139 to <4 x float>*
store <4 x float> %1135, <4 x float>* %1140
%1141 = getelementptr inbounds float, float* %1139, i64 4
%1142 = bitcast float* %1141 to <4 x float>*
store <4 x float> %1138, <4 x float>* %1142
%1143 = or i64 %1131, 8
%1144 = getelementptr inbounds float, float* %8, i64 %1143
%1145 = bitcast float* %1144 to <4 x float>*
%1146 = load <4 x float>, <4 x float>* %1145
%1147 = getelementptr inbounds float, float* %1144, i64 4
%1148 = bitcast float* %1147 to <4 x float>*
%1149 = load <4 x float>, <4 x float>* %1148
%1150 = getelementptr inbounds float, float* %6, i64 %1143
%1151 = bitcast float* %1150 to <4 x float>*
store <4 x float> %1146, <4 x float>* %1151
%1152 = getelementptr inbounds float, float* %1150, i64 4
%1153 = bitcast float* %1152 to <4 x float>*
store <4 x float> %1149, <4 x float>* %1153
%1154 = or i64 %1131, 16
%1155 = getelementptr inbounds float, float* %8, i64 %1154
%1156 = bitcast float* %1155 to <4 x float>*
%1157 = load <4 x float>, <4 x float>* %1156
%1158 = getelementptr inbounds float, float* %1155, i64 4
%1159 = bitcast float* %1158 to <4 x float>*
%1160 = load <4 x float>, <4 x float>* %1159
%1161 = getelementptr inbounds float, float* %6, i64 %1154
%1162 = bitcast float* %1161 to <4 x float>*
store <4 x float> %1157, <4 x float>* %1162
%1163 = getelementptr inbounds float, float* %1161, i64 4
%1164 = bitcast float* %1163 to <4 x float>*
store <4 x float> %1160, <4 x float>* %1164
%1165 = or i64 %1131, 24
%1166 = getelementptr inbounds float, float* %8, i64 %1165
%1167 = bitcast float* %1166 to <4 x float>*
%1168 = load <4 x float>, <4 x float>* %1167
%1169 = getelementptr inbounds float, float* %1166, i64 4
%1170 = bitcast float* %1169 to <4 x float>*
%1171 = load <4 x float>, <4 x float>* %1170
%1172 = getelementptr inbounds float, float* %6, i64 %1165
%1173 = bitcast float* %1172 to <4 x float>*
store <4 x float> %1168, <4 x float>* %1173
%1174 = getelementptr inbounds float, float* %1172, i64 4
%1175 = bitcast float* %1174 to <4 x float>*
store <4 x float> %1171, <4 x float>* %1175
%1176 = add nuw i64 %1131, 32
%1177 = add i64 %1132, 4
%1178 = icmp eq i64 %1177, %1129
br i1 %1178, label %1179, label %1130
1179: ; preds = %1130, %1121
%1180 = phi i64 [ 0, %1121 ], [ %1176, %1130 ]
%1181 = icmp eq i64 %1126, 0
br i1 %1181, label %1198, label %1182
1182: ; preds = %1179, %1182
%1183 = phi i64 [ %1195, %1182 ], [ %1180, %1179 ]
%1184 = phi i64 [ %1196, %1182 ], [ 0, %1179 ]
%1185 = getelementptr inbounds float, float* %8, i64 %1183
%1186 = bitcast float* %1185 to <4 x float>*
%1187 = load <4 x float>, <4 x float>* %1186
%1188 = getelementptr inbounds float, float* %1185, i64 4
%1189 = bitcast float* %1188 to <4 x float>*
%1190 = load <4 x float>, <4 x float>* %1189
%1191 = getelementptr inbounds float, float* %6, i64 %1183
%1192 = bitcast float* %1191 to <4 x float>*
store <4 x float> %1187, <4 x float>* %1192
%1193 = getelementptr inbounds float, float* %1191, i64 4
%1194 = bitcast float* %1193 to <4 x float>*
store <4 x float> %1190, <4 x float>* %1194
%1195 = add nuw i64 %1183, 8
%1196 = add i64 %1184, 1
%1197 = icmp eq i64 %1196, %1126
br i1 %1197, label %1198, label %1182
1198: ; preds = %1182, %1179
%1199 = icmp eq i64 %1122, %1113
br i1 %1199, label %1218, label %1200
1200: ; preds = %1115, %1112, %1198
%1201 = phi i64 [ 0, %1115 ], [ 0, %1112 ], [ %1122, %1198 ]
%1202 = xor i64 %1201, -1
%1203 = add nsw i64 %1202, %1113
%1204 = and i64 %1113, 3
%1205 = icmp eq i64 %1204, 0
br i1 %1205, label %1215, label %1206
1206: ; preds = %1200, %1206
%1207 = phi i64 [ %1212, %1206 ], [ %1201, %1200 ]
%1208 = phi i64 [ %1213, %1206 ], [ 0, %1200 ]
%1209 = getelementptr inbounds float, float* %8, i64 %1207
%1210 = load float, float* %1209
%1211 = getelementptr inbounds float, float* %6, i64 %1207
store float %1210, float* %1211
%1212 = add nuw nsw i64 %1207, 1
%1213 = add i64 %1208, 1
%1214 = icmp eq i64 %1213, %1204
br i1 %1214, label %1215, label %1206
1215: ; preds = %1206, %1200
%1216 = phi i64 [ %1201, %1200 ], [ %1212, %1206 ]
%1217 = icmp ult i64 %1203, 3
br i1 %1217, label %1218, label %1228
1218: ; preds = %1215, %1228, %1198, %1110
%1219 = icmp sgt i32 %1, 1
br i1 %1219, label %1220, label %1489
1220: ; preds = %1218
%1221 = icmp sgt i32 %2, 0
%1222 = sext i32 %0 to i64
%1223 = add i32 %2, -1
%1224 = and i32 %2, 3
%1225 = icmp ult i32 %1223, 3
%1226 = and i32 %2, -4
%1227 = icmp eq i32 %1224, 0
br label %1247
1228: ; preds = %1215, %1228
%1229 = phi i64 [ %1245, %1228 ], [ %1216, %1215 ]
%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 %1229, 1
%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 %1229, 2
%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 %1229, 3
%1242 = getelementptr inbounds float, float* %8, i64 %1241
%1243 = load float, float* %1242
%1244 = getelementptr inbounds float, float* %6, i64 %1241
store float %1243, float* %1244
%1245 = add nuw nsw i64 %1229, 4
%1246 = icmp eq i64 %1245, %1113
br i1 %1246, label %1218, label %1228
1247: ; preds = %1220, %1284
%1248 = phi i32 [ %12, %1220 ], [ %1286, %1284 ]
%1249 = phi i32 [ 1, %1220 ], [ %1285, %1284 ]
br i1 %1221, label %1250, label %1284
1250: ; preds = %1247
%1251 = sext i32 %1248 to i64
br i1 %1225, label %1273, label %1252
1252: ; preds = %1250, %1252
%1253 = phi i64 [ %1270, %1252 ], [ %1251, %1250 ]
%1254 = phi i32 [ %1271, %1252 ], [ 0, %1250 ]
%1255 = getelementptr inbounds float, float* %7, i64 %1253
%1256 = load float, float* %1255
%1257 = getelementptr inbounds float, float* %5, i64 %1253
store float %1256, float* %1257
%1258 = add i64 %1253, %1222
%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, %1222
%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, %1222
%1267 = getelementptr inbounds float, float* %7, i64 %1266
%1268 = load float, float* %1267
%1269 = getelementptr inbounds float, float* %5, i64 %1266
store float %1268, float* %1269
%1270 = add i64 %1266, %1222
%1271 = add i32 %1254, 4
%1272 = icmp eq i32 %1271, %1226
br i1 %1272, label %1273, label %1252
1273: ; preds = %1252, %1250
%1274 = phi i64 [ %1251, %1250 ], [ %1270, %1252 ]
br i1 %1227, label %1284, label %1275
1275: ; preds = %1273, %1275
%1276 = phi i64 [ %1281, %1275 ], [ %1274, %1273 ]
%1277 = phi i32 [ %1282, %1275 ], [ 0, %1273 ]
%1278 = getelementptr inbounds float, float* %7, i64 %1276
%1279 = load float, float* %1278
%1280 = getelementptr inbounds float, float* %5, i64 %1276
store float %1279, float* %1280
%1281 = add i64 %1276, %1222
%1282 = add i32 %1277, 1
%1283 = icmp eq i32 %1282, %1224
br i1 %1283, label %1284, label %1275
1284: ; preds = %1273, %1275, %1247
%1285 = add nuw nsw i32 %1249, 1
%1286 = add i32 %1248, %12
%1287 = icmp eq i32 %1285, %1
br i1 %1287, label %1288, label %1247
1288: ; preds = %1284
%1289 = icmp sgt i32 %21, %2
br i1 %1289, label %1345, label %1290
1290: ; preds = %1288
br i1 %1219, label %1291, label %1489
1291: ; preds = %1290
%1292 = icmp sgt i32 %0, 2
%1293 = icmp sgt i32 %2, 0
%1294 = add i32 %12, 2
%1295 = sext i32 %0 to i64
br label %1296
1296: ; preds = %1291, %1340
%1297 = phi i32 [ -1, %1291 ], [ %1343, %1340 ]
%1298 = phi i32 [ %1294, %1291 ], [ %1342, %1340 ]
%1299 = phi i32 [ 1, %1291 ], [ %1341, %1340 ]
br i1 %1292, label %1300, label %1340
1300: ; preds = %1296
%1301 = sext i32 %1297 to i64
br label %1302
1302: ; preds = %1300, %1336
%1303 = phi i64 [ %1301, %1300 ], [ %1306, %1336 ]
%1304 = phi i32 [ %1298, %1300 ], [ %1339, %1336 ]
%1305 = phi i32 [ 2, %1300 ], [ %1337, %1336 ]
%1306 = add nsw i64 %1303, 2
br i1 %1293, label %1307, label %1336
1307: ; preds = %1302
%1308 = sext i32 %1304 to i64
%1309 = add nsw i64 %1303, 1
%1310 = getelementptr inbounds float, float* %9, i64 %1309
%1311 = getelementptr inbounds float, float* %9, i64 %1306
br label %1312
1312: ; preds = %1307, %1312
%1313 = phi i64 [ %1308, %1307 ], [ %1333, %1312 ]
%1314 = phi i32 [ 0, %1307 ], [ %1334, %1312 ]
%1315 = load float, float* %1310
%1316 = add nsw i64 %1313, -1
%1317 = getelementptr inbounds float, float* %7, i64 %1316
%1318 = load float, float* %1317
%1319 = load float, float* %1311
%1320 = getelementptr inbounds float, float* %7, i64 %1313
%1321 = load float, float* %1320
%1322 = fneg float %1319
%1323 = fmul float %1321, %1322
%1324 = tail call float @llvm.fmuladd.f32(float %1315, float %1318, float %1323)
%1325 = getelementptr inbounds float, float* %5, i64 %1316
store float %1324, float* %1325
%1326 = load float, float* %1310
%1327 = load float, float* %1320
%1328 = load float, float* %1311
%1329 = load float, float* %1317
%1330 = fmul float %1328, %1329
%1331 = tail call float @llvm.fmuladd.f32(float %1326, float %1327, float %1330)
%1332 = getelementptr inbounds float, float* %5, i64 %1313
store float %1331, float* %1332
%1333 = add i64 %1313, %1295
%1334 = add nuw nsw i32 %1314, 1
%1335 = icmp eq i32 %1334, %2
br i1 %1335, label %1336, label %1312
1336: ; preds = %1312, %1302
%1337 = add nuw nsw i32 %1305, 2
%1338 = icmp slt i32 %1337, %0
%1339 = add i32 %1304, 2
br i1 %1338, label %1302, label %1340
1340: ; preds = %1336, %1296
%1341 = add nuw nsw i32 %1299, 1
%1342 = add i32 %1298, %12
%1343 = add i32 %1297, %0
%1344 = icmp eq i32 %1341, %1
br i1 %1344, label %1489, label %1296
1345: ; preds = %1288
br i1 %1219, label %1346, label %1489
1346: ; preds = %1345
%1347 = icmp sgt i32 %2, 0
%1348 = icmp sgt i32 %0, 2
%1349 = sext i32 %0 to i64
%1350 = add i32 %0, -3
%1351 = and i32 %1350, -2
%1352 = zext i32 %1351 to i64
%1353 = add nuw nsw i64 %1352, 3
%1354 = getelementptr float, float* %9, i64 1
%1355 = add nuw nsw i64 %1352, 3
%1356 = getelementptr float, float* %9, i64 %1355
%1357 = add i32 %0, -3
%1358 = lshr i32 %1357, 1
%1359 = add nuw i32 %1358, 1
%1360 = zext i32 %1359 to i64
%1361 = icmp ult i32 %1357, 6
%1362 = and i64 %1360, 4294967292
%1363 = shl nuw nsw i64 %1362, 1
%1364 = shl nuw nsw i64 %1362, 1
%1365 = trunc i64 %1362 to i32
%1366 = shl i32 %1365, 1
%1367 = or i32 %1366, 2
%1368 = getelementptr inbounds float, float* %7, i64 -1
%1369 = getelementptr inbounds float, float* %5, i64 -1
%1370 = icmp eq i64 %1362, %1360
br label %1371
1371: ; preds = %1346, %1484
%1372 = phi i32 [ %12, %1346 ], [ %1487, %1484 ]
%1373 = phi i32 [ -1, %1346 ], [ %1486, %1484 ]
%1374 = phi i32 [ 1, %1346 ], [ %1485, %1484 ]
%1375 = sext i32 %1372 to i64
%1376 = add nsw i64 %1375, 1
%1377 = add nsw i64 %1353, %1375
%1378 = sext i32 %1373 to i64
%1379 = getelementptr float, float* %1354, i64 %1378
%1380 = getelementptr float, float* %1356, i64 %1378
%1381 = sext i32 %1373 to i64
br i1 %1347, label %1382, label %1484
1382: ; preds = %1371
%1383 = sext i32 %1372 to i64
%1384 = add nsw i64 %1364, %1381
br label %1385
1385: ; preds = %1382, %1479
%1386 = phi i64 [ 0, %1382 ], [ %1483, %1479 ]
%1387 = phi i64 [ %1383, %1382 ], [ %1480, %1479 ]
%1388 = phi i32 [ 0, %1382 ], [ %1481, %1479 ]
%1389 = mul i64 %1386, %1222
%1390 = add i64 %1376, %1389
%1391 = getelementptr float, float* %5, i64 %1390
%1392 = add i64 %1377, %1389
%1393 = getelementptr float, float* %5, i64 %1392
%1394 = getelementptr float, float* %7, i64 %1390
%1395 = getelementptr float, float* %7, i64 %1392
br i1 %1348, label %1396, label %1479
1396: ; preds = %1385
br i1 %1361, label %1446, label %1397
1397: ; preds = %1396
%1398 = icmp ult float* %1391, %1380
%1399 = icmp ult float* %1379, %1393
%1400 = and i1 %1398, %1399
%1401 = icmp ult float* %1391, %1395
%1402 = icmp ult float* %1394, %1393
%1403 = and i1 %1401, %1402
%1404 = or i1 %1400, %1403
br i1 %1404, label %1446, label %1405
1405: ; preds = %1397
%1406 = add i64 %1387, %1363
br label %1407
1407: ; preds = %1407, %1405
%1408 = phi i64 [ 0, %1405 ], [ %1443, %1407 ]
%1409 = shl i64 %1408, 1
%1410 = add i64 %1387, %1409
%1411 = shl i64 %1408, 1
%1412 = add i64 %1411, %1381
%1413 = add nsw i64 %1410, 2
%1414 = add nsw i64 %1412, 1
%1415 = getelementptr inbounds float, float* %9, i64 %1414
%1416 = bitcast float* %1415 to <8 x float>*
%1417 = load <8 x float>, <8 x float>* %1416
%1418 = shufflevector <8 x float> %1417, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1419 = shufflevector <8 x float> %1417, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1420 = add nsw i64 %1410, 1
%1421 = getelementptr inbounds float, float* %7, i64 %1420
%1422 = bitcast float* %1421 to <8 x float>*
%1423 = load <8 x float>, <8 x float>* %1422
%1424 = shufflevector <8 x float> %1423, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1425 = shufflevector <8 x float> %1423, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1426 = fneg <4 x float> %1419
%1427 = fmul <4 x float> %1425, %1426
%1428 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1418, <4 x float> %1424, <4 x float> %1427)
%1429 = bitcast float* %1415 to <8 x float>*
%1430 = load <8 x float>, <8 x float>* %1429
%1431 = shufflevector <8 x float> %1430, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1432 = shufflevector <8 x float> %1430, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1433 = getelementptr inbounds float, float* %1368, i64 %1413
%1434 = bitcast float* %1433 to <8 x float>*
%1435 = load <8 x float>, <8 x float>* %1434
%1436 = shufflevector <8 x float> %1435, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1437 = shufflevector <8 x float> %1435, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1438 = fmul <4 x float> %1432, %1436
%1439 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %1431, <4 x float> %1437, <4 x float> %1438)
%1440 = getelementptr inbounds float, float* %1369, i64 %1413
%1441 = bitcast float* %1440 to <8 x float>*
%1442 = shufflevector <4 x float> %1428, <4 x float> %1439, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %1442, <8 x float>* %1441
%1443 = add nuw i64 %1408, 4
%1444 = icmp eq i64 %1443, %1362
br i1 %1444, label %1445, label %1407
1445: ; preds = %1407
br i1 %1370, label %1479, label %1446
1446: ; preds = %1397, %1396, %1445
%1447 = phi i64 [ %1387, %1397 ], [ %1387, %1396 ], [ %1406, %1445 ]
%1448 = phi i64 [ %1381, %1397 ], [ %1381, %1396 ], [ %1384, %1445 ]
%1449 = phi i32 [ 2, %1397 ], [ 2, %1396 ], [ %1367, %1445 ]
br label %1450
1450: ; preds = %1446, %1450
%1451 = phi i64 [ %1455, %1450 ], [ %1447, %1446 ]
%1452 = phi i64 [ %1454, %1450 ], [ %1448, %1446 ]
%1453 = phi i32 [ %1477, %1450 ], [ %1449, %1446 ]
%1454 = add nsw i64 %1452, 2
%1455 = add nsw i64 %1451, 2
%1456 = add nsw i64 %1452, 1
%1457 = getelementptr inbounds float, float* %9, i64 %1456
%1458 = load float, float* %1457
%1459 = add nsw i64 %1451, 1
%1460 = getelementptr inbounds float, float* %7, i64 %1459
%1461 = load float, float* %1460
%1462 = getelementptr inbounds float, float* %9, i64 %1454
%1463 = load float, float* %1462
%1464 = getelementptr inbounds float, float* %7, i64 %1455
%1465 = load float, float* %1464
%1466 = fneg float %1463
%1467 = fmul float %1465, %1466
%1468 = tail call float @llvm.fmuladd.f32(float %1458, float %1461, float %1467)
%1469 = getelementptr inbounds float, float* %5, i64 %1459
store float %1468, float* %1469
%1470 = load float, float* %1457
%1471 = load float, float* %1464
%1472 = load float, float* %1462
%1473 = load float, float* %1460
%1474 = fmul float %1472, %1473
%1475 = tail call float @llvm.fmuladd.f32(float %1470, float %1471, float %1474)
%1476 = getelementptr inbounds float, float* %5, i64 %1455
store float %1475, float* %1476
%1477 = add nuw nsw i32 %1453, 2
%1478 = icmp slt i32 %1477, %0
br i1 %1478, label %1450, label %1479
1479: ; preds = %1450, %1445, %1385
%1480 = add i64 %1387, %1349
%1481 = add nuw nsw i32 %1388, 1
%1482 = icmp eq i32 %1481, %2
%1483 = add i64 %1386, 1
br i1 %1482, label %1484, label %1385
1484: ; preds = %1479, %1371
%1485 = add nuw nsw i32 %1374, 1
%1486 = add i32 %1373, %0
%1487 = add i32 %1372, %12
%1488 = icmp eq i32 %1485, %1
br i1 %1488, label %1489, label %1371
1489: ; preds = %1340, %1484, %1218, %1290, %1345, %989
ret void
}