void passf(int *nac, int ido, int ip, int l1, int idl1, float cc[], float ch[],
           const float wa[], int isign) {
  int idij, idlj, idot, ipph, i, j, k, l, jc, lc, ik, idj, idl, inc, idp;
  float wai, war;
  idot = ido / 2;
  ipph = (ip + 1) / 2;
  idp = ip * ido;
  if (ido >= l1) {
    for (j = 1; j < ipph; j++) {
      jc = ip - j;
      for (k = 0; k < l1; k++) {
        for (i = 0; i < ido; i++) {
          ch[i + (k + j * l1) * ido] =
              cc[i + (j + k * ip) * ido] + cc[i + (jc + k * ip) * ido];
          ch[i + (k + jc * l1) * ido] =
              cc[i + (j + k * ip) * ido] - cc[i + (jc + k * ip) * ido];
        }
      }
    }
    for (k = 0; k < l1; k++)
      for (i = 0; i < ido; i++)
        ch[i + k * ido] = cc[i + k * ip * ido];
  } else {
    for (j = 1; j < ipph; j++) {
      jc = ip - j;
      for (i = 0; i < ido; i++) {
        for (k = 0; k < l1; k++) {
          ch[i + (k + j * l1) * ido] =
              cc[i + (j + k * ip) * ido] + cc[i + (jc + k * ip) * ido];
          ch[i + (k + jc * l1) * ido] =
              cc[i + (j + k * ip) * ido] - cc[i + (jc + k * ip) * ido];
        }
      }
    }
    for (i = 0; i < ido; i++)
      for (k = 0; k < l1; k++)
        ch[i + k * ido] = cc[i + k * ip * ido];
  }
  idl = 2 - ido;
  inc = 0;
  for (l = 1; l < ipph; l++) {
    lc = ip - l;
    idl += ido;
    for (ik = 0; ik < idl1; ik++) {
      cc[ik + l * idl1] = ch[ik] + wa[idl - 2] * ch[ik + idl1];
      cc[ik + lc * idl1] = isign * wa[idl - 1] * ch[ik + (ip - 1) * idl1];
    }
    idlj = idl;
    inc += ido;
    for (j = 2; j < ipph; j++) {
      jc = ip - j;
      idlj += inc;
      if (idlj > idp)
        idlj -= idp;
      war = wa[idlj - 2];
      wai = wa[idlj - 1];
      for (ik = 0; ik < idl1; ik++) {
        cc[ik + l * idl1] += war * ch[ik + j * idl1];
        cc[ik + lc * idl1] += isign * wai * ch[ik + jc * idl1];
      }
    }
  }
  for (j = 1; j < ipph; j++)
    for (ik = 0; ik < idl1; ik++)
      ch[ik] += ch[ik + j * idl1];
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    for (ik = 1; ik < idl1; ik += 2) {
      ch[ik - 1 + j * idl1] = cc[ik - 1 + j * idl1] - cc[ik + jc * idl1];
      ch[ik - 1 + jc * idl1] = cc[ik - 1 + j * idl1] + cc[ik + jc * idl1];
      ch[ik + j * idl1] = cc[ik + j * idl1] + cc[ik - 1 + jc * idl1];
      ch[ik + jc * idl1] = cc[ik + j * idl1] - cc[ik - 1 + jc * idl1];
    }
  }
  *nac = 1;
  if (ido == 2)
    return;
  *nac = 0;
  for (ik = 0; ik < idl1; ik++)
    cc[ik] = ch[ik];
  for (j = 1; j < ip; j++) {
    for (k = 0; k < l1; k++) {
      cc[(k + j * l1) * ido + 0] = ch[(k + j * l1) * ido + 0];
      cc[(k + j * l1) * ido + 1] = ch[(k + j * l1) * ido + 1];
    }
  }
  if (idot <= l1) {
    idij = 0;
    for (j = 1; j < ip; j++) {
      idij += 2;
      for (i = 3; i < ido; i += 2) {
        idij += 2;
        for (k = 0; k < l1; k++) {
          cc[i - 1 + (k + j * l1) * ido] =
              wa[idij - 2] * ch[i - 1 + (k + j * l1) * ido] -
              isign * wa[idij - 1] * ch[i + (k + j * l1) * ido];
          cc[i + (k + j * l1) * ido] =
              wa[idij - 2] * ch[i + (k + j * l1) * ido] +
              isign * wa[idij - 1] * ch[i - 1 + (k + j * l1) * ido];
        }
      }
    }
  } else {
    idj = 2 - ido;
    for (j = 1; j < ip; j++) {
      idj += ido;
      for (k = 0; k < l1; k++) {
        idij = idj;
        for (i = 3; i < ido; i += 2) {
          idij += 2;
          cc[i - 1 + (k + j * l1) * ido] =
              wa[idij - 2] * ch[i - 1 + (k + j * l1) * ido] -
              isign * wa[idij - 1] * ch[i + (k + j * l1) * ido];
          cc[i + (k + j * l1) * ido] =
              wa[idij - 2] * ch[i + (k + j * l1) * ido] +
              isign * wa[idij - 1] * ch[i - 1 + (k + j * l1) * ido];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<passf>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1315 <passf+0x215>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1295 <passf+0x195>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1282 <passf+0x182>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    126f <passf+0x16f>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118f <passf+0x8f>
jmp    1274 <passf+0x174>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    117c <passf+0x7c>
jmp    1287 <passf+0x187>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1160 <passf+0x60>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1310 <passf+0x210>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12fd <passf+0x1fd>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x10(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12af <passf+0x1af>
jmp    1302 <passf+0x202>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    129c <passf+0x19c>
jmp    14d1 <passf+0x3d1>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1451 <passf+0x351>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    143e <passf+0x33e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    142b <passf+0x32b>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    134b <passf+0x24b>
jmp    1430 <passf+0x330>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1338 <passf+0x238>
jmp    1443 <passf+0x343>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    131c <passf+0x21c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14cc <passf+0x3cc>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14b9 <passf+0x3b9>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x10(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    146b <passf+0x36b>
jmp    14be <passf+0x3be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1458 <passf+0x358>
jmp    14d1 <passf+0x3d1>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    170d <passf+0x60d>
mov    -0x10(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15c4 <passf+0x4c4>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl 0x20(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    150f <passf+0x40f>
mov    -0x54(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16fa <passf+0x5fa>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x58(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    160f <passf+0x50f>
mov    -0x5c(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16e7 <passf+0x5e7>
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl 0x20(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1644 <passf+0x544>
jmp    16ec <passf+0x5ec>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15da <passf+0x4da>
jmp    16ff <passf+0x5ff>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14ea <passf+0x3ea>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    177e <passf+0x67e>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    176b <passf+0x66b>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1727 <passf+0x627>
jmp    1770 <passf+0x670>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1714 <passf+0x614>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1900 <passf+0x800>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18ed <passf+0x7ed>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    17a1 <passf+0x6a1>
jmp    18f2 <passf+0x7f2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1785 <passf+0x685>
mov    -0x8(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x2,-0xc(%rbp)
jne    1919 <passf+0x819>
jmp    1dc9 <passf+0xcc9>
mov    -0x8(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    195e <passf+0x85e>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    192a <passf+0x82a>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a21 <passf+0x921>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a0e <passf+0x90e>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1978 <passf+0x878>
jmp    1a13 <passf+0x913>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1965 <passf+0x865>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1bf6 <passf+0xaf6>
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1bf1 <passf+0xaf1>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bde <passf+0xade>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bcb <passf+0xacb>
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a73 <passf+0x973>
jmp    1bd0 <passf+0xad0>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1a57 <passf+0x957>
jmp    1be3 <passf+0xae3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a3b <passf+0x93b>
jmp    1dc9 <passf+0xcc9>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dc4 <passf+0xcc4>
mov    -0xc(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1db1 <passf+0xcb1>
mov    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d9e <passf+0xc9e>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1c3d <passf+0xb3d>
jmp    1da3 <passf+0xca3>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c24 <passf+0xb24>
jmp    1db6 <passf+0xcb6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c08 <passf+0xb08>
jmp    1dc9 <passf+0xcc9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<passf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r8d,-0x60(%rsp)
mov    %rdi,0xe8(%rsp)
lea    0x1(%rdx),%eax
shr    $0x1f,%eax
add    %edx,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,-0x1c(%rsp)
mov    %edx,%eax
imul   %esi,%eax
mov    %rax,-0x68(%rsp)
movslq %esi,%rax
mov    %rax,-0x30(%rsp)
cmp    %ecx,%esi
mov    %r9,-0x58(%rsp)
mov    %ecx,-0x5c(%rsp)
mov    %esi,-0x7c(%rsp)
mov    %rdx,-0x10(%rsp)
jge    12b8 <passf+0x1b8>
cmp    $0x3,%edx
jl     1991 <passf+0x891>
mov    -0x10(%rsp),%rdx
mov    %edx,%eax
movslq %ecx,%rbx
mov    -0x1c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,-0x48(%rsp)
mov    %esi,%ebp
mov    %ecx,%edi
mov    %rdi,-0x18(%rsp)
add    $0xffffffff,%edx
imul   %esi,%edx
mov    %edx,-0x50(%rsp)
lea    -0x1(%rax),%rdi
mov    -0x30(%rsp),%rdx
imul   %rdx,%rbx
imul   %rbx,%rdi
shl    $0x2,%rdi
mov    %rdi,-0x78(%rsp)
shl    $0x2,%rbx
lea    0x0(,%rdx,4),%r8
lea    (%r9,%rdx,4),%rdi
mov    %rdi,-0x40(%rsp)
imul   %rdx,%rax
shl    $0x2,%rax
mov    $0x1,%edi
mov    %rbx,-0x28(%rsp)
mov    %rbx,-0x38(%rsp)
jmp    1210 <passf+0x110>
nopl   (%rax)
mov    -0x70(%rsp),%rdi
add    $0x1,%rdi
mov    -0x7c(%rsp),%esi
sub    %esi,-0x50(%rsp)
mov    -0x28(%rsp),%rdx
sub    %rdx,-0x78(%rsp)
add    %rdx,-0x38(%rsp)
add    %r8,-0x40(%rsp)
cmp    -0x48(%rsp),%rdi
je     1991 <passf+0x891>
mov    %rdi,-0x70(%rsp)
test   %esi,%esi
mov    -0x18(%rsp),%rsi
jle    11e0 <passf+0xe0>
mov    -0x40(%rsp),%r14
mov    -0x38(%rsp),%rdi
mov    -0x78(%rsp),%r11
xor    %r10d,%r10d
jmp    1259 <passf+0x159>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x4,%r11
add    $0x4,%rdi
add    $0x4,%r14
cmp    %rbp,%r10
mov    -0x5c(%rsp),%ecx
je     11e0 <passf+0xe0>
test   %ecx,%ecx
mov    -0x68(%rsp),%rcx
jle    1240 <passf+0x140>
mov    %rsi,%r13
mov    %r14,%rdx
mov    0x1a0(%rsp),%r15
mov    -0x50(%rsp),%ebx
mov    %ebx,%r12d
nopw   0x0(%rax,%rax,1)
movss  (%rdx),%xmm0
movslq %r12d,%r12
lea    (%r10,%r12,1),%rbx
addss  (%r9,%rbx,4),%xmm0
movss  %xmm0,(%r15,%rdi,1)
movss  (%rdx),%xmm0
subss  (%r9,%rbx,4),%xmm0
movss  %xmm0,(%r15,%r11,1)
add    %ecx,%r12d
add    %r8,%r15
add    %rax,%rdx
add    $0xffffffffffffffff,%r13
jne    1280 <passf+0x180>
jmp    1240 <passf+0x140>
mov    %ecx,%r12d
mov    %esi,%ebp
cmp    $0x3,%edx
mov    %r12,-0x8(%rsp)
jl     1a6a <passf+0x96a>
mov    -0x10(%rsp),%r8
mov    %r8d,%r10d
movslq %ecx,%rbx
mov    -0x1c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%eax
cmovge %edx,%eax
mov    %rax,0x140(%rsp)
mov    %rbx,0x128(%rsp)
mov    -0x30(%rsp),%rdx
imul   %rdx,%rbx
lea    (%rbx,%rbp,1),%rax
mov    %rax,0x118(%rsp)
lea    -0x1(%r10),%r14
imul   %rbx,%r14
mov    %rdx,%r11
mov    %r10,0x30(%rsp)
imul   %r10,%r11
add    $0xffffffff,%r8d
imul   %esi,%r8d
mov    %edx,%eax
neg    %eax
mov    %rax,0x100(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,0x60(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x50(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x150(%rsp)
lea    0x0(,%rbx,4),%rax
mov    %rax,0x138(%rsp)
neg    %rax
mov    %rax,0x130(%rsp)
lea    (%r14,%rbp,1),%rax
mov    %rax,0xf8(%rsp)
lea    (%rdx,%rbp,1),%rax
mov    %rax,0xf0(%rsp)
lea    (%r9,%rbp,4),%rax
mov    %rax,0x68(%rsp)
lea    0x10(%r9,%rdx,4),%rax
mov    %rax,0xe0(%rsp)
lea    0x0(,%rdx,4),%rax
mov    %r11,0x70(%rsp)
lea    0x0(,%r11,4),%r10
mov    %rax,%r11
lea    0x10(%r9),%rax
mov    %rax,0x148(%rsp)
mov    0x1a0(%rsp),%rax
lea    0x10(%rax,%rbx,4),%rdi
mov    %rdi,0xd8(%rsp)
lea    0x10(%rax,%r14,4),%rdi
mov    %rdi,0xd0(%rsp)
mov    %r14,0x110(%rsp)
lea    (%rax,%r14,4),%rdi
mov    %rdi,0xc8(%rsp)
mov    %r10,%r14
mov    %rbx,0x120(%rsp)
lea    (%rax,%rbx,4),%rax
mov    %rax,0xc0(%rsp)
lea    (%r9,%rdx,4),%rax
mov    %rax,0xb8(%rsp)
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
mov    %r8,0x108(%rsp)
mov    %r8d,%eax
mov    %r8d,0x2c(%rsp)
mov    %r11,(%rsp)
mov    %r10,0x10(%rsp)
jmp    14cd <passf+0x3cd>
nopl   0x0(%rax)
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,0xb0(%rsp)
add    %r11,0xe0(%rsp)
sub    %esi,0x2c(%rsp)
mov    0x138(%rsp),%rax
add    %rax,0xd8(%rsp)
mov    0x130(%rsp),%rcx
add    %rcx,0xd0(%rsp)
add    %rcx,0xc8(%rsp)
add    %rax,0xc0(%rsp)
add    %r11,0xb8(%rsp)
mov    %rdx,0x8(%rsp)
cmp    0x140(%rsp),%rdx
mov    -0x5c(%rsp),%ecx
je     1a6a <passf+0x96a>
test   %ecx,%ecx
jle    1460 <passf+0x360>
mov    0x120(%rsp),%rcx
mov    %rcx,%rax
mov    0xb0(%rsp),%rdx
imul   %rdx,%rax
add    %rax,%rcx
mov    %rcx,0x90(%rsp)
mov    0x118(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0x88(%rsp)
mov    0x110(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x80(%rsp)
mov    0xf8(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x40(%rsp)
mov    %rdx,%rdi
mov    -0x30(%rsp),%rax
imul   %rax,%rdi
mov    0xf0(%rsp),%rcx
add    %rdi,%rcx
mov    %rcx,0x38(%rsp)
add    %rax,%rdi
mov    %rdi,0x78(%rsp)
imul   0x100(%rsp),%rdx
add    0x108(%rsp),%rdx
mov    %rdx,0x18(%rsp)
mov    0x30(%rsp),%rdx
mov    0x8(%rsp),%rax
sub    %rax,%rdx
mov    %rax,%rcx
mov    0x128(%rsp),%rax
imul   %rax,%rcx
mov    %rcx,0x160(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x48(%rsp)
imul   %rax,%rdx
mov    %rdx,0x158(%rsp)
mov    0xb8(%rsp),%r8
mov    0xc0(%rsp),%r15
mov    0xc8(%rsp),%r13
mov    0xd0(%rsp),%r10
mov    0xd8(%rsp),%rcx
mov    0x2c(%rsp),%eax
mov    %eax,-0x50(%rsp)
mov    0xe0(%rsp),%rdi
xor    %eax,%eax
jmp    160b <passf+0x50b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r14,%rdi
mov    -0x50(%rsp),%edx
add    -0x68(%rsp),%edx
mov    %edx,-0x50(%rsp)
add    %r11,%rcx
add    %r11,%r10
add    %r11,%r13
add    %r11,%r15
add    %r14,%r8
cmp    %r12,%rax
je     1460 <passf+0x360>
test   %esi,%esi
jle    15e0 <passf+0x4e0>
movslq -0x50(%rsp),%rbx
cmp    $0x4,%esi
jae    1620 <passf+0x520>
xor    %edx,%edx
jmp    1950 <passf+0x850>
mov    %rbx,-0x78(%rsp)
mov    %rax,%rdx
imul   -0x30(%rsp),%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rdx,1),%r14
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,1),%r11
mov    0x80(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,-0x70(%rsp)
add    0x40(%rsp),%rdx
mov    0x70(%rsp),%rbx
imul   %rax,%rbx
mov    0x78(%rsp),%rsi
add    %rbx,%rsi
mov    %rsi,-0x40(%rsp)
add    0x38(%rsp),%rbx
mov    %eax,%r12d
imul   -0x68(%rsp),%r12d
add    0x18(%rsp),%r12d
mov    0x1a0(%rsp),%rsi
lea    (%rsi,%r14,4),%r14
lea    (%rsi,%r11,4),%rsi
mov    %rsi,0x20(%rsp)
mov    -0x70(%rsp),%rsi
mov    0x1a0(%rsp),%r11
lea    (%r11,%rsi,4),%rsi
mov    %rsi,-0x48(%rsp)
mov    0x1a0(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    %rdx,-0x28(%rsp)
mov    -0x40(%rsp),%rsi
lea    (%r9,%rsi,4),%rsi
mov    %rsi,-0x70(%rsp)
lea    (%r9,%rbx,4),%rsi
mov    %rsi,0xa8(%rsp)
movslq %r12d,%r12
mov    0x68(%rsp),%rbx
lea    (%rbx,%r12,4),%r11
mov    %r11,-0x18(%rsp)
cmp    %rdx,%r14
setb   -0x40(%rsp)
mov    -0x48(%rsp),%rbx
mov    0x20(%rsp),%rsi
cmp    %rsi,%rbx
setb   -0x38(%rsp)
mov    0xa8(%rsp),%rdx
cmp    %rdx,%r14
setb   0xa0(%rsp)
cmp    %rsi,-0x70(%rsp)
setb   0x98(%rsp)
cmp    %r11,%r14
lea    (%r9,%r12,4),%r12
setb   %r14b
cmp    %rsi,%r12
setb   0x20(%rsp)
cmp    %rdx,%rbx
mov    %rbx,%rsi
setb   %bl
mov    -0x28(%rsp),%r9
cmp    %r9,-0x70(%rsp)
setb   -0x70(%rsp)
cmp    -0x18(%rsp),%rsi
setb   %sil
cmp    %r9,%r12
setb   %r11b
mov    -0x38(%rsp),%dl
test   %dl,-0x40(%rsp)
jne    1921 <passf+0x821>
mov    0x98(%rsp),%dl
and    %dl,0xa0(%rsp)
jne    1921 <passf+0x821>
and    0x20(%rsp),%r14b
jne    1921 <passf+0x821>
and    -0x70(%rsp),%bl
mov    -0x58(%rsp),%r9
mov    -0x8(%rsp),%r12
mov    0x10(%rsp),%r14
jne    193c <passf+0x83c>
mov    $0x0,%edx
and    %r11b,%sil
mov    -0x7c(%rsp),%esi
mov    (%rsp),%r11
mov    -0x78(%rsp),%rbx
jne    1950 <passf+0x850>
cmpq   $0x0,0x58(%rsp)
je     1912 <passf+0x812>
mov    0x148(%rsp),%rdx
lea    (%rdx,%rbx,4),%r11
mov    0x150(%rsp),%r14
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rdx,4),%xmm0
movups -0x10(%r11,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,-0x10(%rcx,%rdx,4)
movups -0x10(%rdi,%rdx,4),%xmm0
movups -0x10(%r11,%rdx,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,-0x10(%r10,%rdx,4)
movups (%rdi,%rdx,4),%xmm0
movups (%r11,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rcx,%rdx,4)
movups (%rdi,%rdx,4),%xmm0
movups (%r11,%rdx,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%r10,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r14
jne    17f0 <passf+0x6f0>
testb  $0x1,0x50(%rsp)
je     18f1 <passf+0x7f1>
mov    %eax,%r9d
imul   -0x10(%rsp),%r9d
mov    %rax,%r11
imul   0x30(%rsp),%r11
add    0x48(%rsp),%r9d
add    0x8(%rsp),%r11
imul   %esi,%r9d
mov    0x160(%rsp),%rsi
add    %rax,%rsi
mov    -0x30(%rsp),%r12
imul   %r12,%r11
imul   %r12,%rsi
movslq %r9d,%r9
add    %rdx,%r11
mov    -0x58(%rsp),%rbx
movups (%rbx,%r11,4),%xmm0
add    %rdx,%r9
mov    -0x58(%rsp),%rbx
movups (%rbx,%r9,4),%xmm1
addps  %xmm0,%xmm1
add    %rdx,%rsi
mov    0x1a0(%rsp),%r14
movups %xmm1,(%r14,%rsi,4)
mov    -0x7c(%rsp),%esi
mov    -0x58(%rsp),%rbx
movups (%rbx,%r11,4),%xmm0
mov    -0x58(%rsp),%rbx
movups (%rbx,%r9,4),%xmm1
mov    -0x58(%rsp),%r9
mov    0x158(%rsp),%rbx
add    %rax,%rbx
imul   %r12,%rbx
mov    -0x8(%rsp),%r12
add    %rdx,%rbx
subps  %xmm1,%xmm0
movups %xmm0,(%r14,%rbx,4)
mov    0x60(%rsp),%rbx
mov    %rbx,%rdx
cmp    %rbp,%rbx
mov    (%rsp),%r11
mov    0x10(%rsp),%r14
mov    -0x78(%rsp),%rbx
je     15e0 <passf+0x4e0>
jmp    1950 <passf+0x850>
xor    %edx,%edx
testb  $0x1,0x50(%rsp)
jne    184d <passf+0x74d>
jmp    18f1 <passf+0x7f1>
xor    %edx,%edx
mov    -0x58(%rsp),%r9
mov    -0x7c(%rsp),%esi
mov    -0x8(%rsp),%r12
mov    (%rsp),%r11
mov    0x10(%rsp),%r14
jmp    1946 <passf+0x846>
xor    %edx,%edx
mov    -0x7c(%rsp),%esi
mov    (%rsp),%r11
mov    -0x78(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rbx,4),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r8,%rdx,4),%xmm0
addss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,(%r15,%rdx,4)
movss  (%r8,%rdx,4),%xmm0
subss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1960 <passf+0x860>
jmp    15e0 <passf+0x4e0>
test   %esi,%esi
jle    1c9c <passf+0xb9c>
mov    -0x7c(%rsp),%r12d
mov    %ecx,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
mov    -0x68(%rsp),%rax
lea    (%rax,%rax,1),%r14d
lea    0x0(,%r12,8),%r15
xor    %ebp,%ebp
mov    0x1a0(%rsp),%r10
jmp    19e1 <passf+0x8e1>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
add    $0x4,%r10
cmp    %r12,%rbp
je     1c9c <passf+0xb9c>
test   %ecx,%ecx
jle    19d0 <passf+0x8d0>
cmp    $0x1,%ecx
jne    19f0 <passf+0x8f0>
xor    %edi,%edi
jmp    1a35 <passf+0x935>
xchg   %ax,%ax
xor    %edx,%edx
mov    %r10,%rsi
xor    %edi,%edi
mov    -0x68(%rsp),%rax
nopl   0x0(%rax)
movslq %edx,%rdx
lea    (%rdx,%rbp,1),%rbx
movss  (%r9,%rbx,4),%xmm0
movss  %xmm0,(%rsi)
lea    (%rax,%rdx,1),%ebx
movslq %ebx,%rbx
add    %rbp,%rbx
movss  (%r9,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%r12,4)
add    $0x2,%rdi
add    %r14d,%edx
add    %r15,%rsi
cmp    %rdi,%r11
jne    1a00 <passf+0x900>
test   $0x1,%r8b
je     19d0 <passf+0x8d0>
mov    -0x68(%rsp),%rax
mov    %eax,%edx
imul   %edi,%edx
movslq %edx,%rdx
add    %rbp,%rdx
movss  (%r9,%rdx,4),%xmm0
imul   %r12,%rdi
add    %rbp,%rdi
mov    0x1a0(%rsp),%rdx
movss  %xmm0,(%rdx,%rdi,4)
jmp    19d0 <passf+0x8d0>
test   %ecx,%ecx
mov    -0x30(%rsp),%r13
jle    1c9c <passf+0xb9c>
lea    (%r9,%rbp,4),%rax
mov    %rax,-0x50(%rsp)
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x78(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x28(%rsp)
mov    %ebp,%r12d
and    $0x3,%r12d
lea    0x30(%r9),%rax
mov    %rax,-0x48(%rsp)
mov    0x1a0(%rsp),%r14
lea    0x30(%r14),%rdx
lea    0x0(,%r13,4),%r10
lea    0xc(%r9),%rax
mov    %rax,-0x70(%rsp)
xor    %esi,%esi
xor    %r8d,%r8d
jmp    1b09 <passf+0xa09>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
add    -0x68(%rsp),%esi
add    %r10,%rdx
add    %r10,%r14
cmp    -0x8(%rsp),%r8
je     1c9c <passf+0xb9c>
cmpl   $0x0,-0x7c(%rsp)
jle    1af0 <passf+0x9f0>
movslq %esi,%r15
cmpl   $0x8,-0x7c(%rsp)
jb     1b5f <passf+0xa5f>
mov    %r8,%r11
imul   %r13,%r11
mov    -0x68(%rsp),%rax
imul   %r8d,%eax
mov    0x1a0(%rsp),%rbx
lea    (%rbx,%r11,4),%rcx
cltq
mov    -0x50(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
cmp    %rdi,%rcx
jae    1bf0 <passf+0xaf0>
lea    (%r11,%rbp,1),%rcx
lea    (%rbx,%rcx,4),%rcx
lea    (%r9,%rax,4),%rax
cmp    %rcx,%rax
jae    1bf0 <passf+0xaf0>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %rbp,%rcx
test   %r12,%r12
je     1b95 <passf+0xa95>
lea    (%r9,%r15,4),%rbx
mov    %r12,%rax
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
jne    1b80 <passf+0xa80>
cmp    $0x3,%rcx
jb     1af0 <passf+0x9f0>
mov    -0x70(%rsp),%rax
lea    (%rax,%r15,4),%rcx
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rcx,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movss  -0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%r14,%rdi,4)
movss  -0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x8(%r14,%rdi,4)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,0xc(%r14,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1bb0 <passf+0xab0>
jmp    1af0 <passf+0x9f0>
cmpq   $0x0,-0x40(%rsp)
je     1c91 <passf+0xb91>
mov    -0x48(%rsp),%rax
lea    (%rax,%r15,4),%rcx
mov    -0x28(%rsp),%r13
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x30(%rcx,%rdi,4),%xmm0
movups -0x20(%rcx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rdx,%rdi,4)
movups %xmm1,-0x20(%rdx,%rdi,4)
movups -0x10(%rcx,%rdi,4),%xmm0
movups (%rcx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,4)
movups %xmm1,(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%r13
jne    1c10 <passf+0xb10>
testb  $0x1,-0x38(%rsp)
je     1c76 <passf+0xb76>
mov    -0x68(%rsp),%rax
imul   %r8d,%eax
cltq
add    %rdi,%rax
movups (%r9,%rax,4),%xmm0
movups 0x10(%r9,%rax,4),%xmm1
add    %rdi,%r11
mov    0x1a0(%rsp),%rax
movups %xmm0,(%rax,%r11,4)
movups %xmm1,0x10(%rax,%r11,4)
mov    -0x78(%rsp),%rax
mov    %rax,%rdi
cmp    %rbp,%rax
mov    -0x30(%rsp),%r13
je     1af0 <passf+0x9f0>
jmp    1b61 <passf+0xa61>
xor    %edi,%edi
testb  $0x1,-0x38(%rsp)
jne    1c47 <passf+0xb47>
jmp    1c76 <passf+0xb76>
mov    0x1b0(%rsp),%r14d
mov    0x1a8(%rsp),%rbx
mov    -0x10(%rsp),%r15
cmp    $0x3,%r15d
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
jl     2471 <passf+0x1371>
mov    $0x2,%edi
mov    $0x2,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
sub    %r10d,%edx
lea    -0x1(%r15),%eax
mov    -0x60(%rsp),%r11d
imul   %r11d,%eax
movslq %r11d,%r12
movslq %eax,%r8
mov    %r15d,%r14d
mov    -0x1c(%rsp),%esi
cmp    $0x4,%esi
mov    $0x3,%eax
cmovge %esi,%eax
mov    %rax,-0x78(%rsp)
movslq %edx,%rbp
cmp    $0x3,%esi
cmovge %esi,%edi
mov    %rdi,0x70(%rsp)
mov    %r12d,%edi
lea    (%r12,%rdi,1),%rdx
mov    %rdx,0x8(%rsp)
lea    -0x1(%r14),%rax
imul   %r12,%rax
lea    (%rax,%rdi,1),%rdx
mov    %rdx,0x58(%rsp)
lea    (%r12,%r12,1),%rdx
mov    %rdx,(%rsp)
mov    %r14,0x48(%rsp)
add    $0xfffffffffffffffe,%r14
imul   %r12,%r14
mov    %edi,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x80(%rsp)
lea    0x0(,%r12,4),%rdx
mov    %rdx,-0x18(%rsp)
neg    %rdx
mov    %rdx,-0x50(%rsp)
lea    (%rcx,%r8,4),%rsi
lea    (%rdi,%r12,2),%rdx
mov    %rdx,0x90(%rsp)
lea    (%r14,%rdi,1),%rdx
mov    %rdx,0x88(%rsp)
mov    %rax,0x60(%rsp)
lea    (%r9,%rax,4),%r13
lea    (%r9,%r12,4),%r8
lea    (%rcx,%r12,4),%rax
mov    %rax,0x18(%rsp)
lea    (%rcx,%r12,8),%rax
mov    %rax,0x50(%rsp)
mov    %r14,-0x8(%rsp)
lea    (%rcx,%r14,4),%rax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    $0x1,%eax
movl   $0x0,-0x70(%rsp)
mov    %r12,-0x48(%rsp)
mov    %rsi,0x68(%rsp)
jmp    1e1e <passf+0xd1e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x78(%rsp),%rax
add    $0x1,%rax
addq   $0x1,0x38(%rsp)
add    -0x50(%rsp),%r13
add    %rbp,%r8
cmp    0x70(%rsp),%rax
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
mov    -0x10(%rsp),%r15
mov    0x40(%rsp),%rbp
mov    0x68(%rsp),%rsi
je     215a <passf+0x105a>
mov    %rax,0x78(%rsp)
add    -0x30(%rsp),%rbp
test   %r11d,%r11d
mov    0x18(%rsp),%rdx
jle    1e75 <passf+0xd75>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x8(%rbx,%rbp,4),%xmm1
mulss  (%rdx,%rax,4),%xmm1
addss  (%rcx,%rax,4),%xmm1
movss  %xmm1,(%r8,%rax,4)
movss  -0x4(%rbx,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
mulss  (%rsi,%rax,4),%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1e40 <passf+0xd40>
mov    %rbp,0x40(%rsp)
add    %r10d,-0x70(%rsp)
cmp    $0x5,%r15d
mov    -0x68(%rsp),%rcx
mov    -0x18(%rsp),%rbp
jb     1de0 <passf+0xce0>
mov    0x38(%rsp),%rax
imul   %r12,%rax
lea    (%rax,%r12,1),%r10
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,1),%r11
mov    0x60(%rsp),%rsi
sub    %rax,%rsi
mov    0x58(%rsp),%rdx
sub    %rax,%rdx
lea    (%r9,%r10,4),%rax
lea    (%r9,%r11,4),%r10
lea    (%r9,%rsi,4),%rsi
mov    -0x60(%rsp),%r11d
lea    (%r9,%rdx,4),%rdx
mov    %rax,0xa8(%rsp)
mov    %rdx,0x98(%rsp)
cmp    %rdx,%rax
setb   %al
mov    %r10,0x20(%rsp)
mov    %rsi,0xa0(%rsp)
cmp    %r10,%rsi
setb   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
mov    $0x2,%r14d
mov    0x30(%rsp),%rsi
mov    0x50(%rsp),%rdx
xor    %r15d,%r15d
mov    0x40(%rsp),%rax
mov    %eax,%r10d
jmp    1f3b <passf+0xe3b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x1,%r15
add    %rbp,%rdx
add    -0x50(%rsp),%rsi
cmp    -0x78(%rsp),%r14
je     1de0 <passf+0xce0>
add    -0x70(%rsp),%r10d
cmp    %ecx,%r10d
mov    $0x0,%eax
cmovg  %ecx,%eax
sub    %eax,%r10d
test   %r11d,%r11d
jle    1f20 <passf+0xe20>
movslq %r10d,%rax
movss  -0x8(%rbx,%rax,4),%xmm1
movss  -0x4(%rbx,%rax,4),%xmm2
mulss  %xmm0,%xmm2
cmp    $0x4,%r11d
jae    1fb0 <passf+0xeb0>
xor    %eax,%eax
xchg   %ax,%ax
movss  (%rdx,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  (%r8,%rax,4),%xmm3
movss  %xmm3,(%r8,%rax,4)
movss  (%rsi,%rax,4),%xmm3
mulss  %xmm2,%xmm3
addss  0x0(%r13,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1f70 <passf+0xe70>
jmp    1f20 <passf+0xe20>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
imul   %r12,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,1),%r11
mov    -0x8(%rsp),%rcx
sub    %rax,%rcx
mov    0x88(%rsp),%rbx
sub    %rax,%rbx
mov    0x1a0(%rsp),%rax
lea    (%rax,%rbp,4),%r12
lea    (%rax,%r11,4),%rbp
lea    (%rax,%rcx,4),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rax,%rbx,4),%rbx
mov    0xa8(%rsp),%rcx
cmp    %rbp,%rcx
setb   %r11b
mov    0x20(%rsp),%rax
cmp    %rax,%r12
setb   %r9b
and    %r11b,%r9b
or     0x10(%rsp),%r9b
cmp    %rbx,%rcx
setb   %r11b
mov    -0x40(%rsp),%rcx
cmp    %rax,%rcx
setb   -0x38(%rsp)
mov    0xa0(%rsp),%rax
cmp    %rbp,%rax
setb   -0x28(%rsp)
mov    0x98(%rsp),%rbp
cmp    %rbp,%r12
setb   %r12b
cmp    %rbx,%rax
setb   %bl
cmp    %rbp,%rcx
setb   %cl
test   %r9b,%r9b
jne    2119 <passf+0x1019>
and    -0x38(%rsp),%r11b
jne    2119 <passf+0x1019>
and    %r12b,-0x28(%rsp)
mov    -0x58(%rsp),%r9
mov    -0x60(%rsp),%r11d
mov    -0x18(%rsp),%rbp
jne    2141 <passf+0x1041>
mov    $0x0,%eax
and    %cl,%bl
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
jne    1f70 <passf+0xe70>
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm4
shufps $0x0,%xmm2,%xmm4
xor    %eax,%eax
mov    0x80(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rax,4),%xmm5
mulps  %xmm3,%xmm5
movups (%r8,%rax,4),%xmm6
addps  %xmm5,%xmm6
movups %xmm6,(%r8,%rax,4)
movups (%rsi,%rax,4),%xmm5
mulps  %xmm4,%xmm5
movups 0x0(%r13,%rax,4),%xmm6
addps  %xmm5,%xmm6
movups %xmm6,0x0(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%r12
jne    20d0 <passf+0xfd0>
mov    %r12,%rax
cmp    %rdi,%r12
mov    -0x48(%rsp),%r12
jne    1f70 <passf+0xe70>
jmp    1f20 <passf+0xe20>
xor    %eax,%eax
mov    -0x58(%rsp),%r9
mov    -0x60(%rsp),%r11d
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
mov    -0x18(%rsp),%rbp
jmp    1f70 <passf+0xe70>
xor    %eax,%eax
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
jmp    1f70 <passf+0xe70>
cmp    $0x3,%r15d
mov    0x1b0(%rsp),%r14d
jl     2471 <passf+0x1371>
mov    -0x1c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r10d
cmovge %eax,%r10d
lea    (%rcx,%rdi,4),%rax
mov    %rax,-0x68(%rsp)
mov    %r12,%rax
mov    %edi,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%r15
mov    %r15,-0x70(%rsp)
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x78(%rsp)
mov    %rdi,%r13
neg    %r13
lea    (%rcx,%rax,4),%rdx
add    $0x30,%rdx
lea    (%rcx,%rax,4),%rsi
add    $0x4,%rsi
mov    $0x1,%ebp
xor    %ebx,%ebx
mov    -0x48(%rsp),%r14
jmp    21fc <passf+0x10fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x1,%rbx
mov    -0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    %r10,%rbp
je     237e <passf+0x127e>
cmpl   $0x0,-0x60(%rsp)
jle    21e0 <passf+0x10e0>
mov    %rbp,%r11
imul   %r14,%r11
cmpl   $0x8,-0x60(%rsp)
jb     223f <passf+0x113f>
mov    %rbx,%rax
imul   %r14,%rax
mov    0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x1a0(%rsp),%r8
lea    (%r8,%rcx,4),%rcx
cmp    %r8,%rcx
jbe    22af <passf+0x11af>
add    %r14,%rax
lea    (%r8,%rax,4),%rax
cmp    -0x68(%rsp),%rax
jae    22af <passf+0x11af>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dil
je     226c <passf+0x116c>
add    %rcx,%r11
mov    0x1a0(%rsp),%rax
movss  (%rax,%r11,4),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r13,%rcx
mov    0x1a0(%rsp),%rcx
je     21e0 <passf+0x10e0>
movss  -0x4(%rsi,%rax,4),%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  (%rsi,%rax,4),%xmm0
addss  0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%rcx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdi
jne    2280 <passf+0x1180>
jmp    21e0 <passf+0x10e0>
cmpq   $0x0,-0x70(%rsp)
je     2373 <passf+0x1273>
mov    -0x78(%rsp),%rax
xor    %r8d,%r8d
mov    0x1a0(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%r8,4),%xmm0
movups -0x20(%rdx,%r8,4),%xmm1
movups (%rcx,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rcx,%r8,4),%xmm1
movups 0x30(%rcx,%r8,4),%xmm3
movups %xmm2,(%rcx,%r8,4)
movups %xmm0,0x10(%rcx,%r8,4)
movups -0x10(%rdx,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%r8,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rcx,%r8,4)
movups %xmm1,0x30(%rcx,%r8,4)
add    $0x10,%r8
add    $0xfffffffffffffffe,%rax
jne    22d0 <passf+0x11d0>
test   $0x1,%r15b
je     2362 <passf+0x1262>
lea    (%r8,%r11,1),%rax
mov    0x1a0(%rsp),%rcx
movups (%rcx,%rax,4),%xmm0
movups 0x10(%rcx,%rax,4),%xmm1
movups (%rcx,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rcx,%r8,4)
movups %xmm0,0x10(%rcx,%r8,4)
mov    %r12,%rcx
cmp    %rdi,%r12
je     21e0 <passf+0x10e0>
jmp    2241 <passf+0x1141>
xor    %r8d,%r8d
test   $0x1,%r15b
jne    2331 <passf+0x1231>
jmp    2362 <passf+0x1262>
mov    -0x10(%rsp),%r15
cmp    $0x3,%r15d
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
mov    0x1b0(%rsp),%r14d
mov    -0x48(%rsp),%rbx
jl     2471 <passf+0x1371>
mov    -0x1c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
lea    (%r9,%rbx,4),%rdx
mov    0x48(%rsp),%rax
add    $0xffffffffffffffff,%rax
imul   %rbx,%rax
lea    (%r9,%rax,4),%rsi
lea    (%rcx,%rax,4),%rdi
mov    $0x1,%r9d
jmp    2404 <passf+0x1304>
nopl   0x0(%rax)
add    $0x1,%r9
mov    -0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rbp
mov    %rbp,0x18(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdi
cmp    %r8,%r9
je     2471 <passf+0x1371>
cmpl   $0x2,-0x60(%rsp)
mov    0x18(%rsp),%rbp
jl     23e0 <passf+0x12e0>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rdx,%rax,4),%xmm0
subss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rax,4)
movss  -0x4(%rdx,%rax,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rax,4)
movss  (%rdx,%rax,4),%xmm0
addss  -0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  (%rdx,%rax,4),%xmm0
subss  -0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x2,%rax
cmp    %rbx,%rax
jl     2420 <passf+0x1320>
jmp    23e0 <passf+0x12e0>
mov    0xe8(%rsp),%rax
movl   $0x1,(%rax)
cmp    $0x2,%r10d
je     2a91 <passf+0x1991>
movl   $0x0,(%rax)
mov    -0x60(%rsp),%eax
test   %eax,%eax
mov    -0x58(%rsp),%rbx
jle    2624 <passf+0x1524>
mov    %eax,%r8d
cmp    $0x8,%eax
jb     24be <passf+0x13be>
lea    (%rcx,%r8,4),%rax
cmp    %rbx,%rax
jbe    253c <passf+0x143c>
lea    (%rbx,%r8,4),%rax
cmp    %rcx,%rax
jbe    253c <passf+0x143c>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rsi
and    $0x3,%rsi
je     24f4 <passf+0x13f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    24e0 <passf+0x13e0>
cmp    $0x3,%rax
jb     2624 <passf+0x1524>
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rdx,4)
movss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rdx,4)
movss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    2500 <passf+0x1400>
jmp    2624 <passf+0x1524>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rax
jae    2560 <passf+0x1460>
xor    %ebp,%ebp
jmp    25d8 <passf+0x14d8>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rcx,%rbp,4),%xmm0
movups 0x10(%rcx,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rbp,4)
movups %xmm1,0x10(%rbx,%rbp,4)
movups 0x20(%rcx,%rbp,4),%xmm0
movups 0x30(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm1,0x30(%rbx,%rbp,4)
movups 0x40(%rcx,%rbp,4),%xmm0
movups 0x50(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm1,0x50(%rbx,%rbp,4)
movups 0x60(%rcx,%rbp,4),%xmm0
movups 0x70(%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm1,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    2580 <passf+0x1480>
test   %rsi,%rsi
je     261b <passf+0x151b>
lea    (%rbx,%rbp,4),%rax
add    $0x10,%rax
lea    (%rcx,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    2600 <passf+0x1500>
cmp    %r8,%rdx
jne    24c0 <passf+0x13c0>
cmp    $0x2,%r15d
jl     2a91 <passf+0x1991>
mov    -0x30(%rsp),%rsi
mov    %esi,%r12d
shr    $0x1f,%r12d
add    %r10d,%r12d
sar    %r12d
mov    -0x5c(%rsp),%eax
mov    %rcx,%rdx
mov    %r15,%r11
movslq %eax,%r15
mov    %r11d,%ecx
mov    %rcx,-0x68(%rsp)
mov    %eax,%r8d
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
lea    0x1(%r15),%rax
imul   %rsi,%rax
mov    -0x58(%rsp),%r9
lea    (%r9,%rax,4),%rdi
add    $0x4,%rdi
mov    %r15,%rbp
imul   %rsi,%rbp
lea    0x0(,%rbp,4),%rcx
mov    %rcx,-0x50(%rsp)
lea    0x0(,%rsi,8),%rbx
lea    (%rdx,%rax,4),%rcx
add    $0x4,%rcx
lea    0x4(%rdx,%rbp,4),%rdx
mov    %rbp,-0x78(%rsp)
lea    (%r9,%rbp,4),%rbp
add    $0x4,%rbp
mov    $0x1,%r13d
xor    %r11d,%r11d
jmp    26d4 <passf+0x15d4>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
add    -0x50(%rsp),%r11
cmp    -0x68(%rsp),%r13
je     2774 <passf+0x1674>
cmpl   $0x0,-0x5c(%rsp)
jle    26c0 <passf+0x15c0>
cmpl   $0x1,-0x5c(%rsp)
jne    26f0 <passf+0x15f0>
xor    %eax,%eax
jmp    2739 <passf+0x1639>
cs nopw 0x0(%rax,%rax,1)
mov    %r11,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rdx,%rsi,1),%xmm0
movss  %xmm0,-0x4(%rbp,%rsi,1)
movss  (%rdx,%rsi,1),%xmm0
movss  %xmm0,0x0(%rbp,%rsi,1)
movss  -0x4(%rcx,%rsi,1),%xmm0
movss  %xmm0,-0x4(%rdi,%rsi,1)
movss  (%rcx,%rsi,1),%xmm0
movss  %xmm0,(%rdi,%rsi,1)
add    $0x2,%rax
add    %rbx,%rsi
cmp    %rax,%r10
jne    2700 <passf+0x1600>
test   $0x1,%r8b
je     26c0 <passf+0x15c0>
mov    %r13,%rsi
imul   %r15,%rsi
add    %rsi,%rax
imul   -0x30(%rsp),%rax
mov    0x1a0(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,0x4(%r9,%rax,4)
jmp    26c0 <passf+0x15c0>
cmp    -0x5c(%rsp),%r12d
jle    2915 <passf+0x1815>
cmpl   $0x2,-0x10(%rsp)
mov    0x1a0(%rsp),%rax
jl     2a91 <passf+0x1991>
movabs $0x200000000,%rcx
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
mov    -0x78(%rsp),%rsi
mov    %rsi,%rdx
shl    $0x20,%rdx
mov    %rdx,-0x48(%rsp)
add    %rcx,%rdx
mov    %rdx,-0x70(%rsp)
mov    -0x30(%rsp),%rdx
mov    %rdx,%rbx
shl    $0x20,%rbx
lea    (%rax,%rsi,4),%rax
mov    %rax,-0x38(%rsp)
lea    0x0(,%rdx,4),%rdx
mov    -0x58(%rsp),%rax
lea    (%rax,%rsi,4),%rax
mov    %rax,-0x28(%rsp)
movl   $0x2,-0x78(%rsp)
mov    $0x1,%esi
mov    -0x58(%rsp),%r11
mov    -0x30(%rsp),%r9
jmp    284e <passf+0x174e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rsp),%rsi
add    $0x1,%rsi
mov    -0x78(%rsp),%eax
add    -0x7c(%rsp),%eax
mov    %eax,-0x78(%rsp)
mov    -0x70(%rsp),%rax
add    -0x48(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,-0x38(%rsp)
add    %rax,-0x28(%rsp)
cmp    -0x68(%rsp),%rsi
je     2a91 <passf+0x1991>
mov    %rsi,-0x40(%rsp)
cmpl   $0x0,-0x5c(%rsp)
jle    2810 <passf+0x1710>
movslq -0x78(%rsp),%rax
mov    0x1a8(%rsp),%rsi
lea    (%rsi,%rax,4),%rbp
mov    -0x28(%rsp),%rdi
mov    -0x38(%rsp),%r12
mov    -0x70(%rsp),%r10
xor    %r14d,%r14d
jmp    2896 <passf+0x1796>
nop
add    $0x1,%r14
add    %rbx,%r10
add    %rdx,%r12
add    %rdx,%rdi
cmp    %r8,%r14
je     2810 <passf+0x1710>
cmpl   $0x4,-0x7c(%rsp)
mov    0x1a0(%rsp),%r13
jl     2880 <passf+0x1780>
mov    $0x3,%eax
mov    %r10,%r15
nopl   (%rax)
movss  -0xc(%rbp,%rax,4),%xmm1
mov    %r15,%rsi
sar    $0x1e,%rsi
movss  -0x8(%rbp,%rax,4),%xmm2
mulss  %xmm0,%xmm2
mulss  (%r12,%rax,4),%xmm2
mulss  0x0(%r13,%rsi,1),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,(%r11,%rsi,1)
movss  -0x8(%rbp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
mulss  0x0(%r13,%rsi,1),%xmm1
movss  -0xc(%rbp,%rax,4),%xmm2
mulss  (%r12,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rax,4)
add    $0x2,%rax
add    %rcx,%r15
cmp    %r9,%rax
jl     28b0 <passf+0x17b0>
jmp    2880 <passf+0x1780>
cmpl   $0x2,-0x10(%rsp)
mov    -0x7c(%rsp),%r9d
mov    0x1a0(%rsp),%rdx
jl     2a91 <passf+0x1991>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
mov    -0x5c(%rsp),%eax
mov    %eax,%esi
imul   %r9d,%esi
lea    0x2(%rsi),%r14d
mov    -0x78(%rsp),%rcx
lea    (%rdx,%rcx,4),%rbx
mov    -0x58(%rsp),%rax
lea    (%rax,%rcx,4),%rcx
xor    %ebp,%ebp
mov    $0x1,%edi
mov    %rsi,-0x28(%rsp)
mov    -0x7c(%rsp),%r15d
mov    -0x30(%rsp),%r11
jmp    29ad <passf+0x18ad>
nopl   (%rax)
mov    -0x7c(%rsp),%r9d
mov    -0x28(%rsp),%rsi
mov    -0x70(%rsp),%r14d
mov    -0x78(%rsp),%rbx
mov    -0x40(%rsp),%rcx
mov    -0x38(%rsp),%rdi
add    $0x1,%rdi
add    %esi,%r14d
mov    -0x50(%rsp),%rdx
add    %rdx,%rbx
add    %rdx,%rcx
mov    %eax,%ebp
cmp    -0x68(%rsp),%rdi
je     2a91 <passf+0x1991>
lea    0x2(%rbp),%eax
cmp    $0x4,%r9d
jl     298e <passf+0x188e>
mov    %rdi,-0x38(%rsp)
movslq %eax,%rdi
mov    $0x3,%r9d
mov    %rcx,-0x40(%rsp)
mov    %rbx,-0x78(%rsp)
mov    %r14d,-0x70(%rsp)
mov    -0x58(%rsp),%rdx
jmp    2a02 <passf+0x1902>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r9
lea    0x2(%rdi),%rax
mov    %edi,%ebp
add    $0x2,%r14d
add    $0x8,%rbx
add    $0x8,%rcx
mov    %rax,%rdi
cmp    %r11,%r9
jge    2970 <passf+0x1870>
cmpl   $0x0,-0x5c(%rsp)
mov    0x1a0(%rsp),%r12
mov    0x1a8(%rsp),%r13
jle    29e0 <passf+0x18e0>
add    $0x3,%ebp
movslq %ebp,%rbp
mov    $0x3,%eax
mov    %r8,%rsi
mov    %r14d,%r10d
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rdi,4),%xmm1
movslq %r10d,%r10
movss  0x0(%r13,%rbp,4),%xmm2
mulss  %xmm0,%xmm2
mulss  (%rbx,%rax,4),%xmm2
mulss  (%r12,%r10,4),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,(%rdx,%r10,4)
movss  0x0(%r13,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
mulss  (%r12,%r10,4),%xmm1
movss  0x0(%r13,%rdi,4),%xmm2
mulss  (%rbx,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rcx,%rax,4)
add    %r15d,%r10d
add    %r11,%rax
add    $0xffffffffffffffff,%rsi
jne    2a30 <passf+0x1930>
jmp    29e0 <passf+0x18e0>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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