void passf(int *nac, int ido, int ip, int l1, int idl1, const double cc[],
           double c1[], double c2[], double ch[], double ch2[],
           const double wa[], int isign) {
  int idij, idlj, idot, ipph, i, j, k, l, jc, lc, ik, nt, idj, idl, inc, idp;
  double wai, war;
  idot = ido / 2;
  nt = ip * idl1;
  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++) {
      c2[ik + l * idl1] = ch2[ik] + wa[idl - 2] * ch2[ik + idl1];
      c2[ik + lc * idl1] = isign * wa[idl - 1] * ch2[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++) {
        c2[ik + l * idl1] += war * ch2[ik + j * idl1];
        c2[ik + lc * idl1] += isign * wai * ch2[ik + jc * idl1];
      }
    }
  }
  for (j = 1; j < ipph; j++)
    for (ik = 0; ik < idl1; ik++)
      ch2[ik] += ch2[ik + j * idl1];
  for (j = 1; j < ipph; j++) {
    jc = ip - j;
    for (ik = 1; ik < idl1; ik += 2) {
      ch2[ik - 1 + j * idl1] = c2[ik - 1 + j * idl1] - c2[ik + jc * idl1];
      ch2[ik - 1 + jc * idl1] = c2[ik - 1 + j * idl1] + c2[ik + jc * idl1];
      ch2[ik + j * idl1] = c2[ik + j * idl1] + c2[ik - 1 + jc * idl1];
      ch2[ik + jc * idl1] = c2[ik + j * idl1] - c2[ik - 1 + jc * idl1];
    }
  }
  *nac = 1;
  if (ido == 2)
    return;
  *nac = 0;
  for (ik = 0; ik < idl1; ik++)
    c2[ik] = ch2[ik];
  for (j = 1; j < ip; j++) {
    for (k = 0; k < l1; k++) {
      c1[(k + j * l1) * ido + 0] = ch[(k + j * l1) * ido + 0];
      c1[(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++) {
          c1[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];
          c1[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;
          c1[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];
          c1[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    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
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
imul   -0x18(%rbp),%eax
mov    %eax,-0x50(%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,-0x60(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     132b <passf+0x22b>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    12ab <passf+0x1ab>
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    1298 <passf+0x198>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1285 <passf+0x185>
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
movsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%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
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a5 <passf+0xa5>
jmp    128a <passf+0x18a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1192 <passf+0x92>
jmp    129d <passf+0x19d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1176 <passf+0x76>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1326 <passf+0x226>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1313 <passf+0x213>
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
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c5 <passf+0x1c5>
jmp    1318 <passf+0x218>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12b2 <passf+0x1b2>
jmp    14e7 <passf+0x3e7>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1467 <passf+0x367>
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    1454 <passf+0x354>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1441 <passf+0x341>
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
movsd  (%rax,%rcx,8),%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
addsd  (%rax,%rcx,8),%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
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%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
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1361 <passf+0x261>
jmp    1446 <passf+0x346>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    134e <passf+0x24e>
jmp    1459 <passf+0x359>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1332 <passf+0x232>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14e2 <passf+0x3e2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14cf <passf+0x3cf>
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
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1481 <passf+0x381>
jmp    14d4 <passf+0x3d4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    146e <passf+0x36e>
jmp    14e7 <passf+0x3e7>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1723 <passf+0x623>
mov    -0x10(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15da <passf+0x4da>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl 0x38(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1525 <passf+0x425>
mov    -0x58(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1710 <passf+0x610>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x60(%rbp),%eax
jle    1625 <passf+0x525>
mov    -0x60(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16fd <passf+0x5fd>
movsd  -0x70(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl 0x38(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x48(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    165a <passf+0x55a>
jmp    1702 <passf+0x602>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15f0 <passf+0x4f0>
jmp    1715 <passf+0x615>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1500 <passf+0x400>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1794 <passf+0x694>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1781 <passf+0x681>
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    173d <passf+0x63d>
jmp    1786 <passf+0x686>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    172a <passf+0x62a>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1916 <passf+0x816>
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    1903 <passf+0x803>
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x44(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    17b7 <passf+0x6b7>
jmp    1908 <passf+0x808>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    179b <passf+0x69b>
mov    -0x8(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x2,-0xc(%rbp)
jne    192f <passf+0x82f>
jmp    1df3 <passf+0xcf3>
mov    -0x8(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1974 <passf+0x874>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1940 <passf+0x840>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a37 <passf+0x937>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a24 <passf+0x924>
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
movsd  (%rax,%rcx,8),%xmm0
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
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%xmm0
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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    198e <passf+0x88e>
jmp    1a29 <passf+0x929>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    197b <passf+0x87b>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1c16 <passf+0xb16>
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c11 <passf+0xb11>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bfe <passf+0xafe>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1beb <passf+0xaeb>
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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
movsd  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x38(%rbp),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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
movsd  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x38(%rbp),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a89 <passf+0x989>
jmp    1bf0 <passf+0xaf0>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1a6d <passf+0x96d>
jmp    1c03 <passf+0xb03>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a51 <passf+0x951>
jmp    1df3 <passf+0xcf3>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dee <passf+0xcee>
mov    -0xc(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ddb <passf+0xcdb>
mov    -0x54(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1dc8 <passf+0xcc8>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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
movsd  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x38(%rbp),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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
movsd  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x38(%rbp),%xmm1
mov    0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
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
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1c5d <passf+0xb5d>
jmp    1dcd <passf+0xccd>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c44 <passf+0xb44>
jmp    1de0 <passf+0xce0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c28 <passf+0xb28>
jmp    1df3 <passf+0xcf3>
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,-0x14(%rsp)
mov    %rdi,0xe8(%rsp)
lea    0x1(%rdx),%eax
shr    $0x1f,%eax
add    %edx,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,-0x24(%rsp)
mov    %edx,%eax
imul   %esi,%eax
mov    %rax,-0x48(%rsp)
movslq %esi,%rax
mov    %rax,-0x38(%rsp)
cmp    %ecx,%esi
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    %esi,%edi
mov    -0x24(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%ebp
cmovge %esi,%ebp
mov    %rbp,0x18(%rsp)
mov    %edi,%esi
mov    %edi,%ebp
mov    %ecx,%edi
mov    %rdi,-0x68(%rsp)
add    $0xffffffff,%edx
imul   %esi,%edx
mov    %edx,-0x50(%rsp)
lea    -0x1(%rax),%rdi
mov    -0x38(%rsp),%rdx
imul   %rdx,%rbx
imul   %rbx,%rdi
shl    $0x3,%rdi
mov    %rdi,-0x58(%rsp)
shl    $0x3,%rbx
lea    0x0(,%rdx,8),%r8
lea    (%r9,%rdx,8),%rdi
mov    %rdi,-0x40(%rsp)
imul   %rdx,%rax
shl    $0x3,%rax
mov    $0x1,%edi
mov    %rbx,-0x70(%rsp)
mov    %rbx,-0x30(%rsp)
jmp    1210 <passf+0x110>
nopl   0x0(%rax)
mov    -0x78(%rsp),%rdi
add    $0x1,%rdi
mov    -0x7c(%rsp),%esi
sub    %esi,-0x50(%rsp)
mov    -0x70(%rsp),%rdx
sub    %rdx,-0x58(%rsp)
add    %rdx,-0x30(%rsp)
add    %r8,-0x40(%rsp)
cmp    0x18(%rsp),%rdi
je     1991 <passf+0x891>
mov    %rdi,-0x78(%rsp)
test   %esi,%esi
mov    0x1b0(%rsp),%rsi
jle    11e0 <passf+0xe0>
mov    -0x40(%rsp),%r14
mov    -0x30(%rsp),%rdi
mov    -0x58(%rsp),%r11
xor    %r10d,%r10d
jmp    1259 <passf+0x159>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10
add    $0x8,%r11
add    $0x8,%rdi
add    $0x8,%r14
cmp    %rbp,%r10
mov    -0x5c(%rsp),%ecx
je     11e0 <passf+0xe0>
test   %ecx,%ecx
mov    -0x48(%rsp),%rcx
jle    1240 <passf+0x140>
mov    -0x68(%rsp),%r13
mov    %r14,%rdx
mov    %rsi,%r15
mov    -0x50(%rsp),%ebx
mov    %ebx,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx),%xmm0
movslq %r12d,%r12
lea    (%r10,%r12,1),%rbx
addsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rdi,1)
movsd  (%rdx),%xmm0
subsd  (%r9,%rbx,8),%xmm0
movsd  %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,%r13d
mov    %esi,%eax
cmp    $0x3,%edx
mov    %r13,-0x20(%rsp)
jl     1a77 <passf+0x977>
mov    -0x10(%rsp),%r10
mov    %r10d,%r11d
movslq %ecx,%rdi
mov    %esi,%r8d
mov    -0x24(%rsp),%esi
cmp    $0x3,%esi
mov    $0x2,%edx
cmovge %esi,%edx
mov    %rdx,0x140(%rsp)
mov    %r8d,%r12d
mov    %rdi,0x128(%rsp)
mov    -0x38(%rsp),%r15
imul   %r15,%rdi
lea    (%rdi,%rax,1),%rdx
mov    %rdx,0x118(%rsp)
lea    -0x1(%r11),%r8
imul   %rdi,%r8
mov    %r15,%r14
mov    %r11,0x28(%rsp)
imul   %r11,%r14
lea    -0x1(%r10),%esi
imul   %r12d,%esi
mov    %r15d,%edx
neg    %edx
mov    %rdx,0x100(%rsp)
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x60(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0x58(%rsp)
mov    %rdx,%rbx
shr    %rbx
add    $0x1,%rbx
mov    %rbx,%rdx
mov    %rbx,0x50(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x150(%rsp)
lea    0x0(,%rdi,8),%rdx
mov    %rdx,0x138(%rsp)
neg    %rdx
mov    %rdx,0x130(%rsp)
lea    (%r8,%rax,1),%rdx
mov    %rdx,0xf8(%rsp)
lea    (%r15,%rax,1),%rdx
mov    %rdx,0xf0(%rsp)
lea    (%r9,%rax,8),%rdx
mov    %rdx,0x68(%rsp)
lea    0x10(%r9,%r15,8),%rdx
mov    %rdx,0xe0(%rsp)
lea    0x0(,%r15,8),%rbp
mov    %r14,0x70(%rsp)
lea    0x0(,%r14,8),%r10
lea    0x10(%r9),%rdx
mov    %rdx,0x148(%rsp)
mov    0x1b0(%rsp),%rdx
lea    0x10(%rdx,%rdi,8),%rbx
mov    %rbx,0xd8(%rsp)
lea    0x10(%rdx,%r8,8),%rbx
mov    %rbx,0xd0(%rsp)
mov    %r8,0x110(%rsp)
lea    (%rdx,%r8,8),%rbx
mov    %rbx,0xc8(%rsp)
mov    %rdi,0x120(%rsp)
lea    (%rdx,%rdi,8),%rdx
mov    %rdx,0xc0(%rsp)
lea    (%r9,%r15,8),%rdx
mov    %rdx,0xb8(%rsp)
mov    $0x1,%edx
mov    %rdx,(%rsp)
xor    %edx,%edx
mov    %rdx,0xb0(%rsp)
mov    %rsi,0x108(%rsp)
mov    %esi,%edx
mov    %r13,%rsi
mov    %edx,0x24(%rsp)
mov    %rbp,0x10(%rsp)
mov    %r10,0x8(%rsp)
jmp    14cc <passf+0x3cc>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rdi
add    $0x1,%rdi
addq   $0x1,0xb0(%rsp)
add    %rbp,0xe0(%rsp)
sub    %r12d,0x24(%rsp)
mov    0x138(%rsp),%rcx
add    %rcx,0xd8(%rsp)
mov    0x130(%rsp),%rdx
add    %rdx,0xd0(%rsp)
add    %rdx,0xc8(%rsp)
add    %rcx,0xc0(%rsp)
add    %rbp,0xb8(%rsp)
mov    %rdi,(%rsp)
cmp    0x140(%rsp),%rdi
mov    -0x5c(%rsp),%ecx
je     1a77 <passf+0x977>
test   %ecx,%ecx
jle    1460 <passf+0x360>
mov    0x120(%rsp),%rdx
mov    %rdx,%rcx
mov    0xb0(%rsp),%rdi
imul   %rdi,%rcx
add    %rcx,%rdx
mov    %rdx,0x90(%rsp)
mov    0x118(%rsp),%rdx
add    %rcx,%rdx
mov    %rdx,0x88(%rsp)
mov    0x110(%rsp),%rdx
sub    %rcx,%rdx
mov    %rdx,0x80(%rsp)
mov    0xf8(%rsp),%rdx
sub    %rcx,%rdx
mov    %rdx,0x40(%rsp)
mov    %rdi,%rbx
mov    -0x38(%rsp),%rcx
imul   %rcx,%rbx
mov    0xf0(%rsp),%rdx
add    %rbx,%rdx
mov    %rdx,0x38(%rsp)
add    %rcx,%rbx
mov    %rbx,0x78(%rsp)
imul   0x100(%rsp),%rdi
add    0x108(%rsp),%rdi
mov    %rdi,0x30(%rsp)
mov    0x28(%rsp),%rdi
mov    (%rsp),%rcx
sub    %rcx,%rdi
mov    %rcx,%rdx
mov    0x128(%rsp),%rcx
imul   %rcx,%rdx
mov    %rdx,0x160(%rsp)
mov    %rdi,%rdx
mov    %rdi,0x48(%rsp)
imul   %rcx,%rdi
mov    %rdi,0x158(%rsp)
mov    0xb8(%rsp),%r8
mov    0xc0(%rsp),%r11
mov    0xc8(%rsp),%r13
mov    0xd0(%rsp),%r14
mov    0xd8(%rsp),%rcx
mov    0x24(%rsp),%edx
mov    %edx,-0x50(%rsp)
mov    0xe0(%rsp),%rdi
xor    %r15d,%r15d
jmp    160b <passf+0x50b>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
add    %r10,%rdi
mov    -0x50(%rsp),%edx
add    -0x48(%rsp),%edx
mov    %edx,-0x50(%rsp)
add    %rbp,%rcx
add    %rbp,%r14
add    %rbp,%r13
add    %rbp,%r11
add    %r10,%r8
cmp    %rsi,%r15
je     1460 <passf+0x360>
test   %r12d,%r12d
jle    15e0 <passf+0x4e0>
movslq -0x50(%rsp),%rdx
mov    %rdx,-0x68(%rsp)
cmp    $0x1,%r12d
jne    1630 <passf+0x530>
xor    %edx,%edx
jmp    1950 <passf+0x850>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdx
imul   -0x38(%rsp),%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rdx,1),%r12
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,1),%r10
mov    0x80(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,-0x78(%rsp)
add    0x40(%rsp),%rdx
mov    0x70(%rsp),%rbx
imul   %r15,%rbx
mov    0x78(%rsp),%rsi
add    %rbx,%rsi
mov    %rsi,-0x40(%rsp)
add    0x38(%rsp),%rbx
mov    %r15d,%ebp
imul   -0x48(%rsp),%ebp
add    0x30(%rsp),%ebp
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%r12,8),%r12
lea    (%rsi,%r10,8),%rsi
mov    %rsi,-0x58(%rsp)
mov    -0x78(%rsp),%rsi
mov    0x1b0(%rsp),%r10
lea    (%r10,%rsi,8),%rsi
mov    %rsi,0xa8(%rsp)
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,-0x70(%rsp)
mov    -0x40(%rsp),%rsi
lea    (%r9,%rsi,8),%rsi
mov    %rsi,0x18(%rsp)
lea    (%r9,%rbx,8),%rsi
mov    %rsi,-0x78(%rsp)
movslq %ebp,%r10
mov    0x68(%rsp),%rsi
lea    (%rsi,%r10,8),%rbx
cmp    %rdx,%r12
setb   -0x40(%rsp)
mov    0xa8(%rsp),%rsi
mov    -0x58(%rsp),%rbp
cmp    %rbp,%rsi
setb   -0x30(%rsp)
cmp    -0x78(%rsp),%r12
setb   0xa0(%rsp)
mov    0x18(%rsp),%rdx
cmp    %rbp,%rdx
setb   0x98(%rsp)
cmp    %rbx,%r12
lea    (%r9,%r10,8),%rbp
setb   %r12b
cmp    -0x58(%rsp),%rbp
setb   -0x58(%rsp)
cmp    -0x78(%rsp),%rsi
setb   -0x8(%rsp)
mov    -0x70(%rsp),%r10
cmp    %r10,%rdx
setb   -0x78(%rsp)
cmp    %rbx,%rsi
setb   %sil
cmp    %r10,%rbp
setb   -0x70(%rsp)
mov    -0x30(%rsp),%dl
test   %dl,-0x40(%rsp)
jne    1924 <passf+0x824>
mov    0x98(%rsp),%dl
and    %dl,0xa0(%rsp)
jne    1924 <passf+0x824>
and    -0x58(%rsp),%r12b
jne    1924 <passf+0x824>
mov    -0x8(%rsp),%dl
and    -0x78(%rsp),%dl
mov    -0x7c(%rsp),%r12d
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%r10
jne    193c <passf+0x83c>
mov    $0x0,%edx
and    -0x70(%rsp),%sil
mov    -0x20(%rsp),%rsi
jne    1950 <passf+0x850>
cmpq   $0x0,0x58(%rsp)
je     1854 <passf+0x754>
mov    %r12d,%esi
mov    0x148(%rsp),%rdx
mov    -0x68(%rsp),%rbp
lea    (%rdx,%rbp,8),%r12
mov    0x150(%rsp),%r10
xor    %edx,%edx
nopl   (%rax)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd -0x10(%r12,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd -0x10(%r12,%rdx,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r14,%rdx,8)
movupd (%rdi,%rdx,8),%xmm0
movupd (%r12,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rdx,8)
movupd (%rdi,%rdx,8),%xmm0
movupd (%r12,%rdx,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r10
jne    17f0 <passf+0x6f0>
jmp    1859 <passf+0x759>
mov    %r12d,%esi
xor    %edx,%edx
testb  $0x1,0x50(%rsp)
mov    %esi,%r12d
mov    -0x20(%rsp),%rsi
je     1907 <passf+0x807>
mov    %r12d,%esi
mov    %r15d,%r12d
imul   -0x10(%rsp),%r12d
mov    %r15,%rbx
imul   0x28(%rsp),%rbx
add    0x48(%rsp),%r12d
add    (%rsp),%rbx
imul   %esi,%r12d
mov    0x160(%rsp),%rbp
lea    (%r15,%rbp,1),%r10
mov    -0x38(%rsp),%rsi
imul   %rsi,%rbx
imul   %rsi,%r10
movslq %r12d,%r12
add    %rdx,%rbx
movupd (%r9,%rbx,8),%xmm0
add    %rdx,%r12
movupd (%r9,%r12,8),%xmm1
addpd  %xmm0,%xmm1
add    %rdx,%r10
mov    0x1b0(%rsp),%rbp
movupd %xmm1,0x0(%rbp,%r10,8)
mov    %rbp,%r10
movupd (%r9,%rbx,8),%xmm0
movupd (%r9,%r12,8),%xmm1
mov    0x158(%rsp),%rbp
add    %r15,%rbp
imul   %rsi,%rbp
mov    -0x7c(%rsp),%r12d
add    %rdx,%rbp
subpd  %xmm1,%xmm0
movupd %xmm0,(%r10,%rbp,8)
mov    -0x20(%rsp),%rsi
mov    0x60(%rsp),%rbx
mov    %rbx,%rdx
cmp    %rax,%rbx
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%r10
je     15e0 <passf+0x4e0>
jmp    1950 <passf+0x850>
xor    %edx,%edx
mov    -0x7c(%rsp),%r12d
mov    -0x20(%rsp),%rsi
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%r10
jmp    1950 <passf+0x850>
xor    %edx,%edx
mov    -0x20(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x68(%rsp),%rbx
lea    (%r9,%rbx,8),%rbx
nopl   0x0(%rax)
movsd  (%r8,%rdx,8),%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
movsd  (%r8,%rdx,8),%xmm0
subsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1960 <passf+0x860>
jmp    15e0 <passf+0x4e0>
test   %esi,%esi
jle    1cc5 <passf+0xbc5>
mov    -0x7c(%rsp),%eax
mov    -0x5c(%rsp),%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rcx,1),%r14d
mov    %rax,%r15
shl    $0x4,%r15
xor    %ebp,%ebp
mov    0x1b0(%rsp),%r10
mov    -0x48(%rsp),%rdi
jmp    19e1 <passf+0x8e1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x8,%r10
cmp    %rax,%rbp
je     1cc5 <passf+0xbc5>
mov    -0x5c(%rsp),%ecx
test   %ecx,%ecx
jle    19d0 <passf+0x8d0>
cmp    $0x1,%ecx
jne    1a00 <passf+0x900>
xor    %ecx,%ecx
jmp    1a44 <passf+0x944>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
mov    %r10,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
lea    (%rdx,%rbp,1),%rbx
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%rsi)
lea    (%rdi,%rdx,1),%ebx
movslq %ebx,%rbx
add    %rbp,%rbx
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x2,%rcx
add    %r14d,%edx
add    %r15,%rsi
cmp    %rcx,%r11
jne    1a10 <passf+0x910>
test   $0x1,%r8b
je     19d0 <passf+0x8d0>
mov    -0x48(%rsp),%rdx
imul   %ecx,%edx
movslq %edx,%rdx
add    %rbp,%rdx
movsd  (%r9,%rdx,8),%xmm0
imul   %rax,%rcx
add    %rbp,%rcx
mov    0x1b0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
jmp    19d0 <passf+0x8d0>
test   %ecx,%ecx
jle    1cc5 <passf+0xbc5>
lea    (%r9,%rax,8),%r12
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,-0x78(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x58(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,-0x40(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x30(%rsp)
mov    %eax,%r15d
and    $0x3,%r15d
lea    0x30(%r9),%rcx
mov    %rcx,-0x70(%rsp)
mov    0x1b0(%rsp),%rdx
lea    0x30(%rdx),%rsi
mov    -0x38(%rsp),%rcx
lea    0x0(,%rcx,8),%r14
lea    0x18(%r9),%rcx
mov    %rcx,-0x50(%rsp)
xor    %r13d,%r13d
xor    %r10d,%r10d
mov    %r12,-0x68(%rsp)
jmp    1b1a <passf+0xa1a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    -0x48(%rsp),%r13d
add    %r14,%rsi
add    %r14,%rdx
cmp    -0x20(%rsp),%r10
je     1cc5 <passf+0xbc5>
cmpl   $0x0,-0x7c(%rsp)
jle    1b00 <passf+0xa00>
movslq %r13d,%r8
cmpl   $0x4,-0x7c(%rsp)
jb     1b7c <passf+0xa7c>
mov    %r10,%r11
imul   -0x38(%rsp),%r11
mov    -0x48(%rsp),%rcx
imul   %r10d,%ecx
mov    0x1b0(%rsp),%rbp
lea    0x0(,%r11,8),%rdi
add    %rbp,%rdi
movslq %ecx,%rcx
lea    (%r12,%rcx,8),%rbx
cmp    %rbx,%rdi
jae    1c0c <passf+0xb0c>
lea    (%r11,%rax,1),%rdi
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
lea    (%r9,%rcx,8),%rcx
cmp    %rdi,%rcx
jae    1c0c <passf+0xb0c>
xor    %ebp,%ebp
mov    %rbp,%rcx
not    %rcx
add    %rax,%rcx
test   %r15,%r15
je     1bb4 <passf+0xab4>
lea    (%r9,%r8,8),%rbx
mov    %r15,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1ba0 <passf+0xaa0>
cmp    $0x3,%rcx
jb     1b00 <passf+0xa00>
mov    -0x50(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  -0x10(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rbp,8)
movsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rbp,8)
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rax
jne    1bd0 <passf+0xad0>
jmp    1b00 <passf+0xa00>
cmpq   $0x0,-0x58(%rsp)
je     1cba <passf+0xbba>
mov    -0x70(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    -0x30(%rsp),%r12
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rbp,8),%xmm0
movups -0x20(%rcx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,8)
movups %xmm1,-0x20(%rsi,%rbp,8)
movupd -0x10(%rcx,%rbp,8),%xmm0
movupd (%rcx,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,8)
movupd %xmm1,(%rsi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%r12
jne    1c30 <passf+0xb30>
testb  $0x1,-0x40(%rsp)
je     1c9f <passf+0xb9f>
mov    -0x48(%rsp),%rcx
imul   %r10d,%ecx
movslq %ecx,%rcx
add    %rbp,%rcx
movupd (%r9,%rcx,8),%xmm0
movupd 0x10(%r9,%rcx,8),%xmm1
add    %rbp,%r11
mov    0x1b0(%rsp),%rcx
movupd %xmm0,(%rcx,%r11,8)
movupd %xmm1,0x10(%rcx,%r11,8)
mov    -0x78(%rsp),%rcx
mov    %rcx,%rbp
cmp    %rax,%rcx
mov    -0x68(%rsp),%r12
je     1b00 <passf+0xa00>
jmp    1b7e <passf+0xa7e>
xor    %ebp,%ebp
testb  $0x1,-0x40(%rsp)
jne    1c6b <passf+0xb6b>
jmp    1c9f <passf+0xb9f>
mov    0x1c0(%rsp),%rbx
mov    0x1b8(%rsp),%r15
mov    0x1a8(%rsp),%r14
mov    -0x10(%rsp),%r11
cmp    $0x3,%r11d
mov    -0x7c(%rsp),%r10d
mov    -0x14(%rsp),%r12d
jl     247d <passf+0x137d>
mov    $0x2,%edi
mov    $0x2,%esi
sub    %r10d,%esi
xorps  %xmm0,%xmm0
cvtsi2sdl 0x1c8(%rsp),%xmm0
lea    -0x1(%r11),%eax
imul   %r12d,%eax
movslq %r12d,%r13
movslq %eax,%r8
mov    -0x24(%rsp),%edx
cmp    $0x4,%edx
mov    $0x3,%ecx
cmovge %edx,%ecx
mov    %rcx,-0x78(%rsp)
mov    %r11d,%ecx
cmp    $0x3,%edx
cmovge %edx,%edi
mov    %rdi,0x70(%rsp)
movslq %esi,%rsi
mov    %r13d,%edi
lea    (%rdi,%r13,1),%rdx
mov    %rdx,(%rsp)
lea    -0x1(%rcx),%rax
imul   %r13,%rax
lea    (%rax,%rdi,1),%rdx
mov    %rdx,0x58(%rsp)
mov    %rcx,0x48(%rsp)
add    $0xfffffffffffffffe,%rcx
imul   %r13,%rcx
mov    %edi,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x80(%rsp)
lea    0x0(,%r13,8),%rbp
mov    %rbp,%rdx
neg    %rdx
mov    %rdx,-0x50(%rsp)
lea    (%r15,%r8,8),%rdx
mov    %rdx,0x68(%rsp)
mov    %r13,%rdx
shl    $0x4,%rdx
add    %r15,%rdx
mov    %rdx,0x50(%rsp)
mov    %r13,%rdx
add    %r13,%rdx
mov    %rdx,0x8(%rsp)
lea    (%rdi,%r13,2),%rdx
mov    %rdx,0x90(%rsp)
lea    (%rcx,%rdi,1),%rdx
mov    %rdx,0x88(%rsp)
mov    %rax,0x60(%rsp)
lea    (%r14,%rax,8),%r9
lea    (%r14,%r13,8),%r8
lea    (%r15,%r13,8),%rdx
mov    %rcx,0x10(%rsp)
lea    (%r15,%rcx,8),%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    $0x1,%ecx
movl   $0x0,-0x68(%rsp)
mov    -0x38(%rsp),%rax
mov    %r13,-0x8(%rsp)
mov    %rbp,-0x70(%rsp)
mov    %rdx,0x30(%rsp)
jmp    1e4b <passf+0xd4b>
nop
mov    0x78(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0x38(%rsp)
add    -0x50(%rsp),%r9
add    %rbp,%r8
cmp    0x70(%rsp),%rcx
mov    -0x7c(%rsp),%r10d
mov    -0x38(%rsp),%rax
mov    -0x10(%rsp),%r11
mov    0x30(%rsp),%rdx
mov    0x40(%rsp),%rsi
je     216f <passf+0x106f>
mov    %rcx,0x78(%rsp)
add    %rax,%rsi
test   %r12d,%r12d
mov    0x68(%rsp),%rax
jle    1e95 <passf+0xd95>
xor    %ecx,%ecx
nop
movsd  -0x10(%rbx,%rsi,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1e60 <passf+0xd60>
mov    %rsi,0x40(%rsp)
add    %r10d,-0x68(%rsp)
cmp    $0x5,%r11d
jb     1e10 <passf+0xd10>
mov    0x38(%rsp),%rax
imul   %r13,%rax
lea    (%rax,%r13,1),%rcx
mov    (%rsp),%rdx
add    %rax,%rdx
mov    0x60(%rsp),%rsi
sub    %rax,%rsi
mov    0x58(%rsp),%rbp
sub    %rax,%rbp
mov    0x1a8(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
lea    (%rax,%rdx,8),%rdx
lea    (%rax,%rsi,8),%rsi
lea    (%rax,%rbp,8),%rax
mov    -0x70(%rsp),%rbp
mov    %rcx,0x18(%rsp)
mov    %rax,0x98(%rsp)
cmp    %rax,%rcx
setb   %al
mov    %rdx,0xa8(%rsp)
mov    %rsi,0xa0(%rsp)
cmp    %rdx,%rsi
setb   %cl
and    %al,%cl
mov    %cl,-0x20(%rsp)
mov    $0x2,%edx
mov    0x28(%rsp),%r11
mov    0x50(%rsp),%rsi
xor    %r10d,%r10d
mov    0x40(%rsp),%rax
mov    %eax,%r14d
jmp    1f5b <passf+0xe5b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
add    $0x1,%r10
add    %rbp,%rsi
add    -0x50(%rsp),%r11
cmp    -0x78(%rsp),%rdx
je     1e10 <passf+0xd10>
add    -0x68(%rsp),%r14d
mov    -0x48(%rsp),%rcx
cmp    %ecx,%r14d
mov    $0x0,%eax
cmovg  %ecx,%eax
sub    %eax,%r14d
test   %r12d,%r12d
jle    1f40 <passf+0xe40>
movslq %r14d,%rax
movsd  -0x10(%rbx,%rax,8),%xmm1
movsd  -0x8(%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
cmp    $0x1,%r12d
jne    1fe0 <passf+0xee0>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  (%r8,%rcx,8),%xmm3
movsd  %xmm3,(%r8,%rcx,8)
movsd  (%r11,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r9,%rcx,8),%xmm3
movsd  %xmm3,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1fa0 <passf+0xea0>
jmp    1f40 <passf+0xe40>
nopl   0x0(%rax)
mov    %r10,%rax
imul   %r13,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%r12
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
mov    0x10(%rsp),%rbp
sub    %rax,%rbp
mov    0x88(%rsp),%rcx
sub    %rax,%rcx
lea    (%r15,%r12,8),%r12
lea    (%r15,%rbx,8),%rbx
lea    (%r15,%rbp,8),%rax
mov    %rax,-0x58(%rsp)
lea    (%r15,%rcx,8),%r13
mov    0x18(%rsp),%rbp
cmp    %rbx,%rbp
setb   %cl
mov    0xa8(%rsp),%rax
cmp    %rax,%r12
setb   %r15b
and    %cl,%r15b
or     -0x20(%rsp),%r15b
cmp    %r13,%rbp
setb   %cl
mov    -0x58(%rsp),%rbp
cmp    %rax,%rbp
setb   -0x40(%rsp)
mov    0xa0(%rsp),%rax
cmp    %rbx,%rax
setb   -0x30(%rsp)
mov    0x98(%rsp),%rbx
cmp    %rbx,%r12
setb   %r12b
cmp    %r13,%rax
setb   %r13b
cmp    %rbx,%rbp
setb   %al
test   %r15b,%r15b
jne    213d <passf+0x103d>
and    -0x40(%rsp),%cl
jne    213d <passf+0x103d>
and    %r12b,-0x30(%rsp)
mov    -0x14(%rsp),%r12d
mov    0x1b8(%rsp),%r15
jne    2156 <passf+0x1056>
mov    $0x0,%ecx
and    %al,%r13b
mov    0x1c0(%rsp),%rbx
mov    -0x8(%rsp),%r13
mov    -0x70(%rsp),%rbp
jne    1fa0 <passf+0xea0>
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
xor    %ecx,%ecx
mov    0x80(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movupd (%rsi,%rcx,8),%xmm5
mulpd  %xmm3,%xmm5
movupd (%r8,%rcx,8),%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r8,%rcx,8)
movupd (%r11,%rcx,8),%xmm5
mulpd  %xmm4,%xmm5
movupd (%r9,%rcx,8),%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r9,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    20f0 <passf+0xff0>
mov    %rax,%rcx
cmp    %rdi,%rax
jne    1fa0 <passf+0xea0>
jmp    1f40 <passf+0xe40>
xor    %ecx,%ecx
mov    -0x14(%rsp),%r12d
mov    0x1c0(%rsp),%rbx
mov    0x1b8(%rsp),%r15
jmp    2160 <passf+0x1060>
xor    %ecx,%ecx
mov    0x1c0(%rsp),%rbx
mov    -0x8(%rsp),%r13
mov    -0x70(%rsp),%rbp
jmp    1fa0 <passf+0xea0>
cmp    $0x3,%r11d
mov    0x1a8(%rsp),%r14
jl     247d <passf+0x137d>
mov    -0x24(%rsp),%eax
cmp    $0x3,%eax
mov    %r13,%rcx
mov    $0x2,%r13d
cmovge %eax,%r13d
lea    (%r15,%rdi,8),%rax
mov    %rax,-0x48(%rsp)
mov    %edi,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r14
mov    %r14,-0x68(%rsp)
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x78(%rsp)
mov    %r15,%rax
mov    %rdi,%r15
neg    %r15
lea    (%rax,%rcx,8),%rdx
add    $0x30,%rdx
lea    (%rax,%rcx,8),%rsi
add    $0x8,%rsi
mov    $0x1,%ebp
xor    %ebx,%ebx
mov    -0x8(%rsp),%r10
jmp    220c <passf+0x110c>
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x1,%rbx
mov    -0x70(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    %r13,%rbp
je     2397 <passf+0x1297>
test   %r12d,%r12d
jle    21f0 <passf+0x10f0>
mov    %rbp,%r9
imul   %r10,%r9
cmp    $0x4,%r12d
jb     224f <passf+0x114f>
mov    %rbx,%rax
imul   %r10,%rax
mov    (%rsp),%rcx
add    %rax,%rcx
mov    0x1b8(%rsp),%r8
lea    (%r8,%rcx,8),%rcx
cmp    %r8,%rcx
jbe    22bf <passf+0x11bf>
add    %r10,%rax
lea    (%r8,%rax,8),%rax
cmp    -0x48(%rsp),%rax
jae    22bf <passf+0x11bf>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dil
je     227c <passf+0x117c>
add    %rcx,%r9
mov    0x1b8(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r15,%rcx
mov    0x1b8(%rsp),%rcx
je     21f0 <passf+0x10f0>
movsd  -0x8(%rsi,%rax,8),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%rsi,%rax,8),%xmm0
addsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    2290 <passf+0x1190>
jmp    21f0 <passf+0x10f0>
cmpq   $0x0,-0x68(%rsp)
je     238d <passf+0x128d>
mov    -0x78(%rsp),%r8
xor    %eax,%eax
mov    0x1b8(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rax,8),%xmm0
movupd -0x20(%rdx,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rcx,%rax,8),%xmm1
movupd 0x30(%rcx,%rax,8),%xmm3
movupd %xmm2,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
movupd -0x10(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rcx,%rax,8)
movupd %xmm1,0x30(%rcx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r8
jne    22e0 <passf+0x11e0>
test   $0x1,%r14b
je     237c <passf+0x127c>
lea    (%rax,%r9,1),%r8
mov    0x1b8(%rsp),%rcx
movupd (%rcx,%r8,8),%xmm0
movupd 0x10(%rcx,%r8,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
mov    %r11,%rcx
cmp    %rdi,%r11
je     21f0 <passf+0x10f0>
jmp    2251 <passf+0x1151>
xor    %eax,%eax
test   $0x1,%r14b
jne    2345 <passf+0x1245>
jmp    237c <passf+0x127c>
mov    -0x10(%rsp),%r11
cmp    $0x3,%r11d
mov    -0x7c(%rsp),%r10d
mov    0x1b8(%rsp),%r15
mov    0x1a8(%rsp),%r14
mov    -0x8(%rsp),%rbx
mov    0x30(%rsp),%rcx
jl     247d <passf+0x137d>
mov    -0x24(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
lea    (%r14,%rbx,8),%rdx
mov    0x48(%rsp),%rax
add    $0xffffffffffffffff,%rax
imul   %rbx,%rax
lea    (%r14,%rax,8),%rsi
lea    (%r15,%rax,8),%rdi
mov    $0x1,%ebp
jmp    241f <passf+0x131f>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
mov    -0x70(%rsp),%rax
add    %rax,%rdx
add    %rax,%rcx
mov    -0x50(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdi
cmp    %r8,%rbp
je     247d <passf+0x137d>
cmp    $0x2,%r12d
jl     2400 <passf+0x1300>
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rax,8),%xmm0
subsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
addsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
subsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rbx,%rax
jl     2430 <passf+0x1330>
jmp    2400 <passf+0x1300>
mov    0xe8(%rsp),%rax
movl   $0x1,(%rax)
cmp    $0x2,%r10d
je     2a8e <passf+0x198e>
movl   $0x0,(%rax)
test   %r12d,%r12d
jle    2638 <passf+0x1538>
mov    %r12d,%ebx
cmp    $0x4,%r12d
jb     24c7 <passf+0x13c7>
lea    (%r15,%rbx,8),%rax
cmp    %r14,%rax
jbe    2544 <passf+0x1444>
lea    (%r14,%rbx,8),%rax
cmp    %r15,%rax
jbe    2544 <passf+0x1444>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %rbx,%rax
mov    %rbx,%rsi
and    $0x3,%rsi
je     24f6 <passf+0x13f6>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    24e0 <passf+0x13e0>
cmp    $0x3,%rax
jb     2638 <passf+0x1538>
movsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0x8(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  0x10(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
movsd  0x18(%r15,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    2500 <passf+0x1400>
jmp    2638 <passf+0x1538>
mov    %ebx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rdi
mov    %rdi,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%esi
and    $0x3,%esi
cmp    $0xc,%rdi
jae    256a <passf+0x146a>
xor    %edi,%edi
jmp    25ec <passf+0x14ec>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rax
xor    %edi,%edi
nopl   (%rax)
movups (%r15,%rdi,8),%xmm0
movups 0x10(%r15,%rdi,8),%xmm1
movups %xmm0,(%r14,%rdi,8)
movups %xmm1,0x10(%r14,%rdi,8)
movups 0x20(%r15,%rdi,8),%xmm0
movups 0x30(%r15,%rdi,8),%xmm1
movups %xmm0,0x20(%r14,%rdi,8)
movups %xmm1,0x30(%r14,%rdi,8)
movups 0x40(%r15,%rdi,8),%xmm0
movups 0x50(%r15,%rdi,8),%xmm1
movups %xmm0,0x40(%r14,%rdi,8)
movups %xmm1,0x50(%r14,%rdi,8)
movupd 0x60(%r15,%rdi,8),%xmm0
movupd 0x70(%r15,%rdi,8),%xmm1
movupd %xmm0,0x60(%r14,%rdi,8)
movupd %xmm1,0x70(%r14,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rax
jne    2580 <passf+0x1480>
test   %rsi,%rsi
je     262f <passf+0x152f>
lea    (%r14,%rdi,8),%rax
add    $0x10,%rax
lea    (%r15,%rdi,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rax,%rbp,1)
movupd %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    2610 <passf+0x1510>
cmp    %rbx,%rdx
jne    24c9 <passf+0x13c9>
cmp    $0x2,%r11d
jl     2a8e <passf+0x198e>
mov    -0x38(%rsp),%rcx
mov    %ecx,%r9d
shr    $0x1f,%r9d
add    -0x7c(%rsp),%r9d
mov    0x1a0(%rsp),%r8
sar    %r9d
mov    -0x5c(%rsp),%r10d
movslq %r10d,%r14
mov    %r11d,%r13d
mov    %r10d,%r15d
mov    %r15,-0x48(%rsp)
and    $0xfffffffe,%r15d
lea    0x1(%r14),%rax
imul   %rcx,%rax
lea    (%r8,%rax,8),%rbp
add    $0x8,%rbp
mov    %r14,%rdi
imul   %rcx,%rdi
lea    0x0(,%rdi,8),%rdx
mov    %rdx,-0x50(%rsp)
shl    $0x4,%rcx
mov    0x1b0(%rsp),%rsi
lea    (%rsi,%rax,8),%rdx
add    $0x8,%rdx
lea    0x8(%rsi,%rdi,8),%rbx
mov    %rdi,-0x78(%rsp)
lea    (%r8,%rdi,8),%rsi
add    $0x8,%rsi
mov    $0x1,%r12d
xor    %r11d,%r11d
jmp    26e2 <passf+0x15e2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    -0x50(%rsp),%r11
cmp    %r13,%r12
je     2785 <passf+0x1685>
test   %r10d,%r10d
jle    26d0 <passf+0x15d0>
cmp    $0x1,%r10d
jne    2700 <passf+0x1600>
xor    %edi,%edi
jmp    2749 <passf+0x1649>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbx,%rax,1),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,1)
movsd  (%rbx,%rax,1),%xmm0
movsd  %xmm0,(%rsi,%rax,1)
movsd  -0x8(%rdx,%rax,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%rax,1)
movsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,1)
add    $0x2,%rdi
add    %rcx,%rax
cmp    %rdi,%r15
jne    2710 <passf+0x1610>
testb  $0x1,-0x48(%rsp)
je     26d0 <passf+0x15d0>
mov    %r12,%rax
imul   %r14,%rax
add    %rax,%rdi
imul   -0x38(%rsp),%rdi
mov    0x1b0(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rdi,8)
movsd  0x8(%rax,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r8,%rdi,8)
jmp    26d0 <passf+0x15d0>
cmp    %r10d,%r9d
mov    %r13,-0x30(%rsp)
jle    2914 <passf+0x1814>
cmpl   $0x2,-0x10(%rsp)
jl     2a8e <passf+0x198e>
movabs $0x200000000,%rcx
xorps  %xmm0,%xmm0
cvtsi2sdl 0x1c8(%rsp),%xmm0
mov    -0x78(%rsp),%rdi
mov    %rdi,%rax
shl    $0x20,%rax
mov    %rax,-0x70(%rsp)
add    %rcx,%rax
mov    %rax,-0x68(%rsp)
mov    -0x38(%rsp),%rdx
mov    %rdx,%rbp
shl    $0x20,%rbp
mov    0x1b0(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    %rax,-0x58(%rsp)
lea    0x0(,%rdx,8),%rsi
lea    (%r8,%rdi,8),%rax
mov    %rax,-0x40(%rsp)
movl   $0x2,-0x78(%rsp)
mov    $0x1,%edx
mov    -0x38(%rsp),%r13
jmp    2849 <passf+0x1749>
nop
add    $0x1,%rdx
mov    -0x78(%rsp),%eax
add    -0x7c(%rsp),%eax
mov    %eax,-0x78(%rsp)
mov    -0x68(%rsp),%rax
add    -0x70(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,-0x58(%rsp)
add    %rax,-0x40(%rsp)
cmp    -0x30(%rsp),%rdx
je     2a8e <passf+0x198e>
cmpl   $0x0,-0x5c(%rsp)
jle    2810 <passf+0x1710>
movslq -0x78(%rsp),%rax
mov    0x1c0(%rsp),%rdi
lea    (%rdi,%rax,8),%rbx
mov    -0x40(%rsp),%r12
mov    -0x58(%rsp),%r15
mov    -0x68(%rsp),%r9
xor    %r10d,%r10d
jmp    2898 <passf+0x1798>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10
add    %rbp,%r9
add    %rsi,%r15
add    %rsi,%r12
cmp    -0x48(%rsp),%r10
je     2810 <passf+0x1710>
cmpl   $0x4,-0x7c(%rsp)
mov    0x1b0(%rsp),%r11
jl     2880 <passf+0x1780>
mov    $0x3,%eax
mov    %r9,%r14
nop
movsd  -0x18(%rbx,%rax,8),%xmm1
mov    %r14,%rdi
sar    $0x1d,%rdi
movsd  -0x10(%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  (%r15,%rax,8),%xmm2
mulsd  (%r11,%rdi,1),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%rdi,1)
movsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  (%r11,%rdi,1),%xmm1
movsd  -0x18(%rbx,%rax,8),%xmm2
mulsd  (%r15,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rax,8)
add    $0x2,%rax
add    %rcx,%r14
cmp    %r13,%rax
jl     28b0 <passf+0x17b0>
jmp    2880 <passf+0x1780>
cmpl   $0x2,-0x10(%rsp)
jl     2a8e <passf+0x198e>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x1c8(%rsp),%xmm0
mov    -0x5c(%rsp),%eax
mov    %eax,%esi
imul   -0x7c(%rsp),%esi
lea    0x2(%rsi),%edx
mov    0x1b0(%rsp),%rax
mov    -0x78(%rsp),%rdi
lea    (%rax,%rdi,8),%rcx
lea    (%r8,%rdi,8),%rbp
xor    %eax,%eax
mov    $0x1,%ebx
mov    %rsi,-0x70(%rsp)
mov    -0x7c(%rsp),%r14d
mov    -0x38(%rsp),%r11
jmp    29a9 <passf+0x18a9>
cs nopw 0x0(%rax,%rax,1)
mov    -0x30(%rsp),%r13
mov    -0x70(%rsp),%rsi
mov    -0x68(%rsp),%edx
mov    -0x78(%rsp),%rcx
mov    -0x58(%rsp),%rbp
mov    -0x40(%rsp),%rbx
add    $0x1,%rbx
add    %esi,%edx
mov    -0x50(%rsp),%rax
add    %rax,%rcx
add    %rax,%rbp
mov    %edi,%eax
cmp    %r13,%rbx
je     2a8e <passf+0x198e>
lea    0x2(%rax),%edi
cmpl   $0x4,-0x7c(%rsp)
jl     298d <passf+0x188d>
mov    %rbx,-0x40(%rsp)
movslq %edi,%rbx
mov    $0x3,%esi
mov    %rbp,-0x58(%rsp)
mov    %rcx,-0x78(%rsp)
mov    %edx,-0x68(%rsp)
mov    -0x5c(%rsp),%r13d
jmp    2a01 <passf+0x1901>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rsi
lea    0x2(%rbx),%rdi
mov    %ebx,%eax
add    $0x2,%edx
add    $0x10,%rcx
add    $0x10,%rbp
mov    %rdi,%rbx
cmp    %r11,%rsi
jge    2970 <passf+0x1870>
test   %r13d,%r13d
mov    0x1b0(%rsp),%r15
mov    0x1c0(%rsp),%r12
jle    29e0 <passf+0x18e0>
add    $0x3,%eax
cltq
mov    $0x3,%edi
mov    -0x48(%rsp),%r9
mov    %edx,%r10d
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rbx,8),%xmm1
movslq %r10d,%r10
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
mulsd  (%r15,%r10,8),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r8,%r10,8)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  (%r15,%r10,8),%xmm1
movsd  (%r12,%rbx,8),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rdi,8)
add    %r14d,%r10d
add    %r11,%rdi
add    $0xffffffffffffffff,%r9
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, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, i32 %11) {
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca double
%42 = alloca double
store i32* %0, i32** %13
store i32 %1, i32* %14
store i32 %2, i32* %15
store i32 %3, i32* %16
store i32 %4, i32* %17
store double* %5, double** %18
store double* %6, double** %19
store double* %7, double** %20
store double* %8, double** %21
store double* %9, double** %22
store double* %10, double** %23
store i32 %11, i32* %24
%43 = load i32, i32* %14
%44 = sdiv i32 %43, 2
store i32 %44, i32* %27
%45 = load i32, i32* %15
%46 = load i32, i32* %17
%47 = mul nsw i32 %45, %46
store i32 %47, i32* %36
%48 = load i32, i32* %15
%49 = add nsw i32 %48, 1
%50 = sdiv i32 %49, 2
store i32 %50, i32* %28
%51 = load i32, i32* %15
%52 = load i32, i32* %14
%53 = mul nsw i32 %51, %52
store i32 %53, i32* %40
%54 = load i32, i32* %14
%55 = load i32, i32* %16
%56 = icmp sge i32 %54, %55
br i1 %56, label %57, label %203
57: ; preds = %12
store i32 1, i32* %30
br label %58
58: ; preds = %162, %57
%59 = load i32, i32* %30
%60 = load i32, i32* %28
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %165
62: ; preds = %58
%63 = load i32, i32* %15
%64 = load i32, i32* %30
%65 = sub nsw i32 %63, %64
store i32 %65, i32* %33
store i32 0, i32* %31
br label %66
66: ; preds = %158, %62
%67 = load i32, i32* %31
%68 = load i32, i32* %16
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %161
70: ; preds = %66
store i32 0, i32* %29
br label %71
71: ; preds = %154, %70
%72 = load i32, i32* %29
%73 = load i32, i32* %14
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %157
75: ; preds = %71
%76 = load double*, double** %18
%77 = load i32, i32* %29
%78 = load i32, i32* %30
%79 = load i32, i32* %31
%80 = load i32, i32* %15
%81 = mul nsw i32 %79, %80
%82 = add nsw i32 %78, %81
%83 = load i32, i32* %14
%84 = mul nsw i32 %82, %83
%85 = add nsw i32 %77, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %76, i64 %86
%88 = load double, double* %87
%89 = load double*, double** %18
%90 = load i32, i32* %29
%91 = load i32, i32* %33
%92 = load i32, i32* %31
%93 = load i32, i32* %15
%94 = mul nsw i32 %92, %93
%95 = add nsw i32 %91, %94
%96 = load i32, i32* %14
%97 = mul nsw i32 %95, %96
%98 = add nsw i32 %90, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %89, i64 %99
%101 = load double, double* %100
%102 = fadd double %88, %101
%103 = load double*, double** %21
%104 = load i32, i32* %29
%105 = load i32, i32* %31
%106 = load i32, i32* %30
%107 = load i32, i32* %16
%108 = mul nsw i32 %106, %107
%109 = add nsw i32 %105, %108
%110 = load i32, i32* %14
%111 = mul nsw i32 %109, %110
%112 = add nsw i32 %104, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %103, i64 %113
store double %102, double* %114
%115 = load double*, double** %18
%116 = load i32, i32* %29
%117 = load i32, i32* %30
%118 = load i32, i32* %31
%119 = load i32, i32* %15
%120 = mul nsw i32 %118, %119
%121 = add nsw i32 %117, %120
%122 = load i32, i32* %14
%123 = mul nsw i32 %121, %122
%124 = add nsw i32 %116, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %115, i64 %125
%127 = load double, double* %126
%128 = load double*, double** %18
%129 = load i32, i32* %29
%130 = load i32, i32* %33
%131 = load i32, i32* %31
%132 = load i32, i32* %15
%133 = mul nsw i32 %131, %132
%134 = add nsw i32 %130, %133
%135 = load i32, i32* %14
%136 = mul nsw i32 %134, %135
%137 = add nsw i32 %129, %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %128, i64 %138
%140 = load double, double* %139
%141 = fsub double %127, %140
%142 = load double*, double** %21
%143 = load i32, i32* %29
%144 = load i32, i32* %31
%145 = load i32, i32* %33
%146 = load i32, i32* %16
%147 = mul nsw i32 %145, %146
%148 = add nsw i32 %144, %147
%149 = load i32, i32* %14
%150 = mul nsw i32 %148, %149
%151 = add nsw i32 %143, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %142, i64 %152
store double %141, double* %153
br label %154
154: ; preds = %75
%155 = load i32, i32* %29
%156 = add nsw i32 %155, 1
store i32 %156, i32* %29
br label %71
157: ; preds = %71
br label %158
158: ; preds = %157
%159 = load i32, i32* %31
%160 = add nsw i32 %159, 1
store i32 %160, i32* %31
br label %66
161: ; preds = %66
br label %162
162: ; preds = %161
%163 = load i32, i32* %30
%164 = add nsw i32 %163, 1
store i32 %164, i32* %30
br label %58
165: ; preds = %58
store i32 0, i32* %31
br label %166
166: ; preds = %199, %165
%167 = load i32, i32* %31
%168 = load i32, i32* %16
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %202
170: ; preds = %166
store i32 0, i32* %29
br label %171
171: ; preds = %195, %170
%172 = load i32, i32* %29
%173 = load i32, i32* %14
%174 = icmp slt i32 %172, %173
br i1 %174, label %175, label %198
175: ; preds = %171
%176 = load double*, double** %18
%177 = load i32, i32* %29
%178 = load i32, i32* %31
%179 = load i32, i32* %15
%180 = mul nsw i32 %178, %179
%181 = load i32, i32* %14
%182 = mul nsw i32 %180, %181
%183 = add nsw i32 %177, %182
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %176, i64 %184
%186 = load double, double* %185
%187 = load double*, double** %21
%188 = load i32, i32* %29
%189 = load i32, i32* %31
%190 = load i32, i32* %14
%191 = mul nsw i32 %189, %190
%192 = add nsw i32 %188, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %187, i64 %193
store double %186, double* %194
br label %195
195: ; preds = %175
%196 = load i32, i32* %29
%197 = add nsw i32 %196, 1
store i32 %197, i32* %29
br label %171
198: ; preds = %171
br label %199
199: ; preds = %198
%200 = load i32, i32* %31
%201 = add nsw i32 %200, 1
store i32 %201, i32* %31
br label %166
202: ; preds = %166
br label %349
203: ; preds = %12
store i32 1, i32* %30
br label %204
204: ; preds = %308, %203
%205 = load i32, i32* %30
%206 = load i32, i32* %28
%207 = icmp slt i32 %205, %206
br i1 %207, label %208, label %311
208: ; preds = %204
%209 = load i32, i32* %15
%210 = load i32, i32* %30
%211 = sub nsw i32 %209, %210
store i32 %211, i32* %33
store i32 0, i32* %29
br label %212
212: ; preds = %304, %208
%213 = load i32, i32* %29
%214 = load i32, i32* %14
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %307
216: ; preds = %212
store i32 0, i32* %31
br label %217
217: ; preds = %300, %216
%218 = load i32, i32* %31
%219 = load i32, i32* %16
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %303
221: ; preds = %217
%222 = load double*, double** %18
%223 = load i32, i32* %29
%224 = load i32, i32* %30
%225 = load i32, i32* %31
%226 = load i32, i32* %15
%227 = mul nsw i32 %225, %226
%228 = add nsw i32 %224, %227
%229 = load i32, i32* %14
%230 = mul nsw i32 %228, %229
%231 = add nsw i32 %223, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %222, i64 %232
%234 = load double, double* %233
%235 = load double*, double** %18
%236 = load i32, i32* %29
%237 = load i32, i32* %33
%238 = load i32, i32* %31
%239 = load i32, i32* %15
%240 = mul nsw i32 %238, %239
%241 = add nsw i32 %237, %240
%242 = load i32, i32* %14
%243 = mul nsw i32 %241, %242
%244 = add nsw i32 %236, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %235, i64 %245
%247 = load double, double* %246
%248 = fadd double %234, %247
%249 = load double*, double** %21
%250 = load i32, i32* %29
%251 = load i32, i32* %31
%252 = load i32, i32* %30
%253 = load i32, i32* %16
%254 = mul nsw i32 %252, %253
%255 = add nsw i32 %251, %254
%256 = load i32, i32* %14
%257 = mul nsw i32 %255, %256
%258 = add nsw i32 %250, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %249, i64 %259
store double %248, double* %260
%261 = load double*, double** %18
%262 = load i32, i32* %29
%263 = load i32, i32* %30
%264 = load i32, i32* %31
%265 = load i32, i32* %15
%266 = mul nsw i32 %264, %265
%267 = add nsw i32 %263, %266
%268 = load i32, i32* %14
%269 = mul nsw i32 %267, %268
%270 = add nsw i32 %262, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %261, i64 %271
%273 = load double, double* %272
%274 = load double*, double** %18
%275 = load i32, i32* %29
%276 = load i32, i32* %33
%277 = load i32, i32* %31
%278 = load i32, i32* %15
%279 = mul nsw i32 %277, %278
%280 = add nsw i32 %276, %279
%281 = load i32, i32* %14
%282 = mul nsw i32 %280, %281
%283 = add nsw i32 %275, %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %274, i64 %284
%286 = load double, double* %285
%287 = fsub double %273, %286
%288 = load double*, double** %21
%289 = load i32, i32* %29
%290 = load i32, i32* %31
%291 = load i32, i32* %33
%292 = load i32, i32* %16
%293 = mul nsw i32 %291, %292
%294 = add nsw i32 %290, %293
%295 = load i32, i32* %14
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %289, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %288, i64 %298
store double %287, double* %299
br label %300
300: ; preds = %221
%301 = load i32, i32* %31
%302 = add nsw i32 %301, 1
store i32 %302, i32* %31
br label %217
303: ; preds = %217
br label %304
304: ; preds = %303
%305 = load i32, i32* %29
%306 = add nsw i32 %305, 1
store i32 %306, i32* %29
br label %212
307: ; preds = %212
br label %308
308: ; preds = %307
%309 = load i32, i32* %30
%310 = add nsw i32 %309, 1
store i32 %310, i32* %30
br label %204
311: ; preds = %204
store i32 0, i32* %29
br label %312
312: ; preds = %345, %311
%313 = load i32, i32* %29
%314 = load i32, i32* %14
%315 = icmp slt i32 %313, %314
br i1 %315, label %316, label %348
316: ; preds = %312
store i32 0, i32* %31
br label %317
317: ; preds = %341, %316
%318 = load i32, i32* %31
%319 = load i32, i32* %16
%320 = icmp slt i32 %318, %319
br i1 %320, label %321, label %344
321: ; preds = %317
%322 = load double*, double** %18
%323 = load i32, i32* %29
%324 = load i32, i32* %31
%325 = load i32, i32* %15
%326 = mul nsw i32 %324, %325
%327 = load i32, i32* %14
%328 = mul nsw i32 %326, %327
%329 = add nsw i32 %323, %328
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %322, i64 %330
%332 = load double, double* %331
%333 = load double*, double** %21
%334 = load i32, i32* %29
%335 = load i32, i32* %31
%336 = load i32, i32* %14
%337 = mul nsw i32 %335, %336
%338 = add nsw i32 %334, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %333, i64 %339
store double %332, double* %340
br label %341
341: ; preds = %321
%342 = load i32, i32* %31
%343 = add nsw i32 %342, 1
store i32 %343, i32* %31
br label %317
344: ; preds = %317
br label %345
345: ; preds = %344
%346 = load i32, i32* %29
%347 = add nsw i32 %346, 1
store i32 %347, i32* %29
br label %312
348: ; preds = %312
br label %349
349: ; preds = %348, %202
%350 = load i32, i32* %14
%351 = sub nsw i32 2, %350
store i32 %351, i32* %38
store i32 0, i32* %39
store i32 1, i32* %32
br label %352
352: ; preds = %518, %349
%353 = load i32, i32* %32
%354 = load i32, i32* %28
%355 = icmp slt i32 %353, %354
br i1 %355, label %356, label %521
356: ; preds = %352
%357 = load i32, i32* %15
%358 = load i32, i32* %32
%359 = sub nsw i32 %357, %358
store i32 %359, i32* %34
%360 = load i32, i32* %14
%361 = load i32, i32* %38
%362 = add nsw i32 %361, %360
store i32 %362, i32* %38
store i32 0, i32* %35
br label %363
363: ; preds = %423, %356
%364 = load i32, i32* %35
%365 = load i32, i32* %17
%366 = icmp slt i32 %364, %365
br i1 %366, label %367, label %426
367: ; preds = %363
%368 = load double*, double** %22
%369 = load i32, i32* %35
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
%372 = load double, double* %371
%373 = load double*, double** %23
%374 = load i32, i32* %38
%375 = sub nsw i32 %374, 2
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %373, i64 %376
%378 = load double, double* %377
%379 = load double*, double** %22
%380 = load i32, i32* %35
%381 = load i32, i32* %17
%382 = add nsw i32 %380, %381
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds double, double* %379, i64 %383
%385 = load double, double* %384
%386 = call double @llvm.fmuladd.f64(double %378, double %385, double %372)
%387 = load double*, double** %20
%388 = load i32, i32* %35
%389 = load i32, i32* %32
%390 = load i32, i32* %17
%391 = mul nsw i32 %389, %390
%392 = add nsw i32 %388, %391
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %387, i64 %393
store double %386, double* %394
%395 = load i32, i32* %24
%396 = sitofp i32 %395 to double
%397 = load double*, double** %23
%398 = load i32, i32* %38
%399 = sub nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %397, i64 %400
%402 = load double, double* %401
%403 = fmul double %396, %402
%404 = load double*, double** %22
%405 = load i32, i32* %35
%406 = load i32, i32* %15
%407 = sub nsw i32 %406, 1
%408 = load i32, i32* %17
%409 = mul nsw i32 %407, %408
%410 = add nsw i32 %405, %409
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %404, i64 %411
%413 = load double, double* %412
%414 = fmul double %403, %413
%415 = load double*, double** %20
%416 = load i32, i32* %35
%417 = load i32, i32* %34
%418 = load i32, i32* %17
%419 = mul nsw i32 %417, %418
%420 = add nsw i32 %416, %419
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %415, i64 %421
store double %414, double* %422
br label %423
423: ; preds = %367
%424 = load i32, i32* %35
%425 = add nsw i32 %424, 1
store i32 %425, i32* %35
br label %363
426: ; preds = %363
%427 = load i32, i32* %38
store i32 %427, i32* %26
%428 = load i32, i32* %14
%429 = load i32, i32* %39
%430 = add nsw i32 %429, %428
store i32 %430, i32* %39
store i32 2, i32* %30
br label %431
431: ; preds = %514, %426
%432 = load i32, i32* %30
%433 = load i32, i32* %28
%434 = icmp slt i32 %432, %433
br i1 %434, label %435, label %517
435: ; preds = %431
%436 = load i32, i32* %15
%437 = load i32, i32* %30
%438 = sub nsw i32 %436, %437
store i32 %438, i32* %33
%439 = load i32, i32* %39
%440 = load i32, i32* %26
%441 = add nsw i32 %440, %439
store i32 %441, i32* %26
%442 = load i32, i32* %26
%443 = load i32, i32* %40
%444 = icmp sgt i32 %442, %443
br i1 %444, label %445, label %449
445: ; preds = %435
%446 = load i32, i32* %40
%447 = load i32, i32* %26
%448 = sub nsw i32 %447, %446
store i32 %448, i32* %26
br label %449
449: ; preds = %445, %435
%450 = load double*, double** %23
%451 = load i32, i32* %26
%452 = sub nsw i32 %451, 2
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %450, i64 %453
%455 = load double, double* %454
store double %455, double* %42
%456 = load double*, double** %23
%457 = load i32, i32* %26
%458 = sub nsw i32 %457, 1
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds double, double* %456, i64 %459
%461 = load double, double* %460
store double %461, double* %41
store i32 0, i32* %35
br label %462
462: ; preds = %510, %449
%463 = load i32, i32* %35
%464 = load i32, i32* %17
%465 = icmp slt i32 %463, %464
br i1 %465, label %466, label %513
466: ; preds = %462
%467 = load double, double* %42
%468 = load double*, double** %22
%469 = load i32, i32* %35
%470 = load i32, i32* %30
%471 = load i32, i32* %17
%472 = mul nsw i32 %470, %471
%473 = add nsw i32 %469, %472
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %468, i64 %474
%476 = load double, double* %475
%477 = load double*, double** %20
%478 = load i32, i32* %35
%479 = load i32, i32* %32
%480 = load i32, i32* %17
%481 = mul nsw i32 %479, %480
%482 = add nsw i32 %478, %481
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %477, i64 %483
%485 = load double, double* %484
%486 = call double @llvm.fmuladd.f64(double %467, double %476, double %485)
store double %486, double* %484
%487 = load i32, i32* %24
%488 = sitofp i32 %487 to double
%489 = load double, double* %41
%490 = fmul double %488, %489
%491 = load double*, double** %22
%492 = load i32, i32* %35
%493 = load i32, i32* %33
%494 = load i32, i32* %17
%495 = mul nsw i32 %493, %494
%496 = add nsw i32 %492, %495
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %491, i64 %497
%499 = load double, double* %498
%500 = load double*, double** %20
%501 = load i32, i32* %35
%502 = load i32, i32* %34
%503 = load i32, i32* %17
%504 = mul nsw i32 %502, %503
%505 = add nsw i32 %501, %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %500, i64 %506
%508 = load double, double* %507
%509 = call double @llvm.fmuladd.f64(double %490, double %499, double %508)
store double %509, double* %507
br label %510
510: ; preds = %466
%511 = load i32, i32* %35
%512 = add nsw i32 %511, 1
store i32 %512, i32* %35
br label %462
513: ; preds = %462
br label %514
514: ; preds = %513
%515 = load i32, i32* %30
%516 = add nsw i32 %515, 1
store i32 %516, i32* %30
br label %431
517: ; preds = %431
br label %518
518: ; preds = %517
%519 = load i32, i32* %32
%520 = add nsw i32 %519, 1
store i32 %520, i32* %32
br label %352
521: ; preds = %352
store i32 1, i32* %30
br label %522
522: ; preds = %551, %521
%523 = load i32, i32* %30
%524 = load i32, i32* %28
%525 = icmp slt i32 %523, %524
br i1 %525, label %526, label %554
526: ; preds = %522
store i32 0, i32* %35
br label %527
527: ; preds = %547, %526
%528 = load i32, i32* %35
%529 = load i32, i32* %17
%530 = icmp slt i32 %528, %529
br i1 %530, label %531, label %550
531: ; preds = %527
%532 = load double*, double** %22
%533 = load i32, i32* %35
%534 = load i32, i32* %30
%535 = load i32, i32* %17
%536 = mul nsw i32 %534, %535
%537 = add nsw i32 %533, %536
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %532, i64 %538
%540 = load double, double* %539
%541 = load double*, double** %22
%542 = load i32, i32* %35
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds double, double* %541, i64 %543
%545 = load double, double* %544
%546 = fadd double %545, %540
store double %546, double* %544
br label %547
547: ; preds = %531
%548 = load i32, i32* %35
%549 = add nsw i32 %548, 1
store i32 %549, i32* %35
br label %527
550: ; preds = %527
br label %551
551: ; preds = %550
%552 = load i32, i32* %30
%553 = add nsw i32 %552, 1
store i32 %553, i32* %30
br label %522
554: ; preds = %522
store i32 1, i32* %30
br label %555
555: ; preds = %686, %554
%556 = load i32, i32* %30
%557 = load i32, i32* %28
%558 = icmp slt i32 %556, %557
br i1 %558, label %559, label %689
559: ; preds = %555
%560 = load i32, i32* %15
%561 = load i32, i32* %30
%562 = sub nsw i32 %560, %561
store i32 %562, i32* %33
store i32 1, i32* %35
br label %563
563: ; preds = %682, %559
%564 = load i32, i32* %35
%565 = load i32, i32* %17
%566 = icmp slt i32 %564, %565
br i1 %566, label %567, label %685
567: ; preds = %563
%568 = load double*, double** %20
%569 = load i32, i32* %35
%570 = sub nsw i32 %569, 1
%571 = load i32, i32* %30
%572 = load i32, i32* %17
%573 = mul nsw i32 %571, %572
%574 = add nsw i32 %570, %573
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double, double* %568, i64 %575
%577 = load double, double* %576
%578 = load double*, double** %20
%579 = load i32, i32* %35
%580 = load i32, i32* %33
%581 = load i32, i32* %17
%582 = mul nsw i32 %580, %581
%583 = add nsw i32 %579, %582
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds double, double* %578, i64 %584
%586 = load double, double* %585
%587 = fsub double %577, %586
%588 = load double*, double** %22
%589 = load i32, i32* %35
%590 = sub nsw i32 %589, 1
%591 = load i32, i32* %30
%592 = load i32, i32* %17
%593 = mul nsw i32 %591, %592
%594 = add nsw i32 %590, %593
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds double, double* %588, i64 %595
store double %587, double* %596
%597 = load double*, double** %20
%598 = load i32, i32* %35
%599 = sub nsw i32 %598, 1
%600 = load i32, i32* %30
%601 = load i32, i32* %17
%602 = mul nsw i32 %600, %601
%603 = add nsw i32 %599, %602
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %597, i64 %604
%606 = load double, double* %605
%607 = load double*, double** %20
%608 = load i32, i32* %35
%609 = load i32, i32* %33
%610 = load i32, i32* %17
%611 = mul nsw i32 %609, %610
%612 = add nsw i32 %608, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds double, double* %607, i64 %613
%615 = load double, double* %614
%616 = fadd double %606, %615
%617 = load double*, double** %22
%618 = load i32, i32* %35
%619 = sub nsw i32 %618, 1
%620 = load i32, i32* %33
%621 = load i32, i32* %17
%622 = mul nsw i32 %620, %621
%623 = add nsw i32 %619, %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %617, i64 %624
store double %616, double* %625
%626 = load double*, double** %20
%627 = load i32, i32* %35
%628 = load i32, i32* %30
%629 = load i32, i32* %17
%630 = mul nsw i32 %628, %629
%631 = add nsw i32 %627, %630
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %626, i64 %632
%634 = load double, double* %633
%635 = load double*, double** %20
%636 = load i32, i32* %35
%637 = sub nsw i32 %636, 1
%638 = load i32, i32* %33
%639 = load i32, i32* %17
%640 = mul nsw i32 %638, %639
%641 = add nsw i32 %637, %640
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %635, i64 %642
%644 = load double, double* %643
%645 = fadd double %634, %644
%646 = load double*, double** %22
%647 = load i32, i32* %35
%648 = load i32, i32* %30
%649 = load i32, i32* %17
%650 = mul nsw i32 %648, %649
%651 = add nsw i32 %647, %650
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %646, i64 %652
store double %645, double* %653
%654 = load double*, double** %20
%655 = load i32, i32* %35
%656 = load i32, i32* %30
%657 = load i32, i32* %17
%658 = mul nsw i32 %656, %657
%659 = add nsw i32 %655, %658
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %654, i64 %660
%662 = load double, double* %661
%663 = load double*, double** %20
%664 = load i32, i32* %35
%665 = sub nsw i32 %664, 1
%666 = load i32, i32* %33
%667 = load i32, i32* %17
%668 = mul nsw i32 %666, %667
%669 = add nsw i32 %665, %668
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %663, i64 %670
%672 = load double, double* %671
%673 = fsub double %662, %672
%674 = load double*, double** %22
%675 = load i32, i32* %35
%676 = load i32, i32* %33
%677 = load i32, i32* %17
%678 = mul nsw i32 %676, %677
%679 = add nsw i32 %675, %678
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds double, double* %674, i64 %680
store double %673, double* %681
br label %682
682: ; preds = %567
%683 = load i32, i32* %35
%684 = add nsw i32 %683, 2
store i32 %684, i32* %35
br label %563
685: ; preds = %563
br label %686
686: ; preds = %685
%687 = load i32, i32* %30
%688 = add nsw i32 %687, 1
store i32 %688, i32* %30
br label %555
689: ; preds = %555
%690 = load i32*, i32** %13
store i32 1, i32* %690
%691 = load i32, i32* %14
%692 = icmp eq i32 %691, 2
br i1 %692, label %693, label %694
693: ; preds = %689
br label %1077
694: ; preds = %689
%695 = load i32*, i32** %13
store i32 0, i32* %695
store i32 0, i32* %35
br label %696
696: ; preds = %710, %694
%697 = load i32, i32* %35
%698 = load i32, i32* %17
%699 = icmp slt i32 %697, %698
br i1 %699, label %700, label %713
700: ; preds = %696
%701 = load double*, double** %22
%702 = load i32, i32* %35
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds double, double* %701, i64 %703
%705 = load double, double* %704
%706 = load double*, double** %20
%707 = load i32, i32* %35
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %706, i64 %708
store double %705, double* %709
br label %710
710: ; preds = %700
%711 = load i32, i32* %35
%712 = add nsw i32 %711, 1
store i32 %712, i32* %35
br label %696
713: ; preds = %696
store i32 1, i32* %30
br label %714
714: ; preds = %774, %713
%715 = load i32, i32* %30
%716 = load i32, i32* %15
%717 = icmp slt i32 %715, %716
br i1 %717, label %718, label %777
718: ; preds = %714
store i32 0, i32* %31
br label %719
719: ; preds = %770, %718
%720 = load i32, i32* %31
%721 = load i32, i32* %16
%722 = icmp slt i32 %720, %721
br i1 %722, label %723, label %773
723: ; preds = %719
%724 = load double*, double** %21
%725 = load i32, i32* %31
%726 = load i32, i32* %30
%727 = load i32, i32* %16
%728 = mul nsw i32 %726, %727
%729 = add nsw i32 %725, %728
%730 = load i32, i32* %14
%731 = mul nsw i32 %729, %730
%732 = add nsw i32 %731, 0
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds double, double* %724, i64 %733
%735 = load double, double* %734
%736 = load double*, double** %19
%737 = load i32, i32* %31
%738 = load i32, i32* %30
%739 = load i32, i32* %16
%740 = mul nsw i32 %738, %739
%741 = add nsw i32 %737, %740
%742 = load i32, i32* %14
%743 = mul nsw i32 %741, %742
%744 = add nsw i32 %743, 0
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds double, double* %736, i64 %745
store double %735, double* %746
%747 = load double*, double** %21
%748 = load i32, i32* %31
%749 = load i32, i32* %30
%750 = load i32, i32* %16
%751 = mul nsw i32 %749, %750
%752 = add nsw i32 %748, %751
%753 = load i32, i32* %14
%754 = mul nsw i32 %752, %753
%755 = add nsw i32 %754, 1
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds double, double* %747, i64 %756
%758 = load double, double* %757
%759 = load double*, double** %19
%760 = load i32, i32* %31
%761 = load i32, i32* %30
%762 = load i32, i32* %16
%763 = mul nsw i32 %761, %762
%764 = add nsw i32 %760, %763
%765 = load i32, i32* %14
%766 = mul nsw i32 %764, %765
%767 = add nsw i32 %766, 1
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds double, double* %759, i64 %768
store double %758, double* %769
br label %770
770: ; preds = %723
%771 = load i32, i32* %31
%772 = add nsw i32 %771, 1
store i32 %772, i32* %31
br label %719
773: ; preds = %719
br label %774
774: ; preds = %773
%775 = load i32, i32* %30
%776 = add nsw i32 %775, 1
store i32 %776, i32* %30
br label %714
777: ; preds = %714
%778 = load i32, i32* %27
%779 = load i32, i32* %16
%780 = icmp sle i32 %778, %779
br i1 %780, label %781, label %927
781: ; preds = %777
store i32 0, i32* %25
store i32 1, i32* %30
br label %782
782: ; preds = %923, %781
%783 = load i32, i32* %30
%784 = load i32, i32* %15
%785 = icmp slt i32 %783, %784
br i1 %785, label %786, label %926
786: ; preds = %782
%787 = load i32, i32* %25
%788 = add nsw i32 %787, 2
store i32 %788, i32* %25
store i32 3, i32* %29
br label %789
789: ; preds = %919, %786
%790 = load i32, i32* %29
%791 = load i32, i32* %14
%792 = icmp slt i32 %790, %791
br i1 %792, label %793, label %922
793: ; preds = %789
%794 = load i32, i32* %25
%795 = add nsw i32 %794, 2
store i32 %795, i32* %25
store i32 0, i32* %31
br label %796
796: ; preds = %915, %793
%797 = load i32, i32* %31
%798 = load i32, i32* %16
%799 = icmp slt i32 %797, %798
br i1 %799, label %800, label %918
800: ; preds = %796
%801 = load double*, double** %23
%802 = load i32, i32* %25
%803 = sub nsw i32 %802, 2
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %801, i64 %804
%806 = load double, double* %805
%807 = load double*, double** %21
%808 = load i32, i32* %29
%809 = sub nsw i32 %808, 1
%810 = load i32, i32* %31
%811 = load i32, i32* %30
%812 = load i32, i32* %16
%813 = mul nsw i32 %811, %812
%814 = add nsw i32 %810, %813
%815 = load i32, i32* %14
%816 = mul nsw i32 %814, %815
%817 = add nsw i32 %809, %816
%818 = sext i32 %817 to i64
%819 = getelementptr inbounds double, double* %807, i64 %818
%820 = load double, double* %819
%821 = load i32, i32* %24
%822 = sitofp i32 %821 to double
%823 = load double*, double** %23
%824 = load i32, i32* %25
%825 = sub nsw i32 %824, 1
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds double, double* %823, i64 %826
%828 = load double, double* %827
%829 = fmul double %822, %828
%830 = load double*, double** %21
%831 = load i32, i32* %29
%832 = load i32, i32* %31
%833 = load i32, i32* %30
%834 = load i32, i32* %16
%835 = mul nsw i32 %833, %834
%836 = add nsw i32 %832, %835
%837 = load i32, i32* %14
%838 = mul nsw i32 %836, %837
%839 = add nsw i32 %831, %838
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double, double* %830, i64 %840
%842 = load double, double* %841
%843 = fmul double %829, %842
%844 = fneg double %843
%845 = call double @llvm.fmuladd.f64(double %806, double %820, double %844)
%846 = load double*, double** %19
%847 = load i32, i32* %29
%848 = sub nsw i32 %847, 1
%849 = load i32, i32* %31
%850 = load i32, i32* %30
%851 = load i32, i32* %16
%852 = mul nsw i32 %850, %851
%853 = add nsw i32 %849, %852
%854 = load i32, i32* %14
%855 = mul nsw i32 %853, %854
%856 = add nsw i32 %848, %855
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %846, i64 %857
store double %845, double* %858
%859 = load double*, double** %23
%860 = load i32, i32* %25
%861 = sub nsw i32 %860, 2
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds double, double* %859, i64 %862
%864 = load double, double* %863
%865 = load double*, double** %21
%866 = load i32, i32* %29
%867 = load i32, i32* %31
%868 = load i32, i32* %30
%869 = load i32, i32* %16
%870 = mul nsw i32 %868, %869
%871 = add nsw i32 %867, %870
%872 = load i32, i32* %14
%873 = mul nsw i32 %871, %872
%874 = add nsw i32 %866, %873
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds double, double* %865, i64 %875
%877 = load double, double* %876
%878 = load i32, i32* %24
%879 = sitofp i32 %878 to double
%880 = load double*, double** %23
%881 = load i32, i32* %25
%882 = sub nsw i32 %881, 1
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds double, double* %880, i64 %883
%885 = load double, double* %884
%886 = fmul double %879, %885
%887 = load double*, double** %21
%888 = load i32, i32* %29
%889 = sub nsw i32 %888, 1
%890 = load i32, i32* %31
%891 = load i32, i32* %30
%892 = load i32, i32* %16
%893 = mul nsw i32 %891, %892
%894 = add nsw i32 %890, %893
%895 = load i32, i32* %14
%896 = mul nsw i32 %894, %895
%897 = add nsw i32 %889, %896
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds double, double* %887, i64 %898
%900 = load double, double* %899
%901 = fmul double %886, %900
%902 = call double @llvm.fmuladd.f64(double %864, double %877, double %901)
%903 = load double*, double** %19
%904 = load i32, i32* %29
%905 = load i32, i32* %31
%906 = load i32, i32* %30
%907 = load i32, i32* %16
%908 = mul nsw i32 %906, %907
%909 = add nsw i32 %905, %908
%910 = load i32, i32* %14
%911 = mul nsw i32 %909, %910
%912 = add nsw i32 %904, %911
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds double, double* %903, i64 %913
store double %902, double* %914
br label %915
915: ; preds = %800
%916 = load i32, i32* %31
%917 = add nsw i32 %916, 1
store i32 %917, i32* %31
br label %796
918: ; preds = %796
br label %919
919: ; preds = %918
%920 = load i32, i32* %29
%921 = add nsw i32 %920, 2
store i32 %921, i32* %29
br label %789
922: ; preds = %789
br label %923
923: ; preds = %922
%924 = load i32, i32* %30
%925 = add nsw i32 %924, 1
store i32 %925, i32* %30
br label %782
926: ; preds = %782
br label %1077
927: ; preds = %777
%928 = load i32, i32* %14
%929 = sub nsw i32 2, %928
store i32 %929, i32* %37
store i32 1, i32* %30
br label %930
930: ; preds = %1073, %927
%931 = load i32, i32* %30
%932 = load i32, i32* %15
%933 = icmp slt i32 %931, %932
br i1 %933, label %934, label %1076
934: ; preds = %930
%935 = load i32, i32* %14
%936 = load i32, i32* %37
%937 = add nsw i32 %936, %935
store i32 %937, i32* %37
store i32 0, i32* %31
br label %938
938: ; preds = %1069, %934
%939 = load i32, i32* %31
%940 = load i32, i32* %16
%941 = icmp slt i32 %939, %940
br i1 %941, label %942, label %1072
942: ; preds = %938
%943 = load i32, i32* %37
store i32 %943, i32* %25
store i32 3, i32* %29
br label %944
944: ; preds = %1065, %942
%945 = load i32, i32* %29
%946 = load i32, i32* %14
%947 = icmp slt i32 %945, %946
br i1 %947, label %948, label %1068
948: ; preds = %944
%949 = load i32, i32* %25
%950 = add nsw i32 %949, 2
store i32 %950, i32* %25
%951 = load double*, double** %23
%952 = load i32, i32* %25
%953 = sub nsw i32 %952, 2
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds double, double* %951, i64 %954
%956 = load double, double* %955
%957 = load double*, double** %21
%958 = load i32, i32* %29
%959 = sub nsw i32 %958, 1
%960 = load i32, i32* %31
%961 = load i32, i32* %30
%962 = load i32, i32* %16
%963 = mul nsw i32 %961, %962
%964 = add nsw i32 %960, %963
%965 = load i32, i32* %14
%966 = mul nsw i32 %964, %965
%967 = add nsw i32 %959, %966
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds double, double* %957, i64 %968
%970 = load double, double* %969
%971 = load i32, i32* %24
%972 = sitofp i32 %971 to double
%973 = load double*, double** %23
%974 = load i32, i32* %25
%975 = sub nsw i32 %974, 1
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds double, double* %973, i64 %976
%978 = load double, double* %977
%979 = fmul double %972, %978
%980 = load double*, double** %21
%981 = load i32, i32* %29
%982 = load i32, i32* %31
%983 = load i32, i32* %30
%984 = load i32, i32* %16
%985 = mul nsw i32 %983, %984
%986 = add nsw i32 %982, %985
%987 = load i32, i32* %14
%988 = mul nsw i32 %986, %987
%989 = add nsw i32 %981, %988
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds double, double* %980, i64 %990
%992 = load double, double* %991
%993 = fmul double %979, %992
%994 = fneg double %993
%995 = call double @llvm.fmuladd.f64(double %956, double %970, double %994)
%996 = load double*, double** %19
%997 = load i32, i32* %29
%998 = sub nsw i32 %997, 1
%999 = load i32, i32* %31
%1000 = load i32, i32* %30
%1001 = load i32, i32* %16
%1002 = mul nsw i32 %1000, %1001
%1003 = add nsw i32 %999, %1002
%1004 = load i32, i32* %14
%1005 = mul nsw i32 %1003, %1004
%1006 = add nsw i32 %998, %1005
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds double, double* %996, i64 %1007
store double %995, double* %1008
%1009 = load double*, double** %23
%1010 = load i32, i32* %25
%1011 = sub nsw i32 %1010, 2
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1009, i64 %1012
%1014 = load double, double* %1013
%1015 = load double*, double** %21
%1016 = load i32, i32* %29
%1017 = load i32, i32* %31
%1018 = load i32, i32* %30
%1019 = load i32, i32* %16
%1020 = mul nsw i32 %1018, %1019
%1021 = add nsw i32 %1017, %1020
%1022 = load i32, i32* %14
%1023 = mul nsw i32 %1021, %1022
%1024 = add nsw i32 %1016, %1023
%1025 = sext i32 %1024 to i64
%1026 = getelementptr inbounds double, double* %1015, i64 %1025
%1027 = load double, double* %1026
%1028 = load i32, i32* %24
%1029 = sitofp i32 %1028 to double
%1030 = load double*, double** %23
%1031 = load i32, i32* %25
%1032 = sub nsw i32 %1031, 1
%1033 = sext i32 %1032 to i64
%1034 = getelementptr inbounds double, double* %1030, i64 %1033
%1035 = load double, double* %1034
%1036 = fmul double %1029, %1035
%1037 = load double*, double** %21
%1038 = load i32, i32* %29
%1039 = sub nsw i32 %1038, 1
%1040 = load i32, i32* %31
%1041 = load i32, i32* %30
%1042 = load i32, i32* %16
%1043 = mul nsw i32 %1041, %1042
%1044 = add nsw i32 %1040, %1043
%1045 = load i32, i32* %14
%1046 = mul nsw i32 %1044, %1045
%1047 = add nsw i32 %1039, %1046
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1037, i64 %1048
%1050 = load double, double* %1049
%1051 = fmul double %1036, %1050
%1052 = call double @llvm.fmuladd.f64(double %1014, double %1027, double %1051)
%1053 = load double*, double** %19
%1054 = load i32, i32* %29
%1055 = load i32, i32* %31
%1056 = load i32, i32* %30
%1057 = load i32, i32* %16
%1058 = mul nsw i32 %1056, %1057
%1059 = add nsw i32 %1055, %1058
%1060 = load i32, i32* %14
%1061 = mul nsw i32 %1059, %1060
%1062 = add nsw i32 %1054, %1061
%1063 = sext i32 %1062 to i64
%1064 = getelementptr inbounds double, double* %1053, i64 %1063
store double %1052, double* %1064
br label %1065
1065: ; preds = %948
%1066 = load i32, i32* %29
%1067 = add nsw i32 %1066, 2
store i32 %1067, i32* %29
br label %944
1068: ; preds = %944
br label %1069
1069: ; preds = %1068
%1070 = load i32, i32* %31
%1071 = add nsw i32 %1070, 1
store i32 %1071, i32* %31
br label %938
1072: ; preds = %938
br label %1073
1073: ; preds = %1072
%1074 = load i32, i32* %30
%1075 = add nsw i32 %1074, 1
store i32 %1075, i32* %30
br label %930
1076: ; preds = %930
br label %1077
1077: ; preds = %693, %1076, %926
ret void
}

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