void dradfg(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, ic, ik, is;
  int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10;
  float dc2, ai1, ai2, ar1, ar2, ds2;
  int nbd;
  float dcp, arg, dsp, ar1h, ar2h;
  int idp2, ipp2;
  arg = tpi / (float)ip;
  dcp = cos(arg);
  dsp = sin(arg);
  ipph = (ip + 1) >> 1;
  ipp2 = ip;
  idp2 = ido;
  nbd = (ido - 1) >> 1;
  t0 = l1 * ido;
  t10 = ip * ido;
  if (ido == 1)
    goto L119;
  for (ik = 0; ik < idl1; ik++)
    ch2[ik] = c2[ik];
  t1 = 0;
  for (j = 1; j < ip; j++) {
    t1 += t0;
    t2 = t1;
    for (k = 0; k < l1; k++) {
      ch[t2] = c1[t2];
      t2 += ido;
    }
  }
  is = -ido;
  t1 = 0;
  if (nbd > l1) {
    for (j = 1; j < ip; j++) {
      t1 += t0;
      is += ido;
      t2 = -ido + t1;
      for (k = 0; k < l1; k++) {
        idij = is - 1;
        t2 += ido;
        t3 = t2;
        for (i = 2; i < ido; i += 2) {
          idij += 2;
          t3 += 2;
          ch[t3 - 1] = wa[idij - 1] * c1[t3 - 1] + wa[idij] * c1[t3];
          ch[t3] = wa[idij - 1] * c1[t3] - wa[idij] * c1[t3 - 1];
        }
      }
    }
  } else {
    for (j = 1; j < ip; j++) {
      is += ido;
      idij = is - 1;
      t1 += t0;
      t2 = t1;
      for (i = 2; i < ido; i += 2) {
        idij += 2;
        t2 += 2;
        t3 = t2;
        for (k = 0; k < l1; k++) {
          ch[t3 - 1] = wa[idij - 1] * c1[t3 - 1] + wa[idij] * c1[t3];
          ch[t3] = wa[idij - 1] * c1[t3] - wa[idij] * c1[t3 - 1];
          t3 += ido;
        }
      }
    }
  }
  t1 = 0;
  t2 = ipp2 * t0;
  if (nbd < l1) {
    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 - ido;
        t6 = t4 - ido;
        for (k = 0; k < l1; k++) {
          t5 += ido;
          t6 += ido;
          c1[t5 - 1] = ch[t5 - 1] + ch[t6 - 1];
          c1[t6 - 1] = ch[t5] - ch[t6];
          c1[t5] = ch[t5] + ch[t6];
          c1[t6] = ch[t6 - 1] - ch[t5 - 1];
        }
      }
    }
  } else {
    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;
          c1[t5 - 1] = ch[t5 - 1] + ch[t6 - 1];
          c1[t6 - 1] = ch[t5] - ch[t6];
          c1[t5] = ch[t5] + ch[t6];
          c1[t6] = ch[t6 - 1] - ch[t5 - 1];
        }
        t3 += ido;
        t4 += ido;
      }
    }
  }
L119:
  for (ik = 0; ik < idl1; ik++)
    c2[ik] = ch2[ik];
  t1 = 0;
  t2 = ipp2 * idl1;
  for (j = 1; j < ipph; j++) {
    t1 += t0;
    t2 -= t0;
    t3 = t1 - ido;
    t4 = t2 - ido;
    for (k = 0; k < l1; k++) {
      t3 += ido;
      t4 += ido;
      c1[t3] = ch[t3] + ch[t4];
      c1[t4] = ch[t4] - ch[t3];
    }
  }
  ar1 = 1.f;
  ai1 = 0.f;
  t1 = 0;
  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 = t3;
    t7 = idl1;
    for (ik = 0; ik < idl1; ik++) {
      ch2[t4++] = c2[ik] + ar1 * c2[t7++];
      ch2[t5++] = ai1 * c2[t6++];
    }
    dc2 = ar1;
    ds2 = ai1;
    ar2 = ar1;
    ai2 = ai1;
    t4 = idl1;
    t5 = (ipp2 - 1) * idl1;
    for (j = 2; j < ipph; j++) {
      t4 += idl1;
      t5 -= idl1;
      ar2h = dc2 * ar2 - ds2 * ai2;
      ai2 = dc2 * ai2 + ds2 * ar2;
      ar2 = ar2h;
      t6 = t1;
      t7 = t2;
      t8 = t4;
      t9 = t5;
      for (ik = 0; ik < idl1; ik++) {
        ch2[t6++] += ar2 * c2[t8++];
        ch2[t7++] += ai2 * c2[t9++];
      }
    }
  }
  t1 = 0;
  for (j = 1; j < ipph; j++) {
    t1 += idl1;
    t2 = t1;
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += c2[t2++];
  }
  if (ido < l1)
    goto L132;
  t1 = 0;
  t2 = 0;
  for (k = 0; k < l1; k++) {
    t3 = t1;
    t4 = t2;
    for (i = 0; i < ido; i++)
      cc[t4++] = ch[t3++];
    t1 += ido;
    t2 += t10;
  }
  goto L135;
L132:
  for (i = 0; i < ido; i++) {
    t1 = i;
    t2 = i;
    for (k = 0; k < l1; k++) {
      cc[t2] = ch[t1];
      t1 += ido;
      t2 += t10;
    }
  }
L135:
  t1 = 0;
  t2 = ido << 1;
  t3 = 0;
  t4 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t0;
    t4 -= t0;
    t5 = t1;
    t6 = t3;
    t7 = t4;
    for (k = 0; k < l1; k++) {
      cc[t5 - 1] = ch[t6];
      cc[t5] = ch[t7];
      t5 += t10;
      t6 += ido;
      t7 += ido;
    }
  }
  if (ido == 1)
    return;
  if (nbd < l1)
    goto L141;
  t1 = -ido;
  t3 = 0;
  t4 = 0;
  t5 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t2;
    t4 += t0;
    t5 -= t0;
    t6 = t1;
    t7 = t3;
    t8 = t4;
    t9 = t5;
    for (k = 0; k < l1; k++) {
      for (i = 2; i < ido; i += 2) {
        ic = idp2 - i;
        cc[i + t7 - 1] = ch[i + t8 - 1] + ch[i + t9 - 1];
        cc[ic + t6 - 1] = ch[i + t8 - 1] - ch[i + t9 - 1];
        cc[i + t7] = ch[i + t8] + ch[i + t9];
        cc[ic + t6] = ch[i + t9] - ch[i + t8];
      }
      t6 += t10;
      t7 += t10;
      t8 += ido;
      t9 += ido;
    }
  }
  return;
L141:
  t1 = -ido;
  t3 = 0;
  t4 = 0;
  t5 = ipp2 * t0;
  for (j = 1; j < ipph; j++) {
    t1 += t2;
    t3 += t2;
    t4 += t0;
    t5 -= t0;
    for (i = 2; i < ido; i += 2) {
      t6 = idp2 + t1 - i;
      t7 = i + t3;
      t8 = i + t4;
      t9 = i + t5;
      for (k = 0; k < l1; k++) {
        cc[t7 - 1] = ch[t8 - 1] + ch[t9 - 1];
        cc[t6 - 1] = ch[t8 - 1] - ch[t9 - 1];
        cc[t7] = ch[t8] + ch[t9];
        cc[t6] = ch[t9] - ch[t8];
        t6 += t10;
        t7 += t10;
        t8 += ido;
        t9 += ido;
      }
    }
  }
}


x86 assembly (clang, -O0):
<dradfg>:
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)
movss  0x3ed9(%rip),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    11f2 <dradfg+0xd2>
jmp    18c9 <dradfg+0x7a9>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    122d <dradfg+0x10d>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11f9 <dradfg+0xd9>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12ad <dradfg+0x18d>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    129a <dradfg+0x17a>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%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    125d <dradfg+0x13d>
jmp    129f <dradfg+0x17f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123b <dradfg+0x11b>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    143c <dradfg+0x31c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1437 <dradfg+0x317>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
xor    %eax,%eax
sub    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1424 <dradfg+0x304>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1411 <dradfg+0x2f1>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x54(%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    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%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    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    132d <dradfg+0x20d>
jmp    1416 <dradfg+0x2f6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1302 <dradfg+0x1e2>
jmp    1429 <dradfg+0x309>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d2 <dradfg+0x1b2>
jmp    15a8 <dradfg+0x488>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15a3 <dradfg+0x483>
mov    -0x4(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1590 <dradfg+0x470>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    157d <dradfg+0x45d>
mov    0x28(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x54(%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    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%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    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14a2 <dradfg+0x382>
jmp    1582 <dradfg+0x462>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1477 <dradfg+0x357>
jmp    1595 <dradfg+0x475>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1443 <dradfg+0x323>
jmp    15a8 <dradfg+0x488>
movl   $0x0,-0x4c(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    174d <dradfg+0x62d>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1748 <dradfg+0x628>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1735 <dradfg+0x615>
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1722 <dradfg+0x602>
mov    -0x4(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x4(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x60(%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
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    163c <dradfg+0x51c>
jmp    1727 <dradfg+0x607>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1605 <dradfg+0x4e5>
jmp    173a <dradfg+0x61a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15d2 <dradfg+0x4b2>
jmp    18c4 <dradfg+0x7a4>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18bf <dradfg+0x79f>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18ac <dradfg+0x78c>
mov    -0x54(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    188c <dradfg+0x76c>
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x60(%rbp)
mov    0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x60(%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
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    17a6 <dradfg+0x686>
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1787 <dradfg+0x667>
jmp    18b1 <dradfg+0x791>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1754 <dradfg+0x634>
jmp    18c4 <dradfg+0x7a4>
jmp    18c9 <dradfg+0x7a9>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1904 <dradfg+0x7e4>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    18d0 <dradfg+0x7b0>
movl   $0x0,-0x4c(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    19e5 <dradfg+0x8c5>
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19d2 <dradfg+0x8b2>
mov    -0x4(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1958 <dradfg+0x838>
jmp    19d7 <dradfg+0x8b7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    191f <dradfg+0x7ff>
movss  0x1613(%rip),%xmm0
movss  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1d1c <dradfg+0xbfc>
mov    -0x10(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x50(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x50(%rbp)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b61 <dradfg+0xa41>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x60(%rbp)
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x5c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1acc <dradfg+0x9ac>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0xa8(%rbp),%eax
sub    $0x1,%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1d09 <dradfg+0xbe9>
mov    -0x10(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x88(%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  -0x74(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
movss  -0x88(%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    -0x4c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1cf6 <dradfg+0xbd6>
movss  -0x84(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
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),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x6c(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c59 <dradfg+0xb39>
jmp    1cfb <dradfg+0xbdb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bac <dradfg+0xa8c>
jmp    1d0e <dradfg+0xbee>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a22 <dradfg+0x902>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1da2 <dradfg+0xc82>
mov    -0x10(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d8f <dradfg+0xc6f>
mov    0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x50(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d4c <dradfg+0xc2c>
jmp    1d94 <dradfg+0xc74>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d2a <dradfg+0xc0a>
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1db3 <dradfg+0xc93>
jmp    1e54 <dradfg+0xd34>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1e4f <dradfg+0xd2f>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e2f <dradfg+0xd0f>
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%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    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1de7 <dradfg+0xcc7>
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1dc8 <dradfg+0xca8>
jmp    1ed8 <dradfg+0xdb8>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ed3 <dradfg+0xdb3>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ec0 <dradfg+0xda0>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e7a <dradfg+0xd5a>
jmp    1ec5 <dradfg+0xda5>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e5b <dradfg+0xd3b>
jmp    1ed8 <dradfg+0xdb8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1fc6 <dradfg+0xea6>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x58(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fb3 <dradfg+0xe93>
mov    0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%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 -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x4(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x4(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f45 <dradfg+0xe25>
jmp    1fb8 <dradfg+0xe98>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1f03 <dradfg+0xde3>
cmpl   $0x1,-0x4(%rbp)
jne    1fd5 <dradfg+0xeb5>
jmp    238f <dradfg+0x126f>
mov    -0x8c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1fe9 <dradfg+0xec9>
jmp    21d1 <dradfg+0x10b1>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    21cc <dradfg+0x10ac>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    21b9 <dradfg+0x1099>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2187 <dradfg+0x1067>
mov    -0xa4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2077 <dradfg+0xf57>
mov    -0x70(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x70(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2064 <dradfg+0xf44>
jmp    21be <dradfg+0x109e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2013 <dradfg+0xef3>
jmp    238f <dradfg+0x126f>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    238f <dradfg+0x126f>
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    237c <dradfg+0x125c>
mov    -0xa4(%rbp),%eax
add    -0x4c(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2369 <dradfg+0x1249>
mov    0x18(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x64(%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    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%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 -0x6c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x70(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x4(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x4(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2271 <dradfg+0x1151>
jmp    236e <dradfg+0x124e>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    2234 <dradfg+0x1114>
jmp    2381 <dradfg+0x1261>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    21fb <dradfg+0x10db>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dradfg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,%r13
mov    %r8,0x68(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edx,%r14d
mov    %esi,%ebx
mov    %edi,%ebp
cvtsi2ss %esi,%xmm0
movss  0x2eaf(%rip),%xmm1
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0xd8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
mov    %rbp,0x10(%rsp)
mov    %rbx,0x30(%rsp)
lea    0x1(%rbx),%eax
sar    %eax
mov    %eax,0x54(%rsp)
lea    -0x1(%rbp),%eax
mov    %rax,0x118(%rsp)
sar    %eax
mov    %eax,0xac(%rsp)
mov    %r14,%rax
mov    %r14,0x18(%rsp)
mov    %r14d,%ebx
imul   %ebp,%ebx
mov    %rbx,0x58(%rsp)
cmp    $0x1,%ebp
je     1af6 <dradfg+0x9d6>
mov    0x38(%rsp),%rcx
test   %ecx,%ecx
mov    0x1a8(%rsp),%r8
mov    0x30(%rsp),%rdi
mov    0x1b0(%rsp),%rbx
mov    0x1a0(%rsp),%rdx
jle    1359 <dradfg+0x239>
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     1205 <dradfg+0xe5>
lea    (%rdx,%rax,4),%rcx
cmp    %rbx,%rcx
jbe    127c <dradfg+0x15c>
lea    (%rbx,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    127c <dradfg+0x15c>
xor    %ecx,%ecx
mov    %rcx,%rbp
not    %rbp
add    %rax,%rbp
mov    %rax,%rsi
and    $0x3,%rsi
je     1234 <dradfg+0x114>
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1220 <dradfg+0x100>
cmp    $0x3,%rbp
jb     1359 <dradfg+0x239>
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbx,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm1
movss  %xmm1,0x8(%rbx,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm1
movss  %xmm1,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1240 <dradfg+0x120>
jmp    1359 <dradfg+0x239>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rdi
jae    12a1 <dradfg+0x181>
xor    %edi,%edi
jmp    1308 <dradfg+0x1e8>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rdx,%rdi,4),%xmm1
movups 0x10(%rdx,%rdi,4),%xmm2
movups %xmm1,(%rbx,%rdi,4)
movups %xmm2,0x10(%rbx,%rdi,4)
movups 0x20(%rdx,%rdi,4),%xmm1
movups 0x30(%rdx,%rdi,4),%xmm2
movups %xmm1,0x20(%rbx,%rdi,4)
movups %xmm2,0x30(%rbx,%rdi,4)
movups 0x40(%rdx,%rdi,4),%xmm1
movups 0x50(%rdx,%rdi,4),%xmm2
movups %xmm1,0x40(%rbx,%rdi,4)
movups %xmm2,0x50(%rbx,%rdi,4)
movups 0x60(%rdx,%rdi,4),%xmm1
movups 0x70(%rdx,%rdi,4),%xmm2
movups %xmm1,0x60(%rbx,%rdi,4)
movups %xmm2,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12b0 <dradfg+0x190>
test   %r9,%r9
je     134b <dradfg+0x22b>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rdx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r9
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbp,1),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups %xmm1,-0x10(%rsi,%rbp,1)
movups %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1330 <dradfg+0x210>
cmp    %rax,%rcx
mov    0x30(%rsp),%rdi
jne    1207 <dradfg+0xe7>
cmp    $0x2,%edi
jl     188f <dradfg+0x76f>
mov    0x1b8(%rsp),%rax
movslq 0x10(%rsp),%rdx
mov    0x18(%rsp),%rcx
lea    -0x1(%rcx),%esi
mov    %esi,0x8(%rsp)
mov    %ecx,%esi
and    $0x3,%esi
mov    %esi,(%rsp)
and    $0xfffffffc,%ecx
mov    %ecx,0x48(%rsp)
lea    0x0(,%rdx,4),%rcx
lea    (%rcx,%rcx,2),%r14
lea    (%r8,%r14,1),%r11
add    %r13,%r14
mov    %r8,%rbx
lea    (%r8,%rdx,8),%r15
lea    0x0(,%rdx,8),%r12
add    %r13,%r12
lea    (%r8,%rdx,4),%rdi
lea    0x0(%r13,%rdx,4),%r8
mov    $0x1,%r9d
mov    0x58(%rsp),%rsi
mov    %esi,%ebp
jmp    13e3 <dradfg+0x2c3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9d
add    0x58(%rsp),%ebp
cmp    0x30(%rsp),%r9d
je     149a <dradfg+0x37a>
cmpl   $0x0,0x18(%rsp)
jle    13d0 <dradfg+0x2b0>
mov    %ebp,0x20(%rsp)
movslq %ebp,%rsi
cmpl   $0x3,0x8(%rsp)
jae    1410 <dradfg+0x2f0>
mov    %rsi,%rbx
mov    0x1a8(%rsp),%r10
jmp    1465 <dradfg+0x345>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x48(%rsp),%ebp
mov    0x1a8(%rsp),%r10
nopl   0x0(%rax)
movss  0x0(%r13,%rsi,4),%xmm1
movss  %xmm1,(%r10,%rsi,4)
lea    (%rsi,%rdx,1),%rbx
movss  (%r8,%rsi,4),%xmm1
movss  %xmm1,(%rdi,%rsi,4)
add    %rdx,%rbx
movss  (%r12,%rsi,4),%xmm1
movss  %xmm1,(%r15,%rsi,4)
add    %rdx,%rbx
movss  (%r14,%rsi,4),%xmm1
movss  %xmm1,(%r11,%rsi,4)
add    %rdx,%rbx
mov    %rbx,%rsi
add    $0xfffffffc,%ebp
jne    1420 <dradfg+0x300>
cmpl   $0x0,(%rsp)
mov    0x20(%rsp),%ebp
je     13d0 <dradfg+0x2b0>
shl    $0x2,%rbx
mov    (%rsp),%esi
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rbx,1),%xmm1
movss  %xmm1,(%r10,%rbx,1)
add    %rcx,%rbx
add    $0xffffffff,%esi
jne    1480 <dradfg+0x360>
jmp    13d0 <dradfg+0x2b0>
mov    0xac(%rsp),%edx
cmp    0x18(%rsp),%edx
jle    1796 <dradfg+0x676>
mov    0x30(%rsp),%rdi
cmp    $0x2,%edi
mov    0x1a8(%rsp),%rdx
jl     188f <dradfg+0x76f>
lea    0x4(%rdx),%rsi
mov    0x10(%rsp),%rcx
lea    -0x3(%rcx),%edi
mov    %edi,%ecx
and    $0xfffffffe,%ecx
lea    (%rdx,%rcx,4),%rbp
add    $0xc,%rbp
lea    0x4(%rax),%rbx
mov    %rbx,0xd0(%rsp)
lea    0xc(%rax,%rcx,4),%rbx
mov    %rbx,0x70(%rsp)
lea    0x4(%r13),%rbx
lea    0xc(,%rcx,4),%rcx
add    %r13,%rcx
mov    %edi,0x20(%rsp)
mov    %edi,%r10d
shr    %r10d
add    $0x1,%r10d
mov    %rsi,0x28(%rsp)
cmp    %rcx,%rsi
setb   %cl
mov    %rbp,0x40(%rsp)
mov    %rbx,0xb8(%rsp)
cmp    %rbp,%rbx
setb   %bl
and    %cl,%bl
mov    %bl,0x60(%rsp)
mov    %r10,0xc8(%rsp)
and    $0xfffffffc,%r10d
lea    (%r10,%r10,1),%rcx
mov    %rcx,0x78(%rsp)
lea    (%r10,%r10,1),%ecx
add    $0x2,%ecx
mov    %ecx,0xc0(%rsp)
lea    0x8(%r13),%rcx
mov    %rcx,(%rsp)
lea    0x8(%rdx),%rcx
mov    %rcx,0x8(%rsp)
add    $0x8,%rax
mov    $0x1,%edx
movl   $0xffffffff,0xa8(%rsp)
ff ff ff ff
mov    0x58(%rsp),%rcx
mov    %ecx,0x98(%rsp)
jmp    15c0 <dradfg+0x4a0>
nopw   0x0(%rax,%rax,1)
mov    0x90(%rsp),%edx
add    $0x1,%edx
add    %ecx,0xa8(%rsp)
mov    0x98(%rsp),%ecx
add    0x58(%rsp),%ecx
mov    %ecx,0x98(%rsp)
mov    0x30(%rsp),%rdi
cmp    %edi,%edx
je     188f <dradfg+0x76f>
mov    %edx,0x90(%rsp)
mov    0x18(%rsp),%r9
test   %r9d,%r9d
mov    0x10(%rsp),%rcx
jle    1590 <dradfg+0x470>
movslq 0xa8(%rsp),%r12
mov    0xd0(%rsp),%rdx
lea    (%rdx,%r12,4),%r15
mov    0x70(%rsp),%rdx
lea    (%rdx,%r12,4),%rdx
mov    %rdx,0x48(%rsp)
mov    0x78(%rsp),%rdx
add    %r12,%rdx
mov    %rdx,0xa0(%rsp)
xor    %r8d,%r8d
mov    0x98(%rsp),%r14d
jmp    1630 <dradfg+0x510>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8d
add    %ecx,%r14d
cmp    %r9d,%r8d
je     1590 <dradfg+0x470>
cmp    $0x3,%ecx
jl     1620 <dradfg+0x500>
movslq %r14d,%r11
mov    $0x2,%edi
cmpl   $0x6,0x20(%rsp)
jae    1650 <dradfg+0x530>
mov    %r12,%rbp
jmp    1720 <dradfg+0x600>
nopl   0x0(%rax)
mov    0x28(%rsp),%rdx
lea    (%rdx,%r11,4),%rbx
mov    0x40(%rsp),%rdx
lea    (%rdx,%r11,4),%rsi
cmp    0x48(%rsp),%rbx
setb   %r9b
cmp    %rsi,%r15
setb   %dl
and    %r9b,%dl
or     0x60(%rsp),%dl
je     1687 <dradfg+0x567>
mov    %r12,%rbp
mov    0x18(%rsp),%r9
jmp    1720 <dradfg+0x600>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%r11,4),%rsi
add    0x78(%rsp),%r11
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
movups (%r15,%r9,8),%xmm1
movups 0x10(%r15,%r9,8),%xmm2
movaps %xmm1,%xmm3
shufps $0x88,%xmm2,%xmm3
movups (%rsi,%r9,8),%xmm4
movups 0x10(%rsi,%r9,8),%xmm5
movaps %xmm4,%xmm6
shufps $0x88,%xmm5,%xmm6
shufps $0xdd,%xmm2,%xmm1
shufps $0xdd,%xmm5,%xmm4
movaps %xmm1,%xmm2
mulps  %xmm4,%xmm2
mulps  %xmm3,%xmm4
mulps  %xmm6,%xmm3
addps  %xmm2,%xmm3
mulps  %xmm6,%xmm1
subps  %xmm1,%xmm4
movaps %xmm3,%xmm1
unpcklps %xmm4,%xmm1
unpckhps %xmm4,%xmm3
movups %xmm3,0x10(%rbx,%r9,8)
movups %xmm1,(%rbx,%r9,8)
add    $0x4,%r9
cmp    %r9,%r10
jne    16a0 <dradfg+0x580>
mov    0xa0(%rsp),%rbp
mov    0xc0(%rsp),%edi
cmp    0xc8(%rsp),%r10
mov    0x18(%rsp),%r9
je     1620 <dradfg+0x500>
mov    (%rsp),%rcx
lea    (%rcx,%r11,4),%rsi
mov    0x8(%rsp),%rcx
lea    (%rcx,%r11,4),%rdx
lea    (%rax,%rbp,4),%rbx
mov    %edi,%edi
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  (%rbx,%rbp,4),%xmm1
mulss  (%rsi,%rbp,4),%xmm1
movss  -0x4(%rbx,%rbp,4),%xmm2
mulss  -0x4(%rsi,%rbp,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x4(%rdx,%rbp,4)
movss  -0x4(%rsi,%rbp,4),%xmm1
mulss  (%rbx,%rbp,4),%xmm1
movss  -0x4(%rbx,%rbp,4),%xmm2
mulss  (%rsi,%rbp,4),%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rbp,4)
add    $0x2,%rbp
lea    (%rdi,%rbp,1),%ecx
cmp    0x10(%rsp),%ecx
mov    0x10(%rsp),%rcx
jl     1740 <dradfg+0x620>
jmp    1620 <dradfg+0x500>
mov    0x30(%rsp),%rdi
cmp    $0x2,%edi
mov    0x1a8(%rsp),%rbx
jl     188f <dradfg+0x76f>
mov    0x58(%rsp),%rdx
lea    0x2(%rdx),%r8d
mov    $0x1,%r10d
mov    $0xffffffff,%r9d
jmp    17ec <dradfg+0x6cc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10d
add    0x58(%rsp),%r8d
add    0x10(%rsp),%r9d
mov    0x30(%rsp),%rdi
cmp    %edi,%r10d
je     188f <dradfg+0x76f>
cmpl   $0x3,0x10(%rsp)
jl     17d0 <dradfg+0x6b0>
movslq %r9d,%rsi
mov    $0x2,%r14d
mov    %r8d,%r11d
jmp    1822 <dradfg+0x702>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%r14d
add    $0x2,%r11d
mov    %rdi,%rsi
cmp    0x10(%rsp),%r14d
jge    17d0 <dradfg+0x6b0>
lea    0x2(%rsi),%rdi
cmpl   $0x0,0x18(%rsp)
jle    1810 <dradfg+0x6f0>
movslq %r11d,%rbp
shl    $0x2,%rbp
mov    0x18(%rsp),%rdx
nopl   0x0(%rax)
movss  0x4(%rax,%rsi,4),%xmm1
movss  (%rax,%rdi,4),%xmm2
mulss  0x0(%r13,%rbp,1),%xmm2
mulss  -0x4(%r13,%rbp,1),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,-0x4(%rbx,%rbp,1)
movss  0x4(%rax,%rsi,4),%xmm1
movss  -0x4(%r13,%rbp,1),%xmm2
mulss  (%rax,%rdi,4),%xmm2
mulss  0x0(%r13,%rbp,1),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,(%rbx,%rbp,1)
add    %rcx,%rbp
add    $0xffffffff,%edx
jne    1840 <dradfg+0x720>
jmp    1810 <dradfg+0x6f0>
mov    0xac(%rsp),%eax
cmp    0x18(%rsp),%eax
jge    19ec <dradfg+0x8cc>
cmp    $0x3,%edi
mov    0x10(%rsp),%rcx
jl     1af6 <dradfg+0x9d6>
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%r9d
mov    0x18(%rsp),%rax
imul   %eax,%r9d
add    $0xffffffff,%r9d
imul   %ecx,%r9d
add    $0x2,%r9d
movslq %ecx,%r14
lea    -0x1(%rax),%r10d
imul   %ecx,%r10d
add    $0x2,%r10d
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    %edx,0x20(%rsp)
lea    0x0(,%r14,4),%rdi
mov    $0x1,%r11d
jmp    191a <dradfg+0x7fa>
xchg   %ax,%ax
add    $0x1,%r11d
mov    0x58(%rsp),%rax
sub    %eax,%r9d
add    %eax,%r10d
cmp    0x20(%rsp),%r11d
je     1af6 <dradfg+0x9d6>
cmp    $0x3,%ecx
jl     1900 <dradfg+0x7e0>
mov    $0x2,%ebx
mov    %r10d,%r15d
mov    %r9d,%r12d
jmp    1944 <dradfg+0x824>
nopl   0x0(%rax)
add    $0x2,%ebx
add    $0x2,%r12d
add    $0x2,%r15d
mov    0x10(%rsp),%rcx
cmp    %ecx,%ebx
jge    1900 <dradfg+0x7e0>
cmpl   $0x0,0x18(%rsp)
jle    1930 <dradfg+0x810>
movslq %r15d,%rax
add    %r14,%rax
movslq %r12d,%rdx
add    %r14,%rdx
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
lea    0x0(,%rax,4),%rbp
add    %r13,%rbp
lea    (%rcx,%rdx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
mov    0x18(%rsp),%rax
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rsi,%r8,1),%xmm1
addss  -0x4(%rcx,%r8,1),%xmm1
movss  %xmm1,-0x4(%rbp,%r8,1)
movss  (%rsi,%r8,1),%xmm1
subss  (%rcx,%r8,1),%xmm1
movss  %xmm1,-0x4(%rdx,%r8,1)
movss  (%rsi,%r8,1),%xmm1
addss  (%rcx,%r8,1),%xmm1
movss  %xmm1,0x0(%rbp,%r8,1)
movss  -0x4(%rcx,%r8,1),%xmm1
subss  -0x4(%rsi,%r8,1),%xmm1
movss  %xmm1,(%rdx,%r8,1)
add    %rdi,%r8
add    $0xffffffff,%eax
jne    1990 <dradfg+0x870>
jmp    1930 <dradfg+0x810>
cmp    $0x3,%edi
mov    0x10(%rsp),%rcx
jl     1af6 <dradfg+0x9d6>
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%r11d
mov    0x58(%rsp),%rdx
imul   %edx,%r11d
movslq %ecx,%r12
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
mov    0x1a8(%rsp),%rax
lea    0x8(%rax),%r9
shl    $0x2,%r12
lea    0x8(%r13),%r10
mov    $0x1,%r15d
mov    %edx,%r14d
jmp    1a58 <dradfg+0x938>
nop
add    $0x1,%r15d
mov    0x58(%rsp),%rax
sub    %eax,%r11d
add    %eax,%r14d
cmp    %r8d,%r15d
je     1af6 <dradfg+0x9d6>
cmpl   $0x0,0x18(%rsp)
jle    1a40 <dradfg+0x920>
movslq %r14d,%rax
lea    (%r9,%rax,4),%rbx
lea    (%r10,%rax,4),%rdi
movslq %r11d,%rdx
lea    (%r9,%rdx,4),%rax
lea    (%r10,%rdx,4),%rsi
xor    %edx,%edx
jmp    1a95 <dradfg+0x975>
nopl   0x0(%rax)
add    $0x1,%edx
add    %r12,%rbx
add    %r12,%rdi
add    %r12,%rax
add    %r12,%rsi
cmp    0x18(%rsp),%edx
je     1a40 <dradfg+0x920>
cmp    $0x3,%ecx
jl     1a80 <dradfg+0x960>
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  -0x4(%rbx,%rbp,4),%xmm1
addss  -0x4(%rax,%rbp,4),%xmm1
movss  %xmm1,-0x4(%rdi,%rbp,4)
movss  (%rbx,%rbp,4),%xmm1
subss  (%rax,%rbp,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rbp,4)
movss  (%rbx,%rbp,4),%xmm1
addss  (%rax,%rbp,4),%xmm1
movss  %xmm1,(%rdi,%rbp,4)
movss  -0x4(%rax,%rbp,4),%xmm1
subss  -0x4(%rbx,%rbp,4),%xmm1
movss  %xmm1,(%rsi,%rbp,4)
add    $0x2,%rbp
lea    0x2(%rbp),%ecx
cmp    0x10(%rsp),%ecx
mov    0x10(%rsp),%rcx
jl     1aa0 <dradfg+0x980>
jmp    1a80 <dradfg+0x960>
mov    0x38(%rsp),%r14
test   %r14d,%r14d
mov    0x18(%rsp),%r8
mov    0x1a8(%rsp),%r15
mov    0x30(%rsp),%rdi
mov    0x1b0(%rsp),%r10
mov    0x1a0(%rsp),%r12
jle    1ca9 <dradfg+0xb89>
mov    %r14d,%eax
cmp    $0x8,%r14d
jb     1b49 <dradfg+0xa29>
lea    (%r10,%rax,4),%rcx
cmp    %r12,%rcx
jbe    1bc4 <dradfg+0xaa4>
lea    (%r12,%rax,4),%rcx
cmp    %r10,%rcx
jbe    1bc4 <dradfg+0xaa4>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1b76 <dradfg+0xa56>
nopl   (%rax)
movss  (%r10,%rcx,4),%xmm1
movss  %xmm1,(%r12,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1b60 <dradfg+0xa40>
cmp    $0x3,%rdx
jb     1ca9 <dradfg+0xb89>
movss  (%r10,%rcx,4),%xmm1
movss  %xmm1,(%r12,%rcx,4)
movss  0x4(%r10,%rcx,4),%xmm1
movss  %xmm1,0x4(%r12,%rcx,4)
movss  0x8(%r10,%rcx,4),%xmm1
movss  %xmm1,0x8(%r12,%rcx,4)
movss  0xc(%r10,%rcx,4),%xmm1
movss  %xmm1,0xc(%r12,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1b80 <dradfg+0xa60>
jmp    1ca9 <dradfg+0xb89>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1be7 <dradfg+0xac7>
xor    %edi,%edi
jmp    1c58 <dradfg+0xb38>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
movups (%r10,%rdi,4),%xmm1
movups 0x10(%r10,%rdi,4),%xmm2
movups %xmm1,(%r12,%rdi,4)
movups %xmm2,0x10(%r12,%rdi,4)
movups 0x20(%r10,%rdi,4),%xmm1
movups 0x30(%r10,%rdi,4),%xmm2
movups %xmm1,0x20(%r12,%rdi,4)
movups %xmm2,0x30(%r12,%rdi,4)
movups 0x40(%r10,%rdi,4),%xmm1
movups 0x50(%r10,%rdi,4),%xmm2
movups %xmm1,0x40(%r12,%rdi,4)
movups %xmm2,0x50(%r12,%rdi,4)
movups 0x60(%r10,%rdi,4),%xmm1
movups 0x70(%r10,%rdi,4),%xmm2
movups %xmm1,0x60(%r12,%rdi,4)
movups %xmm2,0x70(%r12,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1bf0 <dradfg+0xad0>
test   %rdx,%rdx
je     1c9b <dradfg+0xb7b>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r10,%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),%xmm1
movups (%rdi,%rbp,1),%xmm2
movups %xmm1,-0x10(%rsi,%rbp,1)
movups %xmm2,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1c80 <dradfg+0xb60>
cmp    %rax,%rcx
mov    0x30(%rsp),%rdi
jne    1b4b <dradfg+0xa2b>
cmp    $0x2,%edi
jle    1e79 <dradfg+0xd59>
movsd  0xd8(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm9
cvtsd2ss %xmm0,%xmm10
mov    %r14d,%ecx
imul   %edi,%ecx
lea    -0x1(%r8),%eax
mov    0x10(%rsp),%rsi
imul   %esi,%eax
movslq %esi,%rbx
mov    %r8d,%edx
not    %edx
imul   %esi,%edx
add    %ecx,%edx
mov    0x54(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%r9d
cmovge %ecx,%r9d
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
mov    %ecx,0x28(%rsp)
lea    (%rbx,%rbx,1),%rdi
lea    0x0(,%rbx,8),%rcx
add    %r13,%rcx
mov    %rcx,0x40(%rsp)
lea    (%r15,%rbx,8),%rcx
mov    %rcx,0x60(%rsp)
mov    $0x1,%esi
mov    %rbx,0x8(%rsp)
mov    %r9d,0x48(%rsp)
jmp    1d45 <dradfg+0xc25>
nopl   (%rax)
add    $0x1,%esi
mov    0x58(%rsp),%rcx
add    %ecx,%eax
sub    %ecx,%edx
cmp    %r9d,%esi
je     1e8a <dradfg+0xd6a>
test   %r8d,%r8d
jle    1d30 <dradfg+0xc10>
movslq %edx,%rcx
movslq %eax,%rbp
cmp    $0x1,%r8d
je     1e3e <dradfg+0xd1e>
lea    (%rbx,%rcx,1),%r9
lea    (%rbx,%rbp,1),%r11
mov    0x40(%rsp),%r10
lea    (%r10,%rcx,4),%rbx
mov    0x60(%rsp),%r14
mov    %rcx,0x20(%rsp)
lea    (%r14,%rcx,4),%rcx
lea    (%r15,%r9,4),%r8
lea    0x0(%r13,%r9,4),%r9
lea    (%r10,%rbp,4),%r10
mov    %rbp,(%rsp)
lea    (%r14,%rbp,4),%rbp
lea    (%r15,%r11,4),%r14
lea    0x0(,%r11,4),%r15
add    %r13,%r15
mov    0x28(%rsp),%r12d
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r14,%r11,4),%xmm2
addss  (%r8,%r11,4),%xmm2
movss  %xmm2,(%r15,%r11,4)
movss  (%r8,%r11,4),%xmm2
subss  (%r14,%r11,4),%xmm2
movss  %xmm2,(%r9,%r11,4)
movss  0x0(%rbp,%r11,4),%xmm2
addss  (%rcx,%r11,4),%xmm2
movss  %xmm2,(%r10,%r11,4)
movss  (%rcx,%r11,4),%xmm2
subss  0x0(%rbp,%r11,4),%xmm2
movss  %xmm2,(%rbx,%r11,4)
add    %rdi,%r11
add    $0xfffffffe,%r12d
jne    1db0 <dradfg+0xc90>
mov    0x20(%rsp),%rcx
add    %r11,%rcx
mov    (%rsp),%rbp
add    %r11,%rbp
mov    0x18(%rsp),%r8
mov    0x1a8(%rsp),%r15
mov    0x38(%rsp),%r14
mov    0x1b0(%rsp),%r10
mov    0x1a0(%rsp),%r12
mov    0x8(%rsp),%rbx
mov    0x48(%rsp),%r9d
test   $0x1,%r8b
je     1d30 <dradfg+0xc10>
add    %rbx,%rbp
add    %rbx,%rcx
movss  (%r15,%rbp,4),%xmm2
addss  (%r15,%rcx,4),%xmm2
movss  %xmm2,0x0(%r13,%rbp,4)
movss  (%r15,%rcx,4),%xmm2
subss  (%r15,%rbp,4),%xmm2
movss  %xmm2,0x0(%r13,%rcx,4)
jmp    1d30 <dradfg+0xc10>
lea    -0x1(%rdi),%eax
mov    %eax,0x70(%rsp)
mov    0x10(%rsp),%rax
jmp    2973 <dradfg+0x1853>
mov    0x30(%rsp),%rdi
lea    -0x1(%rdi),%eax
cmp    $0x3,%edi
mov    %eax,0x70(%rsp)
jl     26e5 <dradfg+0x15c5>
mov    %eax,%edx
imul   %r14d,%edx
movslq %r14d,%r8
movslq %edx,%rbp
lea    -0x2(%rdi),%eax
imul   %r14d,%eax
mov    %eax,0xe8(%rsp)
mov    0x54(%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,0xec(%rsp)
mov    %r14d,%ebx
lea    -0x1(%r14),%edi
lea    (%r8,%rbx,1),%rax
lea    (%r12,%rax,4),%rax
mov    %rax,0x158(%rsp)
lea    0x0(%rbp,%rbx,1),%rax
lea    (%r12,%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,0x148(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x140(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x138(%rsp)
movabs $0x1fffffff8,%rax
or     $0x4,%rax
lea    0x1(%rdi),%rsi
mov    %rsi,0x90(%rsp)
and    %rsi,%rax
mov    %rax,0xb8(%rsp)
movss  0x2094(%rip),%xmm2
movaps 0x2098(%rip),%xmm8
lea    (%r14,%r14,1),%eax
mov    %eax,0xe4(%rsp)
lea    0x4(%r10,%rdi,4),%rax
mov    %rax,0x160(%rsp)
mov    %rdi,0x48(%rsp)
lea    0x4(%r12,%rdi,4),%rax
mov    %rax,0x98(%rsp)
lea    (%r10,%rbx,4),%rax
mov    %rax,0x100(%rsp)
mov    %rbx,0xb0(%rsp)
lea    (%r12,%rbx,4),%rax
mov    %rax,0x110(%rsp)
lea    (%r12,%r8,4),%rax
mov    %rax,0xf8(%rsp)
lea    (%r12,%rbp,4),%rax
mov    %rax,0x108(%rsp)
mov    %rbp,0x80(%rsp)
lea    (%rcx,%rbp,1),%rax
mov    %rax,0x128(%rsp)
mov    %r8,0x88(%rsp)
mov    %rcx,0xf0(%rsp)
lea    (%rcx,%r8,1),%rax
mov    %rax,0x120(%rsp)
lea    0x10(%r10),%rax
mov    %rax,0x130(%rsp)
mov    $0x1,%eax
mov    %r14d,%ecx
jmp    2053 <dradfg+0xf33>
mov    0xd8(%rsp),%eax
add    $0x1,%eax
mov    0xd0(%rsp),%ecx
add    %r14d,%ecx
mov    0xa8(%rsp),%edx
sub    %r14d,%edx
cmp    0xec(%rsp),%eax
mov    0x1a8(%rsp),%r15
je     26ef <dradfg+0x15cf>
mov    %eax,0xd8(%rsp)
mov    %edx,0xa8(%rsp)
movslq %edx,%rax
mov    %rax,(%rsp)
lea    (%r10,%rax,4),%r8
mov    %ecx,0xd0(%rsp)
movslq %ecx,%rax
mov    %rax,0x8(%rsp)
lea    (%r10,%rax,4),%r9
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   %r14d,%r14d
jle    211a <dradfg+0xffa>
cmp    $0x4,%r14d
jae    2400 <dradfg+0x12e0>
mov    (%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x8(%rsp),%rbp
xor    %ebx,%ebx
lea    (%r10,%rax,4),%rax
lea    (%r12,%rdx,4),%rcx
lea    (%r12,%rsi,4),%rdx
lea    (%r10,%rbp,4),%rsi
lea    (%r12,%rbx,4),%rdi
mov    0xb0(%rsp),%rbp
sub    %rbx,%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rbx,4),%xmm3
mulss  %xmm2,%xmm3
addss  (%rdi,%rbx,4),%xmm3
movss  %xmm3,(%rsi,%rbx,4)
movss  (%rcx,%rbx,4),%xmm3
mulss  %xmm4,%xmm3
movss  %xmm3,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    20f0 <dradfg+0xfd0>
cmpl   $0x5,0x30(%rsp)
jb     2020 <dradfg+0xf00>
mov    0x160(%rsp),%rax
mov    0x8(%rsp),%rdx
lea    (%rax,%rdx,4),%rsi
mov    (%rsp),%rcx
lea    (%rax,%rcx,4),%rax
xorps  %xmm8,%xmm4
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
mov    %rax,0x78(%rsp)
cmp    %rax,%r9
setb   %al
mov    %rsi,0x60(%rsp)
cmp    %rsi,%r8
setb   %bl
and    %al,%bl
mov    %bl,0xa0(%rsp)
mov    0xb8(%rsp),%rax
add    %rax,%rdx
mov    %rdx,0xc8(%rsp)
add    %rcx,%rax
mov    %rax,0xc0(%rsp)
mov    $0x2,%r11d
mov    0xe4(%rsp),%r13d
mov    0xe8(%rsp),%eax
movaps %xmm2,%xmm6
jmp    21b5 <dradfg+0x1095>
add    $0x1,%r11d
sub    %r14d,%eax
add    %r14d,%r13d
cmp    0x20(%rsp),%r11d
je     2020 <dradfg+0xf00>
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   %r14d,%r14d
jle    21a0 <dradfg+0x1080>
movslq %eax,%rdi
movslq %r13d,%rbp
xor    %r15d,%r15d
movaps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm7
cmpl   $0x3,0x48(%rsp)
jae    2200 <dradfg+0x10e0>
mov    0x8(%rsp),%rdx
mov    (%rsp),%rbx
jmp    23a0 <dradfg+0x1280>
nopl   0x0(%rax)
lea    (%r12,%rdi,4),%rbx
lea    (%r12,%rbp,4),%rdx
mov    0x98(%rsp),%rcx
mov    %rbp,0x40(%rsp)
lea    (%rcx,%rbp,4),%rsi
mov    %rdi,0x28(%rsp)
lea    (%rcx,%rdi,4),%rdi
cmp    %rsi,%r9
setb   %cl
mov    0x60(%rsp),%rbp
cmp    %rbp,%rdx
setb   %r14b
and    %cl,%r14b
or     0xa0(%rsp),%r14b
cmp    %rdi,%r9
setb   %cl
cmp    %rbp,%rbx
setb   %r15b
cmp    %rsi,%r8
setb   %sil
mov    0x78(%rsp),%rbp
cmp    %rbp,%rdx
setb   %r12b
cmp    %rdi,%r8
setb   %dil
cmp    %rbp,%rbx
setb   %r10b
test   %r14b,%r14b
jne    2367 <dradfg+0x1247>
and    %r15b,%cl
mov    0x38(%rsp),%r14
jne    235c <dradfg+0x123c>
and    %r12b,%sil
mov    0x40(%rsp),%rbp
mov    $0x0,%r15d
jne    233c <dradfg+0x121c>
and    %r10b,%dil
mov    0x1a0(%rsp),%r12
jne    2324 <dradfg+0x1204>
mov    0xb8(%rsp),%rsi
add    %rsi,%rbp
mov    0x28(%rsp),%rdi
add    %rsi,%rdi
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
xor    %ecx,%ecx
mov    0x1b0(%rsp),%r10
nopl   0x0(%rax)
movups (%rdx,%rcx,4),%xmm1
mulps  %xmm3,%xmm1
movups (%r9,%rcx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%r9,%rcx,4)
movups (%rbx,%rcx,4),%xmm0
movups (%r8,%rcx,4),%xmm1
mulps  %xmm7,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    22d0 <dradfg+0x11b0>
mov    0xc8(%rsp),%rdx
mov    0xc0(%rsp),%rbx
mov    %esi,%r15d
cmp    %rsi,0x90(%rsp)
je     21a0 <dradfg+0x1080>
jmp    23a0 <dradfg+0x1280>
mov    0x8(%rsp),%rdx
mov    (%rsp),%rbx
mov    0x1b0(%rsp),%r10
mov    0x28(%rsp),%rdi
jmp    23a0 <dradfg+0x1280>
mov    0x8(%rsp),%rdx
mov    (%rsp),%rbx
mov    0x1b0(%rsp),%r10
mov    0x1a0(%rsp),%r12
mov    0x28(%rsp),%rdi
jmp    23a0 <dradfg+0x1280>
mov    0x8(%rsp),%rdx
mov    (%rsp),%rbx
jmp    2375 <dradfg+0x1255>
mov    0x8(%rsp),%rdx
mov    (%rsp),%rbx
mov    0x38(%rsp),%r14
mov    0x1b0(%rsp),%r10
mov    0x1a0(%rsp),%r12
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%rbp
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rdx,4),%rdx
lea    (%r10,%rbx,4),%rbx
lea    (%r12,%rbp,4),%rsi
lea    (%r12,%rdi,4),%rcx
mov    %r14d,%edi
sub    %r15d,%edi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbp,4),%xmm0
mulss  %xmm6,%xmm0
addss  (%rdx,%rbp,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
movss  (%rcx,%rbp,4),%xmm0
mulss  %xmm7,%xmm0
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%edi
jne    23c0 <dradfg+0x12a0>
jmp    21a0 <dradfg+0x1080>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x100(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%rcx
mov    (%rsp),%rdx
lea    (%rax,%rdx,4),%rbp
cmp    %rbp,%r9
setb   0x28(%rsp)
cmp    %rcx,%r8
setb   %r13b
mov    0x110(%rsp),%rsi
cmp    %rsi,%r9
setb   %al
cmp    %r12,%rcx
seta   0x40(%rsp)
mov    0x158(%rsp),%rbx
cmp    %rbx,%r9
setb   %dl
mov    0xf8(%rsp),%r10
cmp    %rcx,%r10
mov    %r12,%rdi
setb   0x60(%rsp)
mov    0x150(%rsp),%r14
cmp    %r14,%r9
setb   %r15b
mov    0x108(%rsp),%r12
cmp    %rcx,%r12
setb   0x78(%rsp)
cmp    %rsi,%r8
setb   %sil
cmp    %rdi,%rbp
seta   %cl
cmp    %rbx,%r8
setb   %r11b
cmp    %rbp,%r10
setb   %bl
cmp    %r14,%r8
setb   %dil
cmp    %rbp,%r12
setb   0xa0(%rsp)
test   %r13b,0x28(%rsp)
jne    26b0 <dradfg+0x1590>
and    0x40(%rsp),%al
mov    0x1b0(%rsp),%r10
jne    2683 <dradfg+0x1563>
and    0x60(%rsp),%dl
jne    2683 <dradfg+0x1563>
and    0x78(%rsp),%r15b
mov    0x1a0(%rsp),%r12
jne    265e <dradfg+0x153e>
and    %cl,%sil
mov    0x38(%rsp),%r14
jne    20ae <dradfg+0xf8e>
and    %bl,%r11b
jne    20ae <dradfg+0xf8e>
mov    (%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x8(%rsp),%rbp
mov    $0x0,%ebx
and    0xa0(%rsp),%dil
jne    20c9 <dradfg+0xfa9>
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
cmpq   $0x0,0x148(%rsp)
mov    0x108(%rsp),%rdi
je     264c <dradfg+0x152c>
mov    0x130(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rax,%rcx,4),%rdx
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
mov    0x138(%rsp),%rbp
xor    %eax,%eax
mov    0xf8(%rsp),%rcx
movups (%r12,%rax,4),%xmm3
movups (%rcx,%rax,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,-0x10(%rsi,%rax,4)
movups (%rdi,%rax,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,-0x10(%rdx,%rax,4)
movups 0x10(%r12,%rax,4),%xmm3
movups 0x10(%rcx,%rax,4),%xmm6
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movups %xmm6,(%rsi,%rax,4)
movups 0x10(%rdi,%rax,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    2570 <dradfg+0x1450>
testb  $0x1,0x140(%rsp)
01
je     2609 <dradfg+0x14e9>
mov    (%rsp),%rcx
add    %rax,%rcx
mov    0x80(%rsp),%rdx
add    %rax,%rdx
mov    0x88(%rsp),%rsi
add    %rax,%rsi
movups (%r12,%rax,4),%xmm3
add    0x8(%rsp),%rax
movups (%r12,%rsi,4),%xmm6
mulps  %xmm6,%xmm5
addps  %xmm3,%xmm5
movups %xmm5,(%r10,%rax,4)
movups (%r12,%rdx,4),%xmm3
mulps  %xmm4,%xmm3
movups %xmm3,(%r10,%rcx,4)
mov    0xf0(%rsp),%rax
cmp    0xb0(%rsp),%rax
je     211a <dradfg+0xffa>
mov    0xf0(%rsp),%rbx
mov    (%rsp),%rax
add    %rbx,%rax
mov    0x8(%rsp),%rcx
lea    (%rbx,%rcx,1),%rbp
mov    0x128(%rsp),%rdx
mov    0x120(%rsp),%rsi
jmp    20c9 <dradfg+0xfa9>
xor    %eax,%eax
testb  $0x1,0x140(%rsp)
01
jne    25c5 <dradfg+0x14a5>
jmp    2609 <dradfg+0x14e9>
mov    (%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x8(%rsp),%rbp
xor    %ebx,%ebx
mov    0x38(%rsp),%r14
jmp    20c9 <dradfg+0xfa9>
mov    (%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x8(%rsp),%rbp
xor    %ebx,%ebx
mov    0x38(%rsp),%r14
mov    0x1a0(%rsp),%r12
jmp    20c9 <dradfg+0xfa9>
mov    (%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x8(%rsp),%rbp
xor    %ebx,%ebx
mov    0x38(%rsp),%r14
mov    0x1b0(%rsp),%r10
mov    0x1a0(%rsp),%r12
jmp    20c9 <dradfg+0xfa9>
mov    0x10(%rsp),%rax
jmp    2973 <dradfg+0x1853>
mov    0x30(%rsp),%rdi
cmp    $0x3,%edi
jl     2950 <dradfg+0x1830>
mov    0x54(%rsp),%ecx
cmp    $0x3,%ecx
mov    $0x2,%eax
cmovge %ecx,%eax
mov    %r12,%rcx
mov    0xb0(%rsp),%r13
mov    %r13d,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%r9
mov    %r9,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r10,%rdx
movabs $0x3ffffffffffffffc,%r10
ff ff 3f
or     $0x2,%r10
and    %r15,%r10
neg    %r13
lea    0x30(%rcx),%rsi
mov    %rsi,0x20(%rsp)
lea    0x4(%rcx),%r11
mov    %r14,%rcx
lea    0x4(%rdx),%r14
mov    $0x1,%edx
mov    %ecx,%edi
jmp    2782 <dradfg+0x1662>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%edx
mov    0x38(%rsp),%rcx
add    %ecx,%edi
cmp    %eax,%edx
je     295c <dradfg+0x183c>
test   %ecx,%ecx
jle    2770 <dradfg+0x1650>
movslq %edi,%rsi
cmpl   $0x8,0x38(%rsp)
jb     27bc <dradfg+0x169c>
mov    0x110(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
cmp    0x1b0(%rsp),%rcx
jbe    27d4 <dradfg+0x16b4>
mov    0x1a0(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
cmp    0x100(%rsp),%rcx
jae    27d4 <dradfg+0x16b4>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    28c0 <dradfg+0x17a0>
mov    %rcx,%rbx
jmp    28ed <dradfg+0x17cd>
test   %r9,%r9
je     293f <dradfg+0x181f>
mov    0x20(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %r10,%rbp
xor    %ebx,%ebx
mov    0x1b0(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rcx,%rbx,4),%xmm0
movups -0x20(%rcx,%rbx,4),%xmm1
movups (%r8,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r8,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%r8,%rbx,4),%xmm1
movups 0x30(%r8,%rbx,4),%xmm3
movups %xmm2,(%r8,%rbx,4)
movups %xmm0,0x10(%r8,%rbx,4)
movups -0x10(%rcx,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups (%rcx,%rbx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%r8,%rbx,4)
movups %xmm1,0x30(%r8,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    2800 <dradfg+0x16e0>
test   $0x1,%r15b
je     2893 <dradfg+0x1773>
lea    (%rbx,%rsi,1),%rcx
mov    0x1a0(%rsp),%rbp
movups 0x0(%rbp,%rcx,4),%xmm0
movups 0x10(%rbp,%rcx,4),%xmm1
mov    0x1b0(%rsp),%rcx
movups (%rcx,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rcx,%rbx,4)
movups %xmm0,0x10(%rcx,%rbx,4)
cmp    0xb0(%rsp),%r12
je     2770 <dradfg+0x1650>
add    %r12,%rsi
mov    %r12,%rcx
testb  $0x1,0xb0(%rsp)
01
je     27cc <dradfg+0x16ac>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1a0(%rsp),%rbp
movss  0x0(%rbp,%rsi,4),%xmm0
add    $0x1,%rsi
mov    0x1b0(%rsp),%rbp
addss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    %r13,%rcx
je     2770 <dradfg+0x1650>
lea    (%r11,%rsi,4),%rcx
mov    0xb0(%rsp),%rsi
sub    %rbx,%rsi
lea    (%r14,%rbx,4),%rbx
xor    %ebp,%ebp
xchg   %ax,%ax
movss  -0x4(%rcx,%rbp,4),%xmm0
addss  -0x4(%rbx,%rbp,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rbp,4)
movss  (%rcx,%rbp,4),%xmm0
addss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    2910 <dradfg+0x17f0>
jmp    2770 <dradfg+0x1650>
xor    %ebx,%ebx
test   $0x1,%r15b
jne    285d <dradfg+0x173d>
jmp    2893 <dradfg+0x1773>
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rax
jmp    2973 <dradfg+0x1853>
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rax
mov    0x1a8(%rsp),%r15
mov    0x30(%rsp),%rdi
mov    %edi,%ecx
imul   %eax,%ecx
mov    %ecx,0x90(%rsp)
cmp    %r8d,%eax
jge    2ba8 <dradfg+0x1a88>
test   %eax,%eax
jle    2e70 <dradfg+0x1d50>
mov    0x10(%rsp),%r11d
movslq 0x90(%rsp),%r14
mov    0x18(%rsp),%rax
lea    -0x1(%rax),%edx
mov    %edx,0x28(%rsp)
mov    %eax,%edx
and    $0x3,%edx
mov    %edx,0x48(%rsp)
and    $0xfffffffc,%eax
mov    %eax,0x60(%rsp)
mov    %r14,%r8
shl    $0x4,%r8
lea    (%r14,%r14,2),%rax
mov    0x68(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %rax,0x78(%rsp)
lea    (%rdx,%r14,8),%rax
mov    %rax,0xa0(%rsp)
lea    (%rdx,%r14,4),%rax
mov    %rax,0x98(%rsp)
mov    %r11,%r9
shl    $0x4,%r9
lea    (%r11,%r11,2),%rdx
lea    (%r15,%rdx,4),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%r15,%r11,8),%rdx
mov    %rdx,0xc8(%rsp)
lea    (%r15,%r11,4),%rdx
mov    %rdx,0xc0(%rsp)
lea    0x0(,%r14,4),%rbx
lea    0x0(,%r11,4),%rax
xor    %edi,%edi
xor    %r10d,%r10d
mov    %rbx,0x40(%rsp)
mov    %rax,0x38(%rsp)
mov    %r9,(%rsp)
jmp    2a51 <dradfg+0x1931>
xchg   %ax,%ax
add    $0x1,%r10
add    $0x4,%rdi
cmp    %r11,%r10
je     2e70 <dradfg+0x1d50>
cmpl   $0x0,0x18(%rsp)
jle    2a40 <dradfg+0x1920>
mov    %r10,%rdx
mov    %r10,0x8(%rsp)
mov    %r10,%r13
cmpl   $0x3,0x28(%rsp)
mov    %r11,%rcx
mov    %r8,%rax
jb     2b46 <dradfg+0x1a26>
mov    0x60(%rsp),%esi
mov    0xc0(%rsp),%r15
mov    0xc8(%rsp),%r11
mov    0xb8(%rsp),%r12
mov    0x1a8(%rsp),%r8
mov    0x98(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x78(%rsp),%rbx
mov    0x68(%rsp),%rbp
mov    0x8(%rsp),%r13
mov    %r13,%rdx
nopw   0x0(%rax,%rax,1)
mov    %esi,0x20(%rsp)
movss  (%r8,%rdi,1),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,1)
add    %rcx,%r13
add    %r14,%rdx
movss  (%r15,%rdi,1),%xmm0
movss  %xmm0,(%r9,%rdi,1)
add    %rcx,%r13
add    %r14,%rdx
movss  (%r11,%rdi,1),%xmm0
movss  %xmm0,(%r10,%rdi,1)
add    %rcx,%r13
add    %r14,%rdx
movss  (%r12,%rdi,1),%xmm0
movss  %xmm0,(%rbx,%rdi,1)
add    %rcx,%r13
add    %r14,%rdx
add    %rax,%rbp
add    %rax,%rbx
add    %rax,%r10
add    %rax,%r9
mov    %rdi,%rsi
mov    %r14,%rdi
mov    %rax,%r14
mov    (%rsp),%rax
add    %rax,%r8
add    %rax,%r12
add    %rax,%r11
add    %rax,%r15
mov    %r14,%rax
mov    %rdi,%r14
mov    %rsi,%rdi
mov    0x20(%rsp),%esi
add    $0xfffffffc,%esi
jne    2ac0 <dradfg+0x19a0>
cmpl   $0x0,0x48(%rsp)
mov    0x1a8(%rsp),%rbp
mov    %rcx,%r11
mov    %rax,%r8
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rax
mov    0x8(%rsp),%r10
je     2a40 <dradfg+0x1920>
mov    0x68(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
lea    0x0(,%r13,4),%rsi
add    %rbp,%rsi
mov    0x48(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi),%xmm0
movss  %xmm0,(%rdx)
add    %rbx,%rdx
add    %rax,%rsi
add    $0xffffffff,%ebp
jne    2b90 <dradfg+0x1a70>
jmp    2a40 <dradfg+0x1920>
test   %r8d,%r8d
jle    2e70 <dradfg+0x1d50>
movslq 0x10(%rsp),%r12
movslq 0x90(%rsp),%rsi
mov    0x118(%rsp),%rax
lea    0x1(%rax),%r13
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x78(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0xa0(%rsp)
and    %rax,%rdx
mov    %rdx,0x98(%rsp)
mov    0x68(%rsp),%rax
lea    0x30(%rax),%rcx
lea    0x0(,%rsi,4),%rdx
mov    %rdx,0x20(%rsp)
lea    0x30(%r15),%rdi
lea    0x0(,%r12,4),%rdx
mov    %rdx,(%rsp)
add    $0xc,%rax
mov    %rax,0x40(%rsp)
lea    0xc(%r15),%rax
mov    %rax,0x38(%rsp)
xor    %r10d,%r10d
xor    %r8d,%r8d
xor    %r9d,%r9d
mov    %r12,0x8(%rsp)
mov    %rsi,0x48(%rsp)
mov    %r13,0x28(%rsp)
jmp    2c7e <dradfg+0x1b5e>
nopl   (%rax)
add    %r12,%r8
add    %rsi,%r10
add    $0x1,%r9d
add    0x20(%rsp),%rcx
add    (%rsp),%rdi
cmp    0x18(%rsp),%r9d
je     2e70 <dradfg+0x1d50>
cmpl   $0x0,0x10(%rsp)
jle    2c60 <dradfg+0x1b40>
xor    %eax,%eax
cmpl   $0x7,0x118(%rsp)
07
jae    2ca0 <dradfg+0x1b80>
mov    %r10,%r11
mov    %r8,%r14
jmp    2d80 <dradfg+0x1c60>
nopl   0x0(%rax)
lea    (%r8,%r13,1),%rdx
mov    0x68(%rsp),%rbp
lea    0x0(%rbp,%r10,4),%rbp
lea    (%r15,%rdx,4),%rdx
cmp    %rdx,%rbp
jae    2cde <dradfg+0x1bbe>
lea    (%r10,%r13,1),%rdx
mov    0x68(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
lea    (%r15,%r8,4),%rbx
mov    %r10,%r11
mov    %r8,%r14
cmp    %rdx,%rbx
jb     2d80 <dradfg+0x1c60>
cmpq   $0x0,0x78(%rsp)
je     2e5b <dradfg+0x1d3b>
mov    0x98(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rdi,%rax,4),%xmm0
movups -0x20(%rdi,%rax,4),%xmm1
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movups -0x10(%rdi,%rax,4),%xmm0
movups (%rdi,%rax,4),%xmm1
movups %xmm0,-0x10(%rcx,%rax,4)
movups %xmm1,(%rcx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    2d00 <dradfg+0x1be0>
testb  $0x1,0xa0(%rsp)
01
je     2d5a <dradfg+0x1c3a>
lea    (%r10,%rax,1),%rdx
add    %r8,%rax
movups (%r15,%rax,4),%xmm0
movups 0x10(%r15,%rax,4),%xmm1
mov    0x68(%rsp),%rax
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
cmp    0x60(%rsp),%r13
je     2c60 <dradfg+0x1b40>
mov    0x60(%rsp),%rax
lea    (%r10,%rax,1),%r11
lea    (%r8,%rax,1),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rbp
mov    %ebp,%edx
sub    %eax,%edx
mov    %eax,%ebx
not    %ebx
add    %ebp,%ebx
and    $0x3,%edx
je     2dec <dradfg+0x1ccc>
mov    0x68(%rsp),%rbp
mov    %r15,%rsi
lea    0x0(,%r11,4),%r15
add    %rbp,%r15
lea    (%rsi,%r14,4),%r12
neg    %edx
xor    %r13d,%r13d
movss  (%r12),%xmm0
movss  %xmm0,(%r15)
add    $0x4,%r15
add    $0xffffffffffffffff,%r13
add    $0x4,%r12
cmp    %r13d,%edx
jne    2db0 <dradfg+0x1c90>
sub    %r13,%r11
sub    %r13,%r14
sub    %r13d,%eax
mov    0x1a8(%rsp),%r15
mov    0x8(%rsp),%r12
mov    0x48(%rsp),%rsi
mov    0x28(%rsp),%r13
cmp    $0x3,%ebx
jb     2c60 <dradfg+0x1b40>
mov    0x40(%rsp),%rdx
lea    (%rdx,%r11,4),%rdx
mov    0x38(%rsp),%rbp
lea    0x0(,%r14,4),%rbx
add    %rbp,%rbx
mov    0x10(%rsp),%rbp
sub    %eax,%ebp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rax,4)
movss  -0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rax,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x4,%rax
cmp    %eax,%ebp
jne    2e20 <dradfg+0x1d00>
jmp    2c60 <dradfg+0x1b40>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    2d3a <dradfg+0x1c1a>
jmp    2d5a <dradfg+0x1c3a>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rcx,1),%eax
mov    %rax,0x20(%rsp)
cmpl   $0x3,0x30(%rsp)
mov    0x18(%rsp),%r8
jl     3021 <dradfg+0x1f01>
mov    0x58(%rsp),%r9
mov    %r9d,%edi
imul   0x70(%rsp),%edi
movslq %ecx,%rdx
movslq 0x90(%rsp),%rsi
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r10d
cmovge %eax,%r10d
mov    %r8d,%eax
and    $0xfffffffe,%eax
mov    %eax,0x38(%rsp)
lea    0x0(,%rsi,8),%rax
mov    %rax,0x60(%rsp)
mov    0x68(%rsp),%rcx
lea    (%rcx,%rsi,4),%rbp
mov    0x10(%rsp),%rcx
mov    %rdx,0x28(%rsp)
lea    (%rdx,%rdx,1),%r15
mov    $0x1,%edx
mov    0x20(%rsp),%rbx
mov    %ebx,%eax
mov    %r9d,%r11d
mov    %r10d,0x40(%rsp)
jmp    2f1a <dradfg+0x1dfa>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edx
mov    0x58(%rsp),%rbx
sub    %ebx,%edi
add    %ebx,%r11d
add    0x20(%rsp),%eax
cmp    %r10d,%edx
je     3021 <dradfg+0x1f01>
test   %r8d,%r8d
jle    2f00 <dradfg+0x1de0>
movslq %r11d,%r12
movslq %edi,%r14
movslq %eax,%rbx
cmp    $0x1,%r8d
je     2fe9 <dradfg+0x1ec9>
mov    %r11d,(%rsp)
mov    %edx,0x8(%rsp)
mov    %eax,0x48(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r12,1),%r10
lea    (%rcx,%r14,1),%r11
mov    0x68(%rsp),%rcx
lea    (%rcx,%rbx,4),%r8
mov    0x1a8(%rsp),%rcx
mov    %r12,%rdx
lea    (%rcx,%r12,4),%r9
lea    (%rcx,%r10,4),%r10
mov    %r14,%rax
lea    (%rcx,%r14,4),%r12
lea    (%rcx,%r11,4),%r13
mov    0x38(%rsp),%r14d
xor    %r11d,%r11d
mov    0x60(%rsp),%rcx
nop
movss  (%r9,%r11,4),%xmm0
movss  %xmm0,-0x4(%r8)
movss  (%r12,%r11,4),%xmm0
movss  %xmm0,(%r8)
movss  (%r10,%r11,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rbx,4)
movss  0x0(%r13,%r11,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    %rsi,%rbx
add    %rsi,%rbx
add    %rcx,%r8
add    %r15,%r11
add    $0xfffffffe,%r14d
jne    2f80 <dradfg+0x1e60>
mov    %rdx,%r12
add    %r11,%r12
mov    %rax,%r14
add    %r11,%r14
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%rcx
mov    0x40(%rsp),%r10d
mov    0x48(%rsp),%eax
mov    0x8(%rsp),%edx
mov    (%rsp),%r11d
test   $0x1,%r8b
je     2f00 <dradfg+0x1de0>
mov    0x1a8(%rsp),%r9
movss  (%r9,%r12,4),%xmm0
mov    0x68(%rsp),%rcx
movss  %xmm0,-0x4(%rcx,%rbx,4)
movss  (%r9,%r14,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
mov    0x10(%rsp),%rcx
jmp    2f00 <dradfg+0x1de0>
cmp    $0x1,%ecx
je     3310 <dradfg+0x21f0>
mov    0xac(%rsp),%eax
cmp    0x18(%rsp),%eax
jge    31af <dradfg+0x208f>
cmpl   $0x3,0x30(%rsp)
jl     3310 <dradfg+0x21f0>
mov    0x58(%rsp),%rax
mov    0x70(%rsp),%ecx
imul   %eax,%ecx
add    $0x2,%ecx
mov    %ecx,0x70(%rsp)
movslq 0x10(%rsp),%rcx
add    $0x2,%eax
mov    %eax,0x8(%rsp)
mov    0x20(%rsp),%rdx
lea    0x2(%rdx),%eax
mov    %eax,0x48(%rsp)
movslq 0x90(%rsp),%rdi
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
mov    %esi,0x40(%rsp)
lea    -0x2(%rdx),%eax
mov    %eax,0x28(%rsp)
shl    $0x2,%rdi
shl    $0x2,%rcx
mov    $0x1,%edx
jmp    30da <dradfg+0x1fba>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsp),%edx
add    $0x1,%edx
mov    0x58(%rsp),%rax
sub    %eax,0x70(%rsp)
add    %eax,0x8(%rsp)
mov    0x20(%rsp),%rax
add    %eax,0x48(%rsp)
add    %eax,0x28(%rsp)
cmp    0x40(%rsp),%edx
je     3310 <dradfg+0x21f0>
mov    %edx,(%rsp)
cmpl   $0x3,0x10(%rsp)
jl     30b0 <dradfg+0x1f90>
mov    $0x2,%ebx
mov    0x28(%rsp),%r12d
mov    0x48(%rsp),%r13d
mov    0x8(%rsp),%r10d
mov    0x70(%rsp),%r15d
jmp    3119 <dradfg+0x1ff9>
nop
add    $0x2,%ebx
add    $0x2,%r15d
add    $0x2,%r10d
add    $0x2,%r13d
add    $0xfffffffe,%r12d
cmp    0x10(%rsp),%ebx
jge    30b0 <dradfg+0x1f90>
cmpl   $0x0,0x18(%rsp)
jle    3100 <dradfg+0x1fe0>
movslq %r12d,%rbp
movslq %r13d,%rsi
movslq %r10d,%rdx
movslq %r15d,%r8
mov    0x18(%rsp),%rax
mov    %eax,%r9d
mov    0x1a8(%rsp),%r11
mov    0x68(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r11,%rdx,4),%xmm0
addss  -0x4(%r11,%r8,4),%xmm0
movss  %xmm0,-0x4(%r14,%rsi,4)
movss  -0x4(%r11,%rdx,4),%xmm0
subss  -0x4(%r11,%r8,4),%xmm0
movss  %xmm0,-0x4(%r14,%rbp,4)
movss  (%r11,%rdx,4),%xmm0
addss  (%r11,%r8,4),%xmm0
movss  %xmm0,(%r14,%rsi,4)
movss  (%r11,%r8,4),%xmm0
subss  (%r11,%rdx,4),%xmm0
movss  %xmm0,(%r14,%rbp,4)
add    %rdi,%r14
add    %rcx,%r11
add    $0xffffffff,%r9d
jne    3150 <dradfg+0x2030>
jmp    3100 <dradfg+0x1fe0>
cmpl   $0x3,0x30(%rsp)
jl     3310 <dradfg+0x21f0>
mov    0x10(%rsp),%rdx
movslq %edx,%rcx
mov    0x58(%rsp),%rsi
mov    0x70(%rsp),%eax
imul   %esi,%eax
mov    %eax,0x70(%rsp)
movslq 0x90(%rsp),%r13
mov    0x54(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r9d
cmovge %eax,%r9d
shl    $0x2,%r13
lea    0x0(,%rcx,4),%r10
mov    0x68(%rsp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,(%rsp)
mov    $0x1,%r12d
mov    %edx,%r11d
mov    0x20(%rsp),%rax
mov    %eax,%r14d
mov    %esi,%r15d
jmp    3244 <dradfg+0x2124>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12d
mov    0x58(%rsp),%rax
sub    %eax,0x70(%rsp)
add    %eax,%r15d
mov    0x20(%rsp),%rax
add    %eax,%r14d
add    %eax,%r11d
cmp    %r9d,%r12d
je     3310 <dradfg+0x21f0>
cmpl   $0x0,0x18(%rsp)
jle    3220 <dradfg+0x2100>
movslq %r11d,%rdx
add    %rcx,%rdx
movslq %r14d,%rax
mov    0x68(%rsp),%rsi
lea    (%rsi,%rax,4),%rbx
movslq 0x70(%rsp),%rax
mov    0x1a8(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
movslq %r15d,%rsi
lea    (%rdi,%rsi,4),%rsi
mov    (%rsp),%rdi
lea    (%rdi,%rdx,4),%r8
xor    %edx,%edx
jmp    32a9 <dradfg+0x2189>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%edx
add    %r13,%rbx
add    %r10,%rax
add    %r10,%rsi
add    %r13,%r8
cmp    0x18(%rsp),%edx
je     3220 <dradfg+0x2100>
cmpl   $0x3,0x10(%rsp)
jl     3290 <dradfg+0x2170>
mov    $0x2,%edi
mov    %r8,%rbp
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rdi,4),%xmm0
addss  -0x4(%rax,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rdi,4)
movss  -0x4(%rsi,%rdi,4),%xmm0
subss  -0x4(%rax,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  (%rsi,%rdi,4),%xmm0
addss  (%rax,%rdi,4),%xmm0
movss  %xmm0,(%rbx,%rdi,4)
movss  (%rax,%rdi,4),%xmm0
subss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x2,%rdi
add    $0xfffffffffffffff8,%rbp
cmp    %rcx,%rdi
jl     32c0 <dradfg+0x21a0>
jmp    3290 <dradfg+0x2170>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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