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


x86 assembly (clang, -O0):
<passf>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1315 <passf+0x215>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1295 <passf+0x195>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1282 <passf+0x182>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    126f <passf+0x16f>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    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    -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    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118f <passf+0x8f>
jmp    1274 <passf+0x174>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    117c <passf+0x7c>
jmp    1287 <passf+0x187>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1160 <passf+0x60>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1310 <passf+0x210>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12fd <passf+0x1fd>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x10(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%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    12af <passf+0x1af>
jmp    1302 <passf+0x202>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    129c <passf+0x19c>
jmp    14d1 <passf+0x3d1>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1451 <passf+0x351>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    143e <passf+0x33e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    142b <passf+0x32b>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
mov    -0x3c(%rbp),%esi
imul   -0x10(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
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    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    -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    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    134b <passf+0x24b>
jmp    1430 <passf+0x330>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1338 <passf+0x238>
jmp    1443 <passf+0x343>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    131c <passf+0x21c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14cc <passf+0x3cc>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14b9 <passf+0x3b9>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x10(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%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    146b <passf+0x36b>
jmp    14be <passf+0x3be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1458 <passf+0x358>
jmp    14d1 <passf+0x3d1>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    170d <passf+0x60d>
mov    -0x10(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15c4 <passf+0x4c4>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%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    -0x20(%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 0x20(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%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    150f <passf+0x40f>
mov    -0x54(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16fa <passf+0x5fa>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x58(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    160f <passf+0x50f>
mov    -0x5c(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x18(%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    16e7 <passf+0x5e7>
movsd  -0x70(%rbp),%xmm0
mov    0x10(%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    -0x20(%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 0x20(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    0x10(%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    -0x20(%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    1644 <passf+0x544>
jmp    16ec <passf+0x5ec>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15da <passf+0x4da>
jmp    16ff <passf+0x5ff>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14ea <passf+0x3ea>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    177e <passf+0x67e>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    176b <passf+0x66b>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%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    1727 <passf+0x627>
jmp    1770 <passf+0x670>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1714 <passf+0x614>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1900 <passf+0x800>
mov    -0x10(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18ed <passf+0x7ed>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%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    0x10(%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    -0x20(%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    -0x20(%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    0x10(%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    -0x20(%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    -0x20(%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    0x10(%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    -0x20(%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    -0x20(%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    0x10(%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    17a1 <passf+0x6a1>
jmp    18f2 <passf+0x7f2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1785 <passf+0x685>
mov    -0x8(%rbp),%rax
movl   $0x1,(%rax)
cmpl   $0x2,-0xc(%rbp)
jne    1919 <passf+0x819>
jmp    1ddd <passf+0xcdd>
mov    -0x8(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    195e <passf+0x85e>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    192a <passf+0x82a>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a21 <passf+0x921>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a0e <passf+0x90e>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
imul   -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1978 <passf+0x878>
jmp    1a13 <passf+0x913>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1965 <passf+0x865>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1c00 <passf+0xb00>
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1bfb <passf+0xafb>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1be8 <passf+0xae8>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bd5 <passf+0xad5>
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a73 <passf+0x973>
jmp    1bda <passf+0xada>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1a57 <passf+0x957>
jmp    1bed <passf+0xaed>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a3b <passf+0x93b>
jmp    1ddd <passf+0xcdd>
mov    $0x2,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dd8 <passf+0xcd8>
mov    -0xc(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dc5 <passf+0xcc5>
mov    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x3,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1db2 <passf+0xcb2>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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  (%rax,%rcx,8),%xmm2
cvtsi2sdl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%esi
imul   -0x14(%rbp),%esi
add    %esi,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1c47 <passf+0xb47>
jmp    1db7 <passf+0xcb7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c2e <passf+0xb2e>
jmp    1dca <passf+0xcca>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c12 <passf+0xb12>
jmp    1ddd <passf+0xcdd>
pop    %rbp
ret

x86 assembly (clang, -O2):
<passf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r8d,-0x60(%rsp)
mov    %rdi,0xe8(%rsp)
lea    0x1(%rdx),%eax
shr    $0x1f,%eax
add    %edx,%eax
add    $0x1,%eax
sar    %eax
mov    %eax,-0x1c(%rsp)
mov    %edx,%eax
imul   %esi,%eax
mov    %rax,-0x68(%rsp)
movslq %esi,%rax
mov    %rax,-0x30(%rsp)
cmp    %ecx,%esi
mov    %r9,-0x58(%rsp)
mov    %ecx,-0x5c(%rsp)
mov    %esi,-0x7c(%rsp)
mov    %rdx,-0x10(%rsp)
jge    12b8 <passf+0x1b8>
cmp    $0x3,%edx
jl     19b1 <passf+0x8b1>
mov    -0x10(%rsp),%rdx
mov    %edx,%eax
movslq %ecx,%rbx
mov    -0x1c(%rsp),%edi
cmp    $0x3,%edi
mov    $0x2,%ebp
cmovge %edi,%ebp
mov    %rbp,-0x48(%rsp)
mov    %esi,%ebp
mov    %ecx,%edi
mov    %rdi,-0x18(%rsp)
add    $0xffffffff,%edx
imul   %esi,%edx
mov    %edx,-0x50(%rsp)
lea    -0x1(%rax),%rdi
mov    -0x30(%rsp),%rdx
imul   %rdx,%rbx
imul   %rbx,%rdi
shl    $0x3,%rdi
mov    %rdi,-0x78(%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,-0x28(%rsp)
mov    %rbx,-0x38(%rsp)
jmp    1210 <passf+0x110>
nopl   (%rax)
mov    -0x70(%rsp),%rdi
add    $0x1,%rdi
mov    -0x7c(%rsp),%esi
sub    %esi,-0x50(%rsp)
mov    -0x28(%rsp),%rdx
sub    %rdx,-0x78(%rsp)
add    %rdx,-0x38(%rsp)
add    %r8,-0x40(%rsp)
cmp    -0x48(%rsp),%rdi
je     19b1 <passf+0x8b1>
mov    %rdi,-0x70(%rsp)
test   %esi,%esi
mov    -0x18(%rsp),%rsi
jle    11e0 <passf+0xe0>
mov    -0x40(%rsp),%r14
mov    -0x38(%rsp),%rdi
mov    -0x78(%rsp),%r11
xor    %r10d,%r10d
jmp    1259 <passf+0x159>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x8,%r11
add    $0x8,%rdi
add    $0x8,%r14
cmp    %rbp,%r10
mov    -0x5c(%rsp),%ecx
je     11e0 <passf+0xe0>
test   %ecx,%ecx
mov    -0x68(%rsp),%rcx
jle    1240 <passf+0x140>
mov    %rsi,%r13
mov    %r14,%rdx
mov    0x1a0(%rsp),%r15
mov    -0x50(%rsp),%ebx
mov    %ebx,%r12d
nopw   0x0(%rax,%rax,1)
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,%r12d
mov    %esi,%ebp
cmp    $0x3,%edx
mov    %r12,-0x8(%rsp)
jl     1a8a <passf+0x98a>
mov    -0x10(%rsp),%r8
mov    %r8d,%r10d
movslq %ecx,%rbx
mov    -0x1c(%rsp),%edx
cmp    $0x3,%edx
mov    $0x2,%eax
cmovge %edx,%eax
mov    %rax,0x140(%rsp)
mov    %rbx,0x128(%rsp)
mov    -0x30(%rsp),%rdx
imul   %rdx,%rbx
lea    (%rbx,%rbp,1),%rax
mov    %rax,0x118(%rsp)
lea    -0x1(%r10),%r14
imul   %rbx,%r14
mov    %rdx,%r11
mov    %r10,0x30(%rsp)
imul   %r10,%r11
add    $0xffffffff,%r8d
imul   %esi,%r8d
mov    %edx,%eax
neg    %eax
mov    %rax,0x100(%rsp)
mov    %ebp,%eax
and    $0xfffffffe,%eax
mov    %rax,0x60(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x50(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x150(%rsp)
lea    0x0(,%rbx,8),%rax
mov    %rax,0x138(%rsp)
neg    %rax
mov    %rax,0x130(%rsp)
lea    (%r14,%rbp,1),%rax
mov    %rax,0xf8(%rsp)
lea    (%rdx,%rbp,1),%rax
mov    %rax,0xf0(%rsp)
lea    (%r9,%rbp,8),%rax
mov    %rax,0x68(%rsp)
lea    0x10(%r9,%rdx,8),%rax
mov    %rax,0xe0(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %r11,0x70(%rsp)
lea    0x0(,%r11,8),%r10
mov    %rax,%r11
lea    0x10(%r9),%rax
mov    %rax,0x148(%rsp)
mov    0x1a0(%rsp),%rax
lea    0x10(%rax,%rbx,8),%rdi
mov    %rdi,0xd8(%rsp)
lea    0x10(%rax,%r14,8),%rdi
mov    %rdi,0xd0(%rsp)
mov    %r14,0x110(%rsp)
lea    (%rax,%r14,8),%rdi
mov    %rdi,0xc8(%rsp)
mov    %r10,%r14
mov    %rbx,0x120(%rsp)
lea    (%rax,%rbx,8),%rax
mov    %rax,0xc0(%rsp)
lea    (%r9,%rdx,8),%rax
mov    %rax,0xb8(%rsp)
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %rax,0xb0(%rsp)
mov    %r8,0x108(%rsp)
mov    %r8d,%eax
mov    %r8d,0x2c(%rsp)
mov    %r11,(%rsp)
mov    %r10,0x10(%rsp)
jmp    14cd <passf+0x3cd>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,0xb0(%rsp)
add    %r11,0xe0(%rsp)
sub    %esi,0x2c(%rsp)
mov    0x138(%rsp),%rax
add    %rax,0xd8(%rsp)
mov    0x130(%rsp),%rcx
add    %rcx,0xd0(%rsp)
add    %rcx,0xc8(%rsp)
add    %rax,0xc0(%rsp)
add    %r11,0xb8(%rsp)
mov    %rdx,0x8(%rsp)
cmp    0x140(%rsp),%rdx
mov    -0x5c(%rsp),%ecx
je     1a8a <passf+0x98a>
test   %ecx,%ecx
jle    1460 <passf+0x360>
mov    0x120(%rsp),%rcx
mov    %rcx,%rax
mov    0xb0(%rsp),%rdx
imul   %rdx,%rax
add    %rax,%rcx
mov    %rcx,0x90(%rsp)
mov    0x118(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0x88(%rsp)
mov    0x110(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x80(%rsp)
mov    0xf8(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x40(%rsp)
mov    %rdx,%rdi
mov    -0x30(%rsp),%rax
imul   %rax,%rdi
mov    0xf0(%rsp),%rcx
add    %rdi,%rcx
mov    %rcx,0x38(%rsp)
add    %rax,%rdi
mov    %rdi,0x78(%rsp)
imul   0x100(%rsp),%rdx
add    0x108(%rsp),%rdx
mov    %rdx,0x18(%rsp)
mov    0x30(%rsp),%rdx
mov    0x8(%rsp),%rax
sub    %rax,%rdx
mov    %rax,%rcx
mov    0x128(%rsp),%rax
imul   %rax,%rcx
mov    %rcx,0x160(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x48(%rsp)
imul   %rax,%rdx
mov    %rdx,0x158(%rsp)
mov    0xb8(%rsp),%r8
mov    0xc0(%rsp),%r15
mov    0xc8(%rsp),%r13
mov    0xd0(%rsp),%r10
mov    0xd8(%rsp),%rcx
mov    0x2c(%rsp),%eax
mov    %eax,-0x50(%rsp)
mov    0xe0(%rsp),%rdi
xor    %eax,%eax
jmp    160b <passf+0x50b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r14,%rdi
mov    -0x50(%rsp),%edx
add    -0x68(%rsp),%edx
mov    %edx,-0x50(%rsp)
add    %r11,%rcx
add    %r11,%r10
add    %r11,%r13
add    %r11,%r15
add    %r14,%r8
cmp    %r12,%rax
je     1460 <passf+0x360>
test   %esi,%esi
jle    15e0 <passf+0x4e0>
movslq -0x50(%rsp),%rbx
cmp    $0x1,%esi
jne    1620 <passf+0x520>
xor    %edx,%edx
jmp    1970 <passf+0x870>
mov    %rbx,-0x78(%rsp)
mov    %rax,%rdx
imul   -0x30(%rsp),%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rdx,1),%r14
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,1),%r11
mov    0x80(%rsp),%rsi
add    %rdx,%rsi
mov    %rsi,-0x70(%rsp)
add    0x40(%rsp),%rdx
mov    0x70(%rsp),%rbx
imul   %rax,%rbx
mov    0x78(%rsp),%rsi
add    %rbx,%rsi
mov    %rsi,-0x40(%rsp)
add    0x38(%rsp),%rbx
mov    %eax,%r12d
imul   -0x68(%rsp),%r12d
add    0x18(%rsp),%r12d
mov    0x1a0(%rsp),%rsi
lea    (%rsi,%r14,8),%r14
lea    (%rsi,%r11,8),%rsi
mov    %rsi,0x20(%rsp)
mov    -0x70(%rsp),%rsi
mov    0x1a0(%rsp),%r11
lea    (%r11,%rsi,8),%rsi
mov    %rsi,-0x48(%rsp)
mov    0x1a0(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,-0x28(%rsp)
mov    -0x40(%rsp),%rsi
lea    (%r9,%rsi,8),%rsi
mov    %rsi,-0x70(%rsp)
lea    (%r9,%rbx,8),%rsi
mov    %rsi,0xa8(%rsp)
movslq %r12d,%r12
mov    0x68(%rsp),%rbx
lea    (%rbx,%r12,8),%r11
mov    %r11,-0x18(%rsp)
cmp    %rdx,%r14
setb   -0x40(%rsp)
mov    -0x48(%rsp),%rbx
mov    0x20(%rsp),%rsi
cmp    %rsi,%rbx
setb   -0x38(%rsp)
mov    0xa8(%rsp),%rdx
cmp    %rdx,%r14
setb   0xa0(%rsp)
cmp    %rsi,-0x70(%rsp)
setb   0x98(%rsp)
cmp    %r11,%r14
lea    (%r9,%r12,8),%r12
setb   %r14b
cmp    %rsi,%r12
setb   0x20(%rsp)
cmp    %rdx,%rbx
mov    %rbx,%rsi
setb   %bl
mov    -0x28(%rsp),%r9
cmp    %r9,-0x70(%rsp)
setb   -0x70(%rsp)
cmp    -0x18(%rsp),%rsi
setb   %sil
cmp    %r9,%r12
setb   %r11b
mov    -0x38(%rsp),%dl
test   %dl,-0x40(%rsp)
jne    1939 <passf+0x839>
mov    0x98(%rsp),%dl
and    %dl,0xa0(%rsp)
jne    1939 <passf+0x839>
and    0x20(%rsp),%r14b
jne    1939 <passf+0x839>
and    -0x70(%rsp),%bl
mov    -0x58(%rsp),%r9
mov    -0x8(%rsp),%r12
mov    0x10(%rsp),%r14
jne    1954 <passf+0x854>
mov    $0x0,%edx
and    %r11b,%sil
mov    -0x7c(%rsp),%esi
mov    (%rsp),%r11
mov    -0x78(%rsp),%rbx
jne    1970 <passf+0x870>
cmpq   $0x0,0x58(%rsp)
je     192a <passf+0x82a>
mov    0x148(%rsp),%rdx
lea    (%rdx,%rbx,8),%r11
mov    0x150(%rsp),%r14
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd -0x10(%r11,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rcx,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd -0x10(%r11,%rdx,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r10,%rdx,8)
movupd (%rdi,%rdx,8),%xmm0
movupd (%r11,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rdx,8)
movupd (%rdi,%rdx,8),%xmm0
movupd (%r11,%rdx,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,(%r10,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r14
jne    17f0 <passf+0x6f0>
testb  $0x1,0x50(%rsp)
je     1909 <passf+0x809>
mov    %eax,%r9d
imul   -0x10(%rsp),%r9d
mov    %rax,%r11
imul   0x30(%rsp),%r11
add    0x48(%rsp),%r9d
add    0x8(%rsp),%r11
imul   %esi,%r9d
mov    0x160(%rsp),%rsi
add    %rax,%rsi
mov    -0x30(%rsp),%r12
imul   %r12,%r11
imul   %r12,%rsi
movslq %r9d,%r9
add    %rdx,%r11
mov    -0x58(%rsp),%rbx
movupd (%rbx,%r11,8),%xmm0
add    %rdx,%r9
mov    -0x58(%rsp),%rbx
movupd (%rbx,%r9,8),%xmm1
addpd  %xmm0,%xmm1
add    %rdx,%rsi
mov    0x1a0(%rsp),%r14
movupd %xmm1,(%r14,%rsi,8)
mov    -0x7c(%rsp),%esi
mov    -0x58(%rsp),%rbx
movupd (%rbx,%r11,8),%xmm0
mov    -0x58(%rsp),%rbx
movupd (%rbx,%r9,8),%xmm1
mov    -0x58(%rsp),%r9
mov    0x158(%rsp),%rbx
add    %rax,%rbx
imul   %r12,%rbx
mov    -0x8(%rsp),%r12
add    %rdx,%rbx
subpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rbx,8)
mov    0x60(%rsp),%rbx
mov    %rbx,%rdx
cmp    %rbp,%rbx
mov    (%rsp),%r11
mov    0x10(%rsp),%r14
mov    -0x78(%rsp),%rbx
je     15e0 <passf+0x4e0>
jmp    1970 <passf+0x870>
xor    %edx,%edx
testb  $0x1,0x50(%rsp)
jne    185d <passf+0x75d>
jmp    1909 <passf+0x809>
xor    %edx,%edx
mov    -0x58(%rsp),%r9
mov    -0x7c(%rsp),%esi
mov    -0x8(%rsp),%r12
mov    (%rsp),%r11
mov    0x10(%rsp),%r14
jmp    195e <passf+0x85e>
xor    %edx,%edx
mov    -0x7c(%rsp),%esi
mov    (%rsp),%r11
mov    -0x78(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r9,%rbx,8),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r8,%rdx,8),%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r8,%rdx,8),%xmm0
subsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1980 <passf+0x880>
jmp    15e0 <passf+0x4e0>
test   %esi,%esi
jle    1cc4 <passf+0xbc4>
mov    -0x7c(%rsp),%r12d
mov    %ecx,%r8d
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
mov    -0x68(%rsp),%rax
lea    (%rax,%rax,1),%r14d
mov    %r12,%r15
shl    $0x4,%r15
xor    %ebp,%ebp
mov    0x1a0(%rsp),%r10
jmp    1a01 <passf+0x901>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%r10
cmp    %r12,%rbp
je     1cc4 <passf+0xbc4>
test   %ecx,%ecx
jle    19f0 <passf+0x8f0>
cmp    $0x1,%ecx
jne    1a10 <passf+0x910>
xor    %edi,%edi
jmp    1a55 <passf+0x955>
xchg   %ax,%ax
xor    %edx,%edx
mov    %r10,%rsi
xor    %edi,%edi
mov    -0x68(%rsp),%rax
nopl   0x0(%rax)
movslq %edx,%rdx
lea    (%rdx,%rbp,1),%rbx
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%rsi)
lea    (%rax,%rdx,1),%ebx
movslq %ebx,%rbx
add    %rbp,%rbx
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%r12,8)
add    $0x2,%rdi
add    %r14d,%edx
add    %r15,%rsi
cmp    %rdi,%r11
jne    1a20 <passf+0x920>
test   $0x1,%r8b
je     19f0 <passf+0x8f0>
mov    -0x68(%rsp),%rax
mov    %eax,%edx
imul   %edi,%edx
movslq %edx,%rdx
add    %rbp,%rdx
movsd  (%r9,%rdx,8),%xmm0
imul   %r12,%rdi
add    %rbp,%rdi
mov    0x1a0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rdi,8)
jmp    19f0 <passf+0x8f0>
test   %ecx,%ecx
mov    -0x30(%rsp),%r13
jle    1cc4 <passf+0xbc4>
lea    (%r9,%rbp,8),%rax
mov    %rax,-0x50(%rsp)
mov    %ebp,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x78(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x40(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x28(%rsp)
mov    %ebp,%r12d
and    $0x3,%r12d
lea    0x30(%r9),%rax
mov    %rax,-0x48(%rsp)
mov    0x1a0(%rsp),%r14
lea    0x30(%r14),%rdx
lea    0x0(,%r13,8),%r10
lea    0x18(%r9),%rax
mov    %rax,-0x70(%rsp)
xor    %esi,%esi
xor    %r8d,%r8d
jmp    1b29 <passf+0xa29>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
add    -0x68(%rsp),%esi
add    %r10,%rdx
add    %r10,%r14
cmp    -0x8(%rsp),%r8
je     1cc4 <passf+0xbc4>
cmpl   $0x0,-0x7c(%rsp)
jle    1b10 <passf+0xa10>
movslq %esi,%r15
cmpl   $0x4,-0x7c(%rsp)
jb     1b7f <passf+0xa7f>
mov    %r8,%r11
imul   %r13,%r11
mov    -0x68(%rsp),%rax
imul   %r8d,%eax
mov    0x1a0(%rsp),%rbx
lea    (%rbx,%r11,8),%rcx
cltq
mov    -0x50(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,%rcx
jae    1c10 <passf+0xb10>
lea    (%r11,%rbp,1),%rcx
lea    (%rbx,%rcx,8),%rcx
lea    (%r9,%rax,8),%rax
cmp    %rcx,%rax
jae    1c10 <passf+0xb10>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %rbp,%rcx
test   %r12,%r12
je     1bb5 <passf+0xab5>
lea    (%r9,%r15,8),%rbx
mov    %r12,%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
jne    1ba0 <passf+0xaa0>
cmp    $0x3,%rcx
jb     1b10 <passf+0xa10>
mov    -0x70(%rsp),%rax
lea    (%rax,%r15,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
movsd  -0x10(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdi,8)
movsd  -0x8(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1bd0 <passf+0xad0>
jmp    1b10 <passf+0xa10>
cmpq   $0x0,-0x40(%rsp)
je     1cb9 <passf+0xbb9>
mov    -0x48(%rsp),%rax
lea    (%rax,%r15,8),%rcx
mov    -0x28(%rsp),%r13
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x30(%rcx,%rdi,8),%xmm0
movups -0x20(%rcx,%rdi,8),%xmm1
movups %xmm0,-0x30(%rdx,%rdi,8)
movups %xmm1,-0x20(%rdx,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm0
movupd (%rcx,%rdi,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rdi,8)
movupd %xmm1,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%r13
jne    1c30 <passf+0xb30>
testb  $0x1,-0x38(%rsp)
je     1c9e <passf+0xb9e>
mov    -0x68(%rsp),%rax
imul   %r8d,%eax
cltq
add    %rdi,%rax
movupd (%r9,%rax,8),%xmm0
movupd 0x10(%r9,%rax,8),%xmm1
add    %rdi,%r11
mov    0x1a0(%rsp),%rax
movupd %xmm0,(%rax,%r11,8)
movupd %xmm1,0x10(%rax,%r11,8)
mov    -0x78(%rsp),%rax
mov    %rax,%rdi
cmp    %rbp,%rax
mov    -0x30(%rsp),%r13
je     1b10 <passf+0xa10>
jmp    1b81 <passf+0xa81>
xor    %edi,%edi
testb  $0x1,-0x38(%rsp)
jne    1c6b <passf+0xb6b>
jmp    1c9e <passf+0xb9e>
mov    0x1b0(%rsp),%r14d
mov    0x1a8(%rsp),%rbx
mov    -0x10(%rsp),%r15
cmp    $0x3,%r15d
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
jl     24b1 <passf+0x13b1>
mov    $0x2,%edi
mov    $0x2,%edx
sub    %r10d,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
lea    -0x1(%r15),%eax
mov    -0x60(%rsp),%r11d
imul   %r11d,%eax
movslq %r11d,%r12
movslq %eax,%r8
mov    -0x1c(%rsp),%esi
cmp    $0x4,%esi
mov    $0x3,%ebp
cmovge %esi,%ebp
mov    %rbp,-0x78(%rsp)
mov    %r15d,%ebp
cmp    $0x3,%esi
cmovge %esi,%edi
mov    %rdi,0x70(%rsp)
movslq %edx,%rsi
mov    %r12d,%edi
lea    (%r12,%rdi,1),%rdx
mov    %rdx,0x8(%rsp)
lea    -0x1(%rbp),%rax
imul   %r12,%rax
lea    (%rax,%rdi,1),%rdx
mov    %rdx,0x58(%rsp)
mov    %rbp,0x48(%rsp)
lea    -0x2(%rbp),%r14
imul   %r12,%r14
mov    %edi,%edx
and    $0xfffffffe,%edx
mov    %rdx,0x80(%rsp)
lea    0x0(,%r12,8),%rdx
mov    %rdx,-0x18(%rsp)
neg    %rdx
mov    %rdx,-0x50(%rsp)
lea    (%rcx,%r8,8),%rbp
mov    %r12,%rdx
shl    $0x4,%rdx
add    %rcx,%rdx
mov    %rdx,0x50(%rsp)
lea    (%r12,%r12,1),%rdx
mov    %rdx,-0x8(%rsp)
lea    (%rdi,%r12,2),%rdx
mov    %rdx,0x90(%rsp)
lea    (%r14,%rdi,1),%rdx
mov    %rdx,0x88(%rsp)
mov    %rax,0x60(%rsp)
lea    (%r9,%rax,8),%r13
lea    (%r9,%r12,8),%r8
lea    (%rcx,%r12,8),%rax
mov    %rax,0x18(%rsp)
mov    %r14,(%rsp)
lea    (%rcx,%r14,8),%rax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    $0x1,%eax
movl   $0x0,-0x70(%rsp)
mov    %r12,-0x48(%rsp)
mov    %rbp,0x68(%rsp)
jmp    1e3e <passf+0xd3e>
mov    0x78(%rsp),%rax
add    $0x1,%rax
addq   $0x1,0x38(%rsp)
add    -0x50(%rsp),%r13
add    %rbp,%r8
cmp    0x70(%rsp),%rax
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
mov    -0x10(%rsp),%r15
mov    0x40(%rsp),%rsi
mov    0x68(%rsp),%rbp
je     2184 <passf+0x1084>
mov    %rax,0x78(%rsp)
add    -0x30(%rsp),%rsi
test   %r11d,%r11d
mov    0x18(%rsp),%rdx
jle    1e96 <passf+0xd96>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x10(%rbx,%rsi,8),%xmm1
mulsd  (%rdx,%rax,8),%xmm1
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%r8,%rax,8)
movsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1e60 <passf+0xd60>
mov    %rsi,0x40(%rsp)
add    %r10d,-0x70(%rsp)
cmp    $0x5,%r15d
mov    -0x68(%rsp),%rcx
mov    -0x18(%rsp),%rbp
jb     1e00 <passf+0xd00>
mov    0x38(%rsp),%rax
imul   %r12,%rax
lea    (%rax,%r12,1),%r10
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,1),%r11
mov    0x60(%rsp),%rsi
sub    %rax,%rsi
mov    0x58(%rsp),%rdx
sub    %rax,%rdx
lea    (%r9,%r10,8),%rax
lea    (%r9,%r11,8),%r10
lea    (%r9,%rsi,8),%rsi
mov    -0x60(%rsp),%r11d
lea    (%r9,%rdx,8),%rdx
mov    %rax,0xa8(%rsp)
mov    %rdx,0x98(%rsp)
cmp    %rdx,%rax
setb   %al
mov    %r10,0x20(%rsp)
mov    %rsi,0xa0(%rsp)
cmp    %r10,%rsi
setb   %dl
and    %al,%dl
mov    %dl,0x10(%rsp)
mov    $0x2,%r14d
mov    0x30(%rsp),%rsi
mov    0x50(%rsp),%rdx
xor    %r15d,%r15d
mov    0x40(%rsp),%rax
mov    %eax,%r10d
jmp    1f5b <passf+0xe5b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x1,%r15
add    %rbp,%rdx
add    -0x50(%rsp),%rsi
cmp    -0x78(%rsp),%r14
je     1e00 <passf+0xd00>
add    -0x70(%rsp),%r10d
cmp    %ecx,%r10d
mov    $0x0,%eax
cmovg  %ecx,%eax
sub    %eax,%r10d
test   %r11d,%r11d
jle    1f40 <passf+0xe40>
movslq %r10d,%rax
movsd  -0x10(%rbx,%rax,8),%xmm1
movsd  -0x8(%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
cmp    $0x1,%r11d
jne    1fd0 <passf+0xed0>
xor    %eax,%eax
xchg   %ax,%ax
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  (%r8,%rax,8),%xmm3
movsd  %xmm3,(%r8,%rax,8)
movsd  (%rsi,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x0(%r13,%rax,8),%xmm3
movsd  %xmm3,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1f90 <passf+0xe90>
jmp    1f40 <passf+0xe40>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
imul   %r12,%rax
mov    -0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,1),%r11
mov    (%rsp),%rcx
sub    %rax,%rcx
mov    0x88(%rsp),%rbx
sub    %rax,%rbx
mov    0x1a0(%rsp),%rax
lea    (%rax,%rbp,8),%r12
lea    (%rax,%r11,8),%rbp
lea    (%rax,%rcx,8),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rax,%rbx,8),%rbx
mov    0xa8(%rsp),%rcx
cmp    %rbp,%rcx
setb   %r11b
mov    0x20(%rsp),%rax
cmp    %rax,%r12
setb   %r9b
and    %r11b,%r9b
or     0x10(%rsp),%r9b
cmp    %rbx,%rcx
setb   %r11b
mov    -0x40(%rsp),%rcx
cmp    %rax,%rcx
setb   -0x38(%rsp)
mov    0xa0(%rsp),%rax
cmp    %rbp,%rax
setb   -0x28(%rsp)
mov    0x98(%rsp),%rbp
cmp    %rbp,%r12
setb   %r12b
cmp    %rbx,%rax
setb   %bl
cmp    %rbp,%rcx
setb   %cl
test   %r9b,%r9b
jne    2143 <passf+0x1043>
and    -0x38(%rsp),%r11b
jne    2143 <passf+0x1043>
and    %r12b,-0x28(%rsp)
mov    -0x58(%rsp),%r9
mov    -0x60(%rsp),%r11d
mov    -0x18(%rsp),%rbp
jne    216b <passf+0x106b>
mov    $0x0,%eax
and    %cl,%bl
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
jne    1f90 <passf+0xe90>
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
xor    %eax,%eax
mov    0x80(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
movupd (%r8,%rax,8),%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r8,%rax,8)
movupd (%rsi,%rax,8),%xmm5
mulpd  %xmm4,%xmm5
movupd 0x0(%r13,%rax,8),%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    20f0 <passf+0xff0>
mov    %r12,%rax
cmp    %rdi,%r12
mov    -0x48(%rsp),%r12
jne    1f90 <passf+0xe90>
jmp    1f40 <passf+0xe40>
xor    %eax,%eax
mov    -0x58(%rsp),%r9
mov    -0x60(%rsp),%r11d
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
mov    -0x18(%rsp),%rbp
jmp    1f90 <passf+0xe90>
xor    %eax,%eax
mov    -0x68(%rsp),%rcx
mov    0x1a8(%rsp),%rbx
mov    -0x48(%rsp),%r12
jmp    1f90 <passf+0xe90>
cmp    $0x3,%r15d
mov    0x1b0(%rsp),%r14d
jl     24b1 <passf+0x13b1>
mov    -0x1c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r10d
cmovge %eax,%r10d
lea    (%rcx,%rdi,8),%rax
mov    %rax,-0x68(%rsp)
mov    %r12,%rax
mov    %edi,%r12d
and    $0xfffffffc,%r12d
lea    -0x4(%r12),%r15
mov    %r15,-0x70(%rsp)
shr    $0x2,%r15
add    $0x1,%r15
mov    %r15,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x78(%rsp)
mov    %rdi,%r13
neg    %r13
lea    (%rcx,%rax,8),%rdx
add    $0x30,%rdx
lea    (%rcx,%rax,8),%rsi
add    $0x8,%rsi
mov    $0x1,%ebp
xor    %ebx,%ebx
mov    -0x48(%rsp),%r14
jmp    221c <passf+0x111c>
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x1,%rbx
mov    -0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    %r10,%rbp
je     23b6 <passf+0x12b6>
cmpl   $0x0,-0x60(%rsp)
jle    2200 <passf+0x1100>
mov    %rbp,%r11
imul   %r14,%r11
cmpl   $0x4,-0x60(%rsp)
jb     225f <passf+0x115f>
mov    %rbx,%rax
imul   %r14,%rax
mov    0x8(%rsp),%rcx
add    %rax,%rcx
mov    0x1a0(%rsp),%r8
lea    (%r8,%rcx,8),%rcx
cmp    %r8,%rcx
jbe    22cf <passf+0x11cf>
add    %r14,%rax
lea    (%r8,%rax,8),%rax
cmp    -0x68(%rsp),%rax
jae    22cf <passf+0x11cf>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%dil
je     228c <passf+0x118c>
add    %rcx,%r11
mov    0x1a0(%rsp),%rax
movsd  (%rax,%r11,8),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    %r13,%rcx
mov    0x1a0(%rsp),%rcx
je     2200 <passf+0x1100>
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    22a0 <passf+0x11a0>
jmp    2200 <passf+0x1100>
cmpq   $0x0,-0x70(%rsp)
je     23ab <passf+0x12ab>
mov    -0x78(%rsp),%rax
xor    %r8d,%r8d
mov    0x1a0(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%r8,8),%xmm0
movupd -0x20(%rdx,%r8,8),%xmm1
movupd (%rcx,%r8,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rcx,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x20(%rcx,%r8,8),%xmm1
movupd 0x30(%rcx,%r8,8),%xmm3
movupd %xmm2,(%rcx,%r8,8)
movupd %xmm0,0x10(%rcx,%r8,8)
movupd -0x10(%rdx,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%r8,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rcx,%r8,8)
movupd %xmm1,0x30(%rcx,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%rax
jne    22f0 <passf+0x11f0>
test   $0x1,%r15b
je     239a <passf+0x129a>
lea    (%r8,%r11,1),%rax
mov    0x1a0(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movupd (%rcx,%r8,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rcx,%r8,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rcx,%r8,8)
movupd %xmm0,0x10(%rcx,%r8,8)
mov    %r12,%rcx
cmp    %rdi,%r12
je     2200 <passf+0x1100>
jmp    2261 <passf+0x1161>
xor    %r8d,%r8d
test   $0x1,%r15b
jne    2361 <passf+0x1261>
jmp    239a <passf+0x129a>
mov    -0x10(%rsp),%r15
cmp    $0x3,%r15d
mov    -0x7c(%rsp),%r10d
mov    0x1a0(%rsp),%rcx
mov    0x1b0(%rsp),%r14d
mov    -0x48(%rsp),%rbx
jl     24b1 <passf+0x13b1>
mov    -0x1c(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%r8d
cmovge %eax,%r8d
lea    (%r9,%rbx,8),%rdx
mov    0x48(%rsp),%rax
add    $0xffffffffffffffff,%rax
imul   %rbx,%rax
lea    (%r9,%rax,8),%rsi
lea    (%rcx,%rax,8),%rdi
mov    $0x1,%r9d
jmp    2444 <passf+0x1344>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    -0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rbp
mov    %rbp,0x18(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdi
cmp    %r8,%r9
je     24b1 <passf+0x13b1>
cmpl   $0x2,-0x60(%rsp)
mov    0x18(%rsp),%rbp
jl     2420 <passf+0x1320>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rax,8),%xmm0
subsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%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,0x0(%rbp,%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     2460 <passf+0x1360>
jmp    2420 <passf+0x1320>
mov    0xe8(%rsp),%rax
movl   $0x1,(%rax)
cmp    $0x2,%r10d
je     2ad1 <passf+0x19d1>
movl   $0x0,(%rax)
mov    -0x60(%rsp),%eax
test   %eax,%eax
mov    -0x58(%rsp),%rbx
jle    2668 <passf+0x1568>
mov    %eax,%r8d
cmp    $0x4,%eax
jb     24fe <passf+0x13fe>
lea    (%rcx,%r8,8),%rax
cmp    %rbx,%rax
jbe    257c <passf+0x147c>
lea    (%rbx,%r8,8),%rax
cmp    %rcx,%rax
jbe    257c <passf+0x147c>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rsi
and    $0x3,%rsi
je     2534 <passf+0x1434>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    2520 <passf+0x1420>
cmp    $0x3,%rax
jb     2668 <passf+0x1568>
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rdx,8)
movsd  0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    2540 <passf+0x1440>
jmp    2668 <passf+0x1568>
mov    %r8d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rax
jae    25a0 <passf+0x14a0>
xor    %ebp,%ebp
jmp    261c <passf+0x151c>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rcx,%rbp,8),%xmm0
movups 0x10(%rcx,%rbp,8),%xmm1
movups %xmm0,(%rbx,%rbp,8)
movups %xmm1,0x10(%rbx,%rbp,8)
movups 0x20(%rcx,%rbp,8),%xmm0
movups 0x30(%rcx,%rbp,8),%xmm1
movups %xmm0,0x20(%rbx,%rbp,8)
movups %xmm1,0x30(%rbx,%rbp,8)
movups 0x40(%rcx,%rbp,8),%xmm0
movups 0x50(%rcx,%rbp,8),%xmm1
movups %xmm0,0x40(%rbx,%rbp,8)
movups %xmm1,0x50(%rbx,%rbp,8)
movupd 0x60(%rcx,%rbp,8),%xmm0
movupd 0x70(%rcx,%rbp,8),%xmm1
movupd %xmm0,0x60(%rbx,%rbp,8)
movupd %xmm1,0x70(%rbx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    25c0 <passf+0x14c0>
test   %rsi,%rsi
je     265f <passf+0x155f>
lea    (%rbx,%rbp,8),%rax
add    $0x10,%rax
lea    (%rcx,%rbp,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    2640 <passf+0x1540>
cmp    %r8,%rdx
jne    2500 <passf+0x1400>
cmp    $0x2,%r15d
jl     2ad1 <passf+0x19d1>
mov    -0x30(%rsp),%rbx
mov    %ebx,%r12d
shr    $0x1f,%r12d
add    %r10d,%r12d
sar    %r12d
mov    -0x5c(%rsp),%eax
mov    %rcx,%rdx
mov    %r15,%r11
movslq %eax,%r15
mov    %r11d,%ecx
mov    %rcx,-0x68(%rsp)
mov    %eax,%r8d
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
lea    0x1(%r15),%rax
imul   %rbx,%rax
mov    -0x58(%rsp),%r9
lea    (%r9,%rax,8),%rdi
add    $0x8,%rdi
mov    %r15,%rsi
imul   %rbx,%rsi
lea    0x0(,%rsi,8),%rcx
mov    %rcx,-0x50(%rsp)
shl    $0x4,%rbx
lea    (%rdx,%rax,8),%rcx
add    $0x8,%rcx
lea    0x8(%rdx,%rsi,8),%rdx
mov    %rsi,-0x78(%rsp)
lea    (%r9,%rsi,8),%rbp
add    $0x8,%rbp
mov    $0x1,%r13d
xor    %r11d,%r11d
jmp    2714 <passf+0x1614>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
add    -0x50(%rsp),%r11
cmp    -0x68(%rsp),%r13
je     27b4 <passf+0x16b4>
cmpl   $0x0,-0x5c(%rsp)
jle    2700 <passf+0x1600>
cmpl   $0x1,-0x5c(%rsp)
jne    2730 <passf+0x1630>
xor    %eax,%eax
jmp    2779 <passf+0x1679>
cs nopw 0x0(%rax,%rax,1)
mov    %r11,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rsi,1),%xmm0
movsd  %xmm0,-0x8(%rbp,%rsi,1)
movsd  (%rdx,%rsi,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,1)
movsd  -0x8(%rcx,%rsi,1),%xmm0
movsd  %xmm0,-0x8(%rdi,%rsi,1)
movsd  (%rcx,%rsi,1),%xmm0
movsd  %xmm0,(%rdi,%rsi,1)
add    $0x2,%rax
add    %rbx,%rsi
cmp    %rax,%r10
jne    2740 <passf+0x1640>
test   $0x1,%r8b
je     2700 <passf+0x1600>
mov    %r13,%rsi
imul   %r15,%rsi
add    %rsi,%rax
imul   -0x30(%rsp),%rax
mov    0x1a0(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r9,%rax,8)
jmp    2700 <passf+0x1600>
cmp    -0x5c(%rsp),%r12d
jle    2955 <passf+0x1855>
cmpl   $0x2,-0x10(%rsp)
mov    0x1a0(%rsp),%rax
jl     2ad1 <passf+0x19d1>
movabs $0x200000000,%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mov    -0x78(%rsp),%rsi
mov    %rsi,%rdx
shl    $0x20,%rdx
mov    %rdx,-0x48(%rsp)
add    %rcx,%rdx
mov    %rdx,-0x70(%rsp)
mov    -0x30(%rsp),%rdx
mov    %rdx,%rbx
shl    $0x20,%rbx
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x38(%rsp)
lea    0x0(,%rdx,8),%rdx
mov    -0x58(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x28(%rsp)
movl   $0x2,-0x78(%rsp)
mov    $0x1,%esi
mov    -0x58(%rsp),%r11
mov    -0x30(%rsp),%r9
jmp    288e <passf+0x178e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rsp),%rsi
add    $0x1,%rsi
mov    -0x78(%rsp),%eax
add    -0x7c(%rsp),%eax
mov    %eax,-0x78(%rsp)
mov    -0x70(%rsp),%rax
add    -0x48(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x50(%rsp),%rax
add    %rax,-0x38(%rsp)
add    %rax,-0x28(%rsp)
cmp    -0x68(%rsp),%rsi
je     2ad1 <passf+0x19d1>
mov    %rsi,-0x40(%rsp)
cmpl   $0x0,-0x5c(%rsp)
jle    2850 <passf+0x1750>
movslq -0x78(%rsp),%rax
mov    0x1a8(%rsp),%rsi
lea    (%rsi,%rax,8),%rbp
mov    -0x28(%rsp),%rdi
mov    -0x38(%rsp),%r12
mov    -0x70(%rsp),%r10
xor    %r14d,%r14d
jmp    28d6 <passf+0x17d6>
nop
add    $0x1,%r14
add    %rbx,%r10
add    %rdx,%r12
add    %rdx,%rdi
cmp    %r8,%r14
je     2850 <passf+0x1750>
cmpl   $0x4,-0x7c(%rsp)
mov    0x1a0(%rsp),%r13
jl     28c0 <passf+0x17c0>
mov    $0x3,%eax
mov    %r10,%r15
nopl   (%rax)
movsd  -0x18(%rbp,%rax,8),%xmm1
mov    %r15,%rsi
sar    $0x1d,%rsi
movsd  -0x10(%rbp,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  (%r12,%rax,8),%xmm2
mulsd  0x0(%r13,%rsi,1),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r11,%rsi,1)
movsd  -0x10(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rsi,1),%xmm1
movsd  -0x18(%rbp,%rax,8),%xmm2
mulsd  (%r12,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
add    $0x2,%rax
add    %rcx,%r15
cmp    %r9,%rax
jl     28f0 <passf+0x17f0>
jmp    28c0 <passf+0x17c0>
cmpl   $0x2,-0x10(%rsp)
mov    -0x7c(%rsp),%r9d
mov    0x1a0(%rsp),%rdx
jl     2ad1 <passf+0x19d1>
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mov    -0x5c(%rsp),%eax
mov    %eax,%esi
imul   %r9d,%esi
lea    0x2(%rsi),%r14d
mov    -0x78(%rsp),%rcx
lea    (%rdx,%rcx,8),%rbx
mov    -0x58(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
xor    %ebp,%ebp
mov    $0x1,%edi
mov    %rsi,-0x28(%rsp)
mov    -0x7c(%rsp),%r15d
mov    -0x30(%rsp),%r11
jmp    29ed <passf+0x18ed>
nopl   (%rax)
mov    -0x7c(%rsp),%r9d
mov    -0x28(%rsp),%rsi
mov    -0x70(%rsp),%r14d
mov    -0x78(%rsp),%rbx
mov    -0x40(%rsp),%rcx
mov    -0x38(%rsp),%rdi
add    $0x1,%rdi
add    %esi,%r14d
mov    -0x50(%rsp),%rdx
add    %rdx,%rbx
add    %rdx,%rcx
mov    %eax,%ebp
cmp    -0x68(%rsp),%rdi
je     2ad1 <passf+0x19d1>
lea    0x2(%rbp),%eax
cmp    $0x4,%r9d
jl     29ce <passf+0x18ce>
mov    %rdi,-0x38(%rsp)
movslq %eax,%rdi
mov    $0x3,%r9d
mov    %rcx,-0x40(%rsp)
mov    %rbx,-0x78(%rsp)
mov    %r14d,-0x70(%rsp)
mov    -0x58(%rsp),%rdx
jmp    2a42 <passf+0x1942>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r9
lea    0x2(%rdi),%rax
mov    %edi,%ebp
add    $0x2,%r14d
add    $0x10,%rbx
add    $0x10,%rcx
mov    %rax,%rdi
cmp    %r11,%r9
jge    29b0 <passf+0x18b0>
cmpl   $0x0,-0x5c(%rsp)
mov    0x1a0(%rsp),%r12
mov    0x1a8(%rsp),%r13
jle    2a20 <passf+0x1920>
add    $0x3,%ebp
movslq %ebp,%rbp
mov    $0x3,%eax
mov    %r8,%rsi
mov    %r14d,%r10d
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdi,8),%xmm1
movslq %r10d,%r10
movsd  0x0(%r13,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  (%rbx,%rax,8),%xmm2
mulsd  (%r12,%r10,8),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx,%r10,8)
movsd  0x0(%r13,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  (%r12,%r10,8),%xmm1
movsd  0x0(%r13,%rdi,8),%xmm2
mulsd  (%rbx,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rax,8)
add    %r15d,%r10d
add    %r11,%rax
add    $0xffffffffffffffff,%rsi
jne    2a70 <passf+0x1970>
jmp    2a20 <passf+0x1920>
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, i32 %8) {
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca double
%35 = alloca double
store i32* %0, i32** %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store i32 %3, i32* %13
store i32 %4, i32* %14
store double* %5, double** %15
store double* %6, double** %16
store double* %7, double** %17
store i32 %8, i32* %18
%36 = load i32, i32* %11
%37 = sdiv i32 %36, 2
store i32 %37, i32* %21
%38 = load i32, i32* %12
%39 = add nsw i32 %38, 1
%40 = sdiv i32 %39, 2
store i32 %40, i32* %22
%41 = load i32, i32* %12
%42 = load i32, i32* %11
%43 = mul nsw i32 %41, %42
store i32 %43, i32* %33
%44 = load i32, i32* %11
%45 = load i32, i32* %13
%46 = icmp sge i32 %44, %45
br i1 %46, label %47, label %193
47: ; preds = %9
store i32 1, i32* %24
br label %48
48: ; preds = %152, %47
%49 = load i32, i32* %24
%50 = load i32, i32* %22
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %155
52: ; preds = %48
%53 = load i32, i32* %12
%54 = load i32, i32* %24
%55 = sub nsw i32 %53, %54
store i32 %55, i32* %27
store i32 0, i32* %25
br label %56
56: ; preds = %148, %52
%57 = load i32, i32* %25
%58 = load i32, i32* %13
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %151
60: ; preds = %56
store i32 0, i32* %23
br label %61
61: ; preds = %144, %60
%62 = load i32, i32* %23
%63 = load i32, i32* %11
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %147
65: ; preds = %61
%66 = load double*, double** %15
%67 = load i32, i32* %23
%68 = load i32, i32* %24
%69 = load i32, i32* %25
%70 = load i32, i32* %12
%71 = mul nsw i32 %69, %70
%72 = add nsw i32 %68, %71
%73 = load i32, i32* %11
%74 = mul nsw i32 %72, %73
%75 = add nsw i32 %67, %74
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %66, i64 %76
%78 = load double, double* %77
%79 = load double*, double** %15
%80 = load i32, i32* %23
%81 = load i32, i32* %27
%82 = load i32, i32* %25
%83 = load i32, i32* %12
%84 = mul nsw i32 %82, %83
%85 = add nsw i32 %81, %84
%86 = load i32, i32* %11
%87 = mul nsw i32 %85, %86
%88 = add nsw i32 %80, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %79, i64 %89
%91 = load double, double* %90
%92 = fadd double %78, %91
%93 = load double*, double** %16
%94 = load i32, i32* %23
%95 = load i32, i32* %25
%96 = load i32, i32* %24
%97 = load i32, i32* %13
%98 = mul nsw i32 %96, %97
%99 = add nsw i32 %95, %98
%100 = load i32, i32* %11
%101 = mul nsw i32 %99, %100
%102 = add nsw i32 %94, %101
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %93, i64 %103
store double %92, double* %104
%105 = load double*, double** %15
%106 = load i32, i32* %23
%107 = load i32, i32* %24
%108 = load i32, i32* %25
%109 = load i32, i32* %12
%110 = mul nsw i32 %108, %109
%111 = add nsw i32 %107, %110
%112 = load i32, i32* %11
%113 = mul nsw i32 %111, %112
%114 = add nsw i32 %106, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %105, i64 %115
%117 = load double, double* %116
%118 = load double*, double** %15
%119 = load i32, i32* %23
%120 = load i32, i32* %27
%121 = load i32, i32* %25
%122 = load i32, i32* %12
%123 = mul nsw i32 %121, %122
%124 = add nsw i32 %120, %123
%125 = load i32, i32* %11
%126 = mul nsw i32 %124, %125
%127 = add nsw i32 %119, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %118, i64 %128
%130 = load double, double* %129
%131 = fsub double %117, %130
%132 = load double*, double** %16
%133 = load i32, i32* %23
%134 = load i32, i32* %25
%135 = load i32, i32* %27
%136 = load i32, i32* %13
%137 = mul nsw i32 %135, %136
%138 = add nsw i32 %134, %137
%139 = load i32, i32* %11
%140 = mul nsw i32 %138, %139
%141 = add nsw i32 %133, %140
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %132, i64 %142
store double %131, double* %143
br label %144
144: ; preds = %65
%145 = load i32, i32* %23
%146 = add nsw i32 %145, 1
store i32 %146, i32* %23
br label %61
147: ; preds = %61
br label %148
148: ; preds = %147
%149 = load i32, i32* %25
%150 = add nsw i32 %149, 1
store i32 %150, i32* %25
br label %56
151: ; preds = %56
br label %152
152: ; preds = %151
%153 = load i32, i32* %24
%154 = add nsw i32 %153, 1
store i32 %154, i32* %24
br label %48
155: ; preds = %48
store i32 0, i32* %25
br label %156
156: ; preds = %189, %155
%157 = load i32, i32* %25
%158 = load i32, i32* %13
%159 = icmp slt i32 %157, %158
br i1 %159, label %160, label %192
160: ; preds = %156
store i32 0, i32* %23
br label %161
161: ; preds = %185, %160
%162 = load i32, i32* %23
%163 = load i32, i32* %11
%164 = icmp slt i32 %162, %163
br i1 %164, label %165, label %188
165: ; preds = %161
%166 = load double*, double** %15
%167 = load i32, i32* %23
%168 = load i32, i32* %25
%169 = load i32, i32* %12
%170 = mul nsw i32 %168, %169
%171 = load i32, i32* %11
%172 = mul nsw i32 %170, %171
%173 = add nsw i32 %167, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %166, i64 %174
%176 = load double, double* %175
%177 = load double*, double** %16
%178 = load i32, i32* %23
%179 = load i32, i32* %25
%180 = load i32, i32* %11
%181 = mul nsw i32 %179, %180
%182 = add nsw i32 %178, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %177, i64 %183
store double %176, double* %184
br label %185
185: ; preds = %165
%186 = load i32, i32* %23
%187 = add nsw i32 %186, 1
store i32 %187, i32* %23
br label %161
188: ; preds = %161
br label %189
189: ; preds = %188
%190 = load i32, i32* %25
%191 = add nsw i32 %190, 1
store i32 %191, i32* %25
br label %156
192: ; preds = %156
br label %339
193: ; preds = %9
store i32 1, i32* %24
br label %194
194: ; preds = %298, %193
%195 = load i32, i32* %24
%196 = load i32, i32* %22
%197 = icmp slt i32 %195, %196
br i1 %197, label %198, label %301
198: ; preds = %194
%199 = load i32, i32* %12
%200 = load i32, i32* %24
%201 = sub nsw i32 %199, %200
store i32 %201, i32* %27
store i32 0, i32* %23
br label %202
202: ; preds = %294, %198
%203 = load i32, i32* %23
%204 = load i32, i32* %11
%205 = icmp slt i32 %203, %204
br i1 %205, label %206, label %297
206: ; preds = %202
store i32 0, i32* %25
br label %207
207: ; preds = %290, %206
%208 = load i32, i32* %25
%209 = load i32, i32* %13
%210 = icmp slt i32 %208, %209
br i1 %210, label %211, label %293
211: ; preds = %207
%212 = load double*, double** %15
%213 = load i32, i32* %23
%214 = load i32, i32* %24
%215 = load i32, i32* %25
%216 = load i32, i32* %12
%217 = mul nsw i32 %215, %216
%218 = add nsw i32 %214, %217
%219 = load i32, i32* %11
%220 = mul nsw i32 %218, %219
%221 = add nsw i32 %213, %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %212, i64 %222
%224 = load double, double* %223
%225 = load double*, double** %15
%226 = load i32, i32* %23
%227 = load i32, i32* %27
%228 = load i32, i32* %25
%229 = load i32, i32* %12
%230 = mul nsw i32 %228, %229
%231 = add nsw i32 %227, %230
%232 = load i32, i32* %11
%233 = mul nsw i32 %231, %232
%234 = add nsw i32 %226, %233
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %225, i64 %235
%237 = load double, double* %236
%238 = fadd double %224, %237
%239 = load double*, double** %16
%240 = load i32, i32* %23
%241 = load i32, i32* %25
%242 = load i32, i32* %24
%243 = load i32, i32* %13
%244 = mul nsw i32 %242, %243
%245 = add nsw i32 %241, %244
%246 = load i32, i32* %11
%247 = mul nsw i32 %245, %246
%248 = add nsw i32 %240, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %239, i64 %249
store double %238, double* %250
%251 = load double*, double** %15
%252 = load i32, i32* %23
%253 = load i32, i32* %24
%254 = load i32, i32* %25
%255 = load i32, i32* %12
%256 = mul nsw i32 %254, %255
%257 = add nsw i32 %253, %256
%258 = load i32, i32* %11
%259 = mul nsw i32 %257, %258
%260 = add nsw i32 %252, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %251, i64 %261
%263 = load double, double* %262
%264 = load double*, double** %15
%265 = load i32, i32* %23
%266 = load i32, i32* %27
%267 = load i32, i32* %25
%268 = load i32, i32* %12
%269 = mul nsw i32 %267, %268
%270 = add nsw i32 %266, %269
%271 = load i32, i32* %11
%272 = mul nsw i32 %270, %271
%273 = add nsw i32 %265, %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %264, i64 %274
%276 = load double, double* %275
%277 = fsub double %263, %276
%278 = load double*, double** %16
%279 = load i32, i32* %23
%280 = load i32, i32* %25
%281 = load i32, i32* %27
%282 = load i32, i32* %13
%283 = mul nsw i32 %281, %282
%284 = add nsw i32 %280, %283
%285 = load i32, i32* %11
%286 = mul nsw i32 %284, %285
%287 = add nsw i32 %279, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %278, i64 %288
store double %277, double* %289
br label %290
290: ; preds = %211
%291 = load i32, i32* %25
%292 = add nsw i32 %291, 1
store i32 %292, i32* %25
br label %207
293: ; preds = %207
br label %294
294: ; preds = %293
%295 = load i32, i32* %23
%296 = add nsw i32 %295, 1
store i32 %296, i32* %23
br label %202
297: ; preds = %202
br label %298
298: ; preds = %297
%299 = load i32, i32* %24
%300 = add nsw i32 %299, 1
store i32 %300, i32* %24
br label %194
301: ; preds = %194
store i32 0, i32* %23
br label %302
302: ; preds = %335, %301
%303 = load i32, i32* %23
%304 = load i32, i32* %11
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %338
306: ; preds = %302
store i32 0, i32* %25
br label %307
307: ; preds = %331, %306
%308 = load i32, i32* %25
%309 = load i32, i32* %13
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %334
311: ; preds = %307
%312 = load double*, double** %15
%313 = load i32, i32* %23
%314 = load i32, i32* %25
%315 = load i32, i32* %12
%316 = mul nsw i32 %314, %315
%317 = load i32, i32* %11
%318 = mul nsw i32 %316, %317
%319 = add nsw i32 %313, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %312, i64 %320
%322 = load double, double* %321
%323 = load double*, double** %16
%324 = load i32, i32* %23
%325 = load i32, i32* %25
%326 = load i32, i32* %11
%327 = mul nsw i32 %325, %326
%328 = add nsw i32 %324, %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %323, i64 %329
store double %322, double* %330
br label %331
331: ; preds = %311
%332 = load i32, i32* %25
%333 = add nsw i32 %332, 1
store i32 %333, i32* %25
br label %307
334: ; preds = %307
br label %335
335: ; preds = %334
%336 = load i32, i32* %23
%337 = add nsw i32 %336, 1
store i32 %337, i32* %23
br label %302
338: ; preds = %302
br label %339
339: ; preds = %338, %192
%340 = load i32, i32* %11
%341 = sub nsw i32 2, %340
store i32 %341, i32* %31
store i32 0, i32* %32
store i32 1, i32* %26
br label %342
342: ; preds = %508, %339
%343 = load i32, i32* %26
%344 = load i32, i32* %22
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %511
346: ; preds = %342
%347 = load i32, i32* %12
%348 = load i32, i32* %26
%349 = sub nsw i32 %347, %348
store i32 %349, i32* %28
%350 = load i32, i32* %11
%351 = load i32, i32* %31
%352 = add nsw i32 %351, %350
store i32 %352, i32* %31
store i32 0, i32* %29
br label %353
353: ; preds = %413, %346
%354 = load i32, i32* %29
%355 = load i32, i32* %14
%356 = icmp slt i32 %354, %355
br i1 %356, label %357, label %416
357: ; preds = %353
%358 = load double*, double** %16
%359 = load i32, i32* %29
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %358, i64 %360
%362 = load double, double* %361
%363 = load double*, double** %17
%364 = load i32, i32* %31
%365 = sub nsw i32 %364, 2
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %363, i64 %366
%368 = load double, double* %367
%369 = load double*, double** %16
%370 = load i32, i32* %29
%371 = load i32, i32* %14
%372 = add nsw i32 %370, %371
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %369, i64 %373
%375 = load double, double* %374
%376 = call double @llvm.fmuladd.f64(double %368, double %375, double %362)
%377 = load double*, double** %15
%378 = load i32, i32* %29
%379 = load i32, i32* %26
%380 = load i32, i32* %14
%381 = mul nsw i32 %379, %380
%382 = add nsw i32 %378, %381
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds double, double* %377, i64 %383
store double %376, double* %384
%385 = load i32, i32* %18
%386 = sitofp i32 %385 to double
%387 = load double*, double** %17
%388 = load i32, i32* %31
%389 = sub nsw i32 %388, 1
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %387, i64 %390
%392 = load double, double* %391
%393 = fmul double %386, %392
%394 = load double*, double** %16
%395 = load i32, i32* %29
%396 = load i32, i32* %12
%397 = sub nsw i32 %396, 1
%398 = load i32, i32* %14
%399 = mul nsw i32 %397, %398
%400 = add nsw i32 %395, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %394, i64 %401
%403 = load double, double* %402
%404 = fmul double %393, %403
%405 = load double*, double** %15
%406 = load i32, i32* %29
%407 = load i32, i32* %28
%408 = load i32, i32* %14
%409 = mul nsw i32 %407, %408
%410 = add nsw i32 %406, %409
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %405, i64 %411
store double %404, double* %412
br label %413
413: ; preds = %357
%414 = load i32, i32* %29
%415 = add nsw i32 %414, 1
store i32 %415, i32* %29
br label %353
416: ; preds = %353
%417 = load i32, i32* %31
store i32 %417, i32* %20
%418 = load i32, i32* %11
%419 = load i32, i32* %32
%420 = add nsw i32 %419, %418
store i32 %420, i32* %32
store i32 2, i32* %24
br label %421
421: ; preds = %504, %416
%422 = load i32, i32* %24
%423 = load i32, i32* %22
%424 = icmp slt i32 %422, %423
br i1 %424, label %425, label %507
425: ; preds = %421
%426 = load i32, i32* %12
%427 = load i32, i32* %24
%428 = sub nsw i32 %426, %427
store i32 %428, i32* %27
%429 = load i32, i32* %32
%430 = load i32, i32* %20
%431 = add nsw i32 %430, %429
store i32 %431, i32* %20
%432 = load i32, i32* %20
%433 = load i32, i32* %33
%434 = icmp sgt i32 %432, %433
br i1 %434, label %435, label %439
435: ; preds = %425
%436 = load i32, i32* %33
%437 = load i32, i32* %20
%438 = sub nsw i32 %437, %436
store i32 %438, i32* %20
br label %439
439: ; preds = %435, %425
%440 = load double*, double** %17
%441 = load i32, i32* %20
%442 = sub nsw i32 %441, 2
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %440, i64 %443
%445 = load double, double* %444
store double %445, double* %35
%446 = load double*, double** %17
%447 = load i32, i32* %20
%448 = sub nsw i32 %447, 1
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %446, i64 %449
%451 = load double, double* %450
store double %451, double* %34
store i32 0, i32* %29
br label %452
452: ; preds = %500, %439
%453 = load i32, i32* %29
%454 = load i32, i32* %14
%455 = icmp slt i32 %453, %454
br i1 %455, label %456, label %503
456: ; preds = %452
%457 = load double, double* %35
%458 = load double*, double** %16
%459 = load i32, i32* %29
%460 = load i32, i32* %24
%461 = load i32, i32* %14
%462 = mul nsw i32 %460, %461
%463 = add nsw i32 %459, %462
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %458, i64 %464
%466 = load double, double* %465
%467 = load double*, double** %15
%468 = load i32, i32* %29
%469 = load i32, i32* %26
%470 = load i32, i32* %14
%471 = mul nsw i32 %469, %470
%472 = add nsw i32 %468, %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %467, i64 %473
%475 = load double, double* %474
%476 = call double @llvm.fmuladd.f64(double %457, double %466, double %475)
store double %476, double* %474
%477 = load i32, i32* %18
%478 = sitofp i32 %477 to double
%479 = load double, double* %34
%480 = fmul double %478, %479
%481 = load double*, double** %16
%482 = load i32, i32* %29
%483 = load i32, i32* %27
%484 = load i32, i32* %14
%485 = mul nsw i32 %483, %484
%486 = add nsw i32 %482, %485
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds double, double* %481, i64 %487
%489 = load double, double* %488
%490 = load double*, double** %15
%491 = load i32, i32* %29
%492 = load i32, i32* %28
%493 = load i32, i32* %14
%494 = mul nsw i32 %492, %493
%495 = add nsw i32 %491, %494
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %490, i64 %496
%498 = load double, double* %497
%499 = call double @llvm.fmuladd.f64(double %480, double %489, double %498)
store double %499, double* %497
br label %500
500: ; preds = %456
%501 = load i32, i32* %29
%502 = add nsw i32 %501, 1
store i32 %502, i32* %29
br label %452
503: ; preds = %452
br label %504
504: ; preds = %503
%505 = load i32, i32* %24
%506 = add nsw i32 %505, 1
store i32 %506, i32* %24
br label %421
507: ; preds = %421
br label %508
508: ; preds = %507
%509 = load i32, i32* %26
%510 = add nsw i32 %509, 1
store i32 %510, i32* %26
br label %342
511: ; preds = %342
store i32 1, i32* %24
br label %512
512: ; preds = %541, %511
%513 = load i32, i32* %24
%514 = load i32, i32* %22
%515 = icmp slt i32 %513, %514
br i1 %515, label %516, label %544
516: ; preds = %512
store i32 0, i32* %29
br label %517
517: ; preds = %537, %516
%518 = load i32, i32* %29
%519 = load i32, i32* %14
%520 = icmp slt i32 %518, %519
br i1 %520, label %521, label %540
521: ; preds = %517
%522 = load double*, double** %16
%523 = load i32, i32* %29
%524 = load i32, i32* %24
%525 = load i32, i32* %14
%526 = mul nsw i32 %524, %525
%527 = add nsw i32 %523, %526
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %522, i64 %528
%530 = load double, double* %529
%531 = load double*, double** %16
%532 = load i32, i32* %29
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %531, i64 %533
%535 = load double, double* %534
%536 = fadd double %535, %530
store double %536, double* %534
br label %537
537: ; preds = %521
%538 = load i32, i32* %29
%539 = add nsw i32 %538, 1
store i32 %539, i32* %29
br label %517
540: ; preds = %517
br label %541
541: ; preds = %540
%542 = load i32, i32* %24
%543 = add nsw i32 %542, 1
store i32 %543, i32* %24
br label %512
544: ; preds = %512
store i32 1, i32* %24
br label %545
545: ; preds = %676, %544
%546 = load i32, i32* %24
%547 = load i32, i32* %22
%548 = icmp slt i32 %546, %547
br i1 %548, label %549, label %679
549: ; preds = %545
%550 = load i32, i32* %12
%551 = load i32, i32* %24
%552 = sub nsw i32 %550, %551
store i32 %552, i32* %27
store i32 1, i32* %29
br label %553
553: ; preds = %672, %549
%554 = load i32, i32* %29
%555 = load i32, i32* %14
%556 = icmp slt i32 %554, %555
br i1 %556, label %557, label %675
557: ; preds = %553
%558 = load double*, double** %15
%559 = load i32, i32* %29
%560 = sub nsw i32 %559, 1
%561 = load i32, i32* %24
%562 = load i32, i32* %14
%563 = mul nsw i32 %561, %562
%564 = add nsw i32 %560, %563
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %558, i64 %565
%567 = load double, double* %566
%568 = load double*, double** %15
%569 = load i32, i32* %29
%570 = load i32, i32* %27
%571 = load i32, i32* %14
%572 = mul nsw i32 %570, %571
%573 = add nsw i32 %569, %572
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %568, i64 %574
%576 = load double, double* %575
%577 = fsub double %567, %576
%578 = load double*, double** %16
%579 = load i32, i32* %29
%580 = sub nsw i32 %579, 1
%581 = load i32, i32* %24
%582 = load i32, i32* %14
%583 = mul nsw i32 %581, %582
%584 = add nsw i32 %580, %583
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %578, i64 %585
store double %577, double* %586
%587 = load double*, double** %15
%588 = load i32, i32* %29
%589 = sub nsw i32 %588, 1
%590 = load i32, i32* %24
%591 = load i32, i32* %14
%592 = mul nsw i32 %590, %591
%593 = add nsw i32 %589, %592
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double, double* %587, i64 %594
%596 = load double, double* %595
%597 = load double*, double** %15
%598 = load i32, i32* %29
%599 = load i32, i32* %27
%600 = load i32, i32* %14
%601 = mul nsw i32 %599, %600
%602 = add nsw i32 %598, %601
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds double, double* %597, i64 %603
%605 = load double, double* %604
%606 = fadd double %596, %605
%607 = load double*, double** %16
%608 = load i32, i32* %29
%609 = sub nsw i32 %608, 1
%610 = load i32, i32* %27
%611 = load i32, i32* %14
%612 = mul nsw i32 %610, %611
%613 = add nsw i32 %609, %612
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %607, i64 %614
store double %606, double* %615
%616 = load double*, double** %15
%617 = load i32, i32* %29
%618 = load i32, i32* %24
%619 = load i32, i32* %14
%620 = mul nsw i32 %618, %619
%621 = add nsw i32 %617, %620
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds double, double* %616, i64 %622
%624 = load double, double* %623
%625 = load double*, double** %15
%626 = load i32, i32* %29
%627 = sub nsw i32 %626, 1
%628 = load i32, i32* %27
%629 = load i32, i32* %14
%630 = mul nsw i32 %628, %629
%631 = add nsw i32 %627, %630
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %625, i64 %632
%634 = load double, double* %633
%635 = fadd double %624, %634
%636 = load double*, double** %16
%637 = load i32, i32* %29
%638 = load i32, i32* %24
%639 = load i32, i32* %14
%640 = mul nsw i32 %638, %639
%641 = add nsw i32 %637, %640
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %636, i64 %642
store double %635, double* %643
%644 = load double*, double** %15
%645 = load i32, i32* %29
%646 = load i32, i32* %24
%647 = load i32, i32* %14
%648 = mul nsw i32 %646, %647
%649 = add nsw i32 %645, %648
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %644, i64 %650
%652 = load double, double* %651
%653 = load double*, double** %15
%654 = load i32, i32* %29
%655 = sub nsw i32 %654, 1
%656 = load i32, i32* %27
%657 = load i32, i32* %14
%658 = mul nsw i32 %656, %657
%659 = add nsw i32 %655, %658
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %653, i64 %660
%662 = load double, double* %661
%663 = fsub double %652, %662
%664 = load double*, double** %16
%665 = load i32, i32* %29
%666 = load i32, i32* %27
%667 = load i32, i32* %14
%668 = mul nsw i32 %666, %667
%669 = add nsw i32 %665, %668
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %664, i64 %670
store double %663, double* %671
br label %672
672: ; preds = %557
%673 = load i32, i32* %29
%674 = add nsw i32 %673, 2
store i32 %674, i32* %29
br label %553
675: ; preds = %553
br label %676
676: ; preds = %675
%677 = load i32, i32* %24
%678 = add nsw i32 %677, 1
store i32 %678, i32* %24
br label %545
679: ; preds = %545
%680 = load i32*, i32** %10
store i32 1, i32* %680
%681 = load i32, i32* %11
%682 = icmp eq i32 %681, 2
br i1 %682, label %683, label %684
683: ; preds = %679
br label %1067
684: ; preds = %679
%685 = load i32*, i32** %10
store i32 0, i32* %685
store i32 0, i32* %29
br label %686
686: ; preds = %700, %684
%687 = load i32, i32* %29
%688 = load i32, i32* %14
%689 = icmp slt i32 %687, %688
br i1 %689, label %690, label %703
690: ; preds = %686
%691 = load double*, double** %16
%692 = load i32, i32* %29
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds double, double* %691, i64 %693
%695 = load double, double* %694
%696 = load double*, double** %15
%697 = load i32, i32* %29
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds double, double* %696, i64 %698
store double %695, double* %699
br label %700
700: ; preds = %690
%701 = load i32, i32* %29
%702 = add nsw i32 %701, 1
store i32 %702, i32* %29
br label %686
703: ; preds = %686
store i32 1, i32* %24
br label %704
704: ; preds = %764, %703
%705 = load i32, i32* %24
%706 = load i32, i32* %12
%707 = icmp slt i32 %705, %706
br i1 %707, label %708, label %767
708: ; preds = %704
store i32 0, i32* %25
br label %709
709: ; preds = %760, %708
%710 = load i32, i32* %25
%711 = load i32, i32* %13
%712 = icmp slt i32 %710, %711
br i1 %712, label %713, label %763
713: ; preds = %709
%714 = load double*, double** %16
%715 = load i32, i32* %25
%716 = load i32, i32* %24
%717 = load i32, i32* %13
%718 = mul nsw i32 %716, %717
%719 = add nsw i32 %715, %718
%720 = load i32, i32* %11
%721 = mul nsw i32 %719, %720
%722 = add nsw i32 %721, 0
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %714, i64 %723
%725 = load double, double* %724
%726 = load double*, double** %15
%727 = load i32, i32* %25
%728 = load i32, i32* %24
%729 = load i32, i32* %13
%730 = mul nsw i32 %728, %729
%731 = add nsw i32 %727, %730
%732 = load i32, i32* %11
%733 = mul nsw i32 %731, %732
%734 = add nsw i32 %733, 0
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %726, i64 %735
store double %725, double* %736
%737 = load double*, double** %16
%738 = load i32, i32* %25
%739 = load i32, i32* %24
%740 = load i32, i32* %13
%741 = mul nsw i32 %739, %740
%742 = add nsw i32 %738, %741
%743 = load i32, i32* %11
%744 = mul nsw i32 %742, %743
%745 = add nsw i32 %744, 1
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %737, i64 %746
%748 = load double, double* %747
%749 = load double*, double** %15
%750 = load i32, i32* %25
%751 = load i32, i32* %24
%752 = load i32, i32* %13
%753 = mul nsw i32 %751, %752
%754 = add nsw i32 %750, %753
%755 = load i32, i32* %11
%756 = mul nsw i32 %754, %755
%757 = add nsw i32 %756, 1
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %749, i64 %758
store double %748, double* %759
br label %760
760: ; preds = %713
%761 = load i32, i32* %25
%762 = add nsw i32 %761, 1
store i32 %762, i32* %25
br label %709
763: ; preds = %709
br label %764
764: ; preds = %763
%765 = load i32, i32* %24
%766 = add nsw i32 %765, 1
store i32 %766, i32* %24
br label %704
767: ; preds = %704
%768 = load i32, i32* %21
%769 = load i32, i32* %13
%770 = icmp sle i32 %768, %769
br i1 %770, label %771, label %917
771: ; preds = %767
store i32 0, i32* %19
store i32 1, i32* %24
br label %772
772: ; preds = %913, %771
%773 = load i32, i32* %24
%774 = load i32, i32* %12
%775 = icmp slt i32 %773, %774
br i1 %775, label %776, label %916
776: ; preds = %772
%777 = load i32, i32* %19
%778 = add nsw i32 %777, 2
store i32 %778, i32* %19
store i32 3, i32* %23
br label %779
779: ; preds = %909, %776
%780 = load i32, i32* %23
%781 = load i32, i32* %11
%782 = icmp slt i32 %780, %781
br i1 %782, label %783, label %912
783: ; preds = %779
%784 = load i32, i32* %19
%785 = add nsw i32 %784, 2
store i32 %785, i32* %19
store i32 0, i32* %25
br label %786
786: ; preds = %905, %783
%787 = load i32, i32* %25
%788 = load i32, i32* %13
%789 = icmp slt i32 %787, %788
br i1 %789, label %790, label %908
790: ; preds = %786
%791 = load double*, double** %17
%792 = load i32, i32* %19
%793 = sub nsw i32 %792, 2
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %791, i64 %794
%796 = load double, double* %795
%797 = load double*, double** %16
%798 = load i32, i32* %23
%799 = sub nsw i32 %798, 1
%800 = load i32, i32* %25
%801 = load i32, i32* %24
%802 = load i32, i32* %13
%803 = mul nsw i32 %801, %802
%804 = add nsw i32 %800, %803
%805 = load i32, i32* %11
%806 = mul nsw i32 %804, %805
%807 = add nsw i32 %799, %806
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds double, double* %797, i64 %808
%810 = load double, double* %809
%811 = load i32, i32* %18
%812 = sitofp i32 %811 to double
%813 = load double*, double** %17
%814 = load i32, i32* %19
%815 = sub nsw i32 %814, 1
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds double, double* %813, i64 %816
%818 = load double, double* %817
%819 = fmul double %812, %818
%820 = load double*, double** %16
%821 = load i32, i32* %23
%822 = load i32, i32* %25
%823 = load i32, i32* %24
%824 = load i32, i32* %13
%825 = mul nsw i32 %823, %824
%826 = add nsw i32 %822, %825
%827 = load i32, i32* %11
%828 = mul nsw i32 %826, %827
%829 = add nsw i32 %821, %828
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds double, double* %820, i64 %830
%832 = load double, double* %831
%833 = fmul double %819, %832
%834 = fneg double %833
%835 = call double @llvm.fmuladd.f64(double %796, double %810, double %834)
%836 = load double*, double** %15
%837 = load i32, i32* %23
%838 = sub nsw i32 %837, 1
%839 = load i32, i32* %25
%840 = load i32, i32* %24
%841 = load i32, i32* %13
%842 = mul nsw i32 %840, %841
%843 = add nsw i32 %839, %842
%844 = load i32, i32* %11
%845 = mul nsw i32 %843, %844
%846 = add nsw i32 %838, %845
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds double, double* %836, i64 %847
store double %835, double* %848
%849 = load double*, double** %17
%850 = load i32, i32* %19
%851 = sub nsw i32 %850, 2
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds double, double* %849, i64 %852
%854 = load double, double* %853
%855 = load double*, double** %16
%856 = load i32, i32* %23
%857 = load i32, i32* %25
%858 = load i32, i32* %24
%859 = load i32, i32* %13
%860 = mul nsw i32 %858, %859
%861 = add nsw i32 %857, %860
%862 = load i32, i32* %11
%863 = mul nsw i32 %861, %862
%864 = add nsw i32 %856, %863
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %855, i64 %865
%867 = load double, double* %866
%868 = load i32, i32* %18
%869 = sitofp i32 %868 to double
%870 = load double*, double** %17
%871 = load i32, i32* %19
%872 = sub nsw i32 %871, 1
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds double, double* %870, i64 %873
%875 = load double, double* %874
%876 = fmul double %869, %875
%877 = load double*, double** %16
%878 = load i32, i32* %23
%879 = sub nsw i32 %878, 1
%880 = load i32, i32* %25
%881 = load i32, i32* %24
%882 = load i32, i32* %13
%883 = mul nsw i32 %881, %882
%884 = add nsw i32 %880, %883
%885 = load i32, i32* %11
%886 = mul nsw i32 %884, %885
%887 = add nsw i32 %879, %886
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds double, double* %877, i64 %888
%890 = load double, double* %889
%891 = fmul double %876, %890
%892 = call double @llvm.fmuladd.f64(double %854, double %867, double %891)
%893 = load double*, double** %15
%894 = load i32, i32* %23
%895 = load i32, i32* %25
%896 = load i32, i32* %24
%897 = load i32, i32* %13
%898 = mul nsw i32 %896, %897
%899 = add nsw i32 %895, %898
%900 = load i32, i32* %11
%901 = mul nsw i32 %899, %900
%902 = add nsw i32 %894, %901
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds double, double* %893, i64 %903
store double %892, double* %904
br label %905
905: ; preds = %790
%906 = load i32, i32* %25
%907 = add nsw i32 %906, 1
store i32 %907, i32* %25
br label %786
908: ; preds = %786
br label %909
909: ; preds = %908
%910 = load i32, i32* %23
%911 = add nsw i32 %910, 2
store i32 %911, i32* %23
br label %779
912: ; preds = %779
br label %913
913: ; preds = %912
%914 = load i32, i32* %24
%915 = add nsw i32 %914, 1
store i32 %915, i32* %24
br label %772
916: ; preds = %772
br label %1067
917: ; preds = %767
%918 = load i32, i32* %11
%919 = sub nsw i32 2, %918
store i32 %919, i32* %30
store i32 1, i32* %24
br label %920
920: ; preds = %1063, %917
%921 = load i32, i32* %24
%922 = load i32, i32* %12
%923 = icmp slt i32 %921, %922
br i1 %923, label %924, label %1066
924: ; preds = %920
%925 = load i32, i32* %11
%926 = load i32, i32* %30
%927 = add nsw i32 %926, %925
store i32 %927, i32* %30
store i32 0, i32* %25
br label %928
928: ; preds = %1059, %924
%929 = load i32, i32* %25
%930 = load i32, i32* %13
%931 = icmp slt i32 %929, %930
br i1 %931, label %932, label %1062
932: ; preds = %928
%933 = load i32, i32* %30
store i32 %933, i32* %19
store i32 3, i32* %23
br label %934
934: ; preds = %1055, %932
%935 = load i32, i32* %23
%936 = load i32, i32* %11
%937 = icmp slt i32 %935, %936
br i1 %937, label %938, label %1058
938: ; preds = %934
%939 = load i32, i32* %19
%940 = add nsw i32 %939, 2
store i32 %940, i32* %19
%941 = load double*, double** %17
%942 = load i32, i32* %19
%943 = sub nsw i32 %942, 2
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %941, i64 %944
%946 = load double, double* %945
%947 = load double*, double** %16
%948 = load i32, i32* %23
%949 = sub nsw i32 %948, 1
%950 = load i32, i32* %25
%951 = load i32, i32* %24
%952 = load i32, i32* %13
%953 = mul nsw i32 %951, %952
%954 = add nsw i32 %950, %953
%955 = load i32, i32* %11
%956 = mul nsw i32 %954, %955
%957 = add nsw i32 %949, %956
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds double, double* %947, i64 %958
%960 = load double, double* %959
%961 = load i32, i32* %18
%962 = sitofp i32 %961 to double
%963 = load double*, double** %17
%964 = load i32, i32* %19
%965 = sub nsw i32 %964, 1
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds double, double* %963, i64 %966
%968 = load double, double* %967
%969 = fmul double %962, %968
%970 = load double*, double** %16
%971 = load i32, i32* %23
%972 = load i32, i32* %25
%973 = load i32, i32* %24
%974 = load i32, i32* %13
%975 = mul nsw i32 %973, %974
%976 = add nsw i32 %972, %975
%977 = load i32, i32* %11
%978 = mul nsw i32 %976, %977
%979 = add nsw i32 %971, %978
%980 = sext i32 %979 to i64
%981 = getelementptr inbounds double, double* %970, i64 %980
%982 = load double, double* %981
%983 = fmul double %969, %982
%984 = fneg double %983
%985 = call double @llvm.fmuladd.f64(double %946, double %960, double %984)
%986 = load double*, double** %15
%987 = load i32, i32* %23
%988 = sub nsw i32 %987, 1
%989 = load i32, i32* %25
%990 = load i32, i32* %24
%991 = load i32, i32* %13
%992 = mul nsw i32 %990, %991
%993 = add nsw i32 %989, %992
%994 = load i32, i32* %11
%995 = mul nsw i32 %993, %994
%996 = add nsw i32 %988, %995
%997 = sext i32 %996 to i64
%998 = getelementptr inbounds double, double* %986, i64 %997
store double %985, double* %998
%999 = load double*, double** %17
%1000 = load i32, i32* %19
%1001 = sub nsw i32 %1000, 2
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %999, i64 %1002
%1004 = load double, double* %1003
%1005 = load double*, double** %16
%1006 = load i32, i32* %23
%1007 = load i32, i32* %25
%1008 = load i32, i32* %24
%1009 = load i32, i32* %13
%1010 = mul nsw i32 %1008, %1009
%1011 = add nsw i32 %1007, %1010
%1012 = load i32, i32* %11
%1013 = mul nsw i32 %1011, %1012
%1014 = add nsw i32 %1006, %1013
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds double, double* %1005, i64 %1015
%1017 = load double, double* %1016
%1018 = load i32, i32* %18
%1019 = sitofp i32 %1018 to double
%1020 = load double*, double** %17
%1021 = load i32, i32* %19
%1022 = sub nsw i32 %1021, 1
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds double, double* %1020, i64 %1023
%1025 = load double, double* %1024
%1026 = fmul double %1019, %1025
%1027 = load double*, double** %16
%1028 = load i32, i32* %23
%1029 = sub nsw i32 %1028, 1
%1030 = load i32, i32* %25
%1031 = load i32, i32* %24
%1032 = load i32, i32* %13
%1033 = mul nsw i32 %1031, %1032
%1034 = add nsw i32 %1030, %1033
%1035 = load i32, i32* %11
%1036 = mul nsw i32 %1034, %1035
%1037 = add nsw i32 %1029, %1036
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds double, double* %1027, i64 %1038
%1040 = load double, double* %1039
%1041 = fmul double %1026, %1040
%1042 = call double @llvm.fmuladd.f64(double %1004, double %1017, double %1041)
%1043 = load double*, double** %15
%1044 = load i32, i32* %23
%1045 = load i32, i32* %25
%1046 = load i32, i32* %24
%1047 = load i32, i32* %13
%1048 = mul nsw i32 %1046, %1047
%1049 = add nsw i32 %1045, %1048
%1050 = load i32, i32* %11
%1051 = mul nsw i32 %1049, %1050
%1052 = add nsw i32 %1044, %1051
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds double, double* %1043, i64 %1053
store double %1042, double* %1054
br label %1055
1055: ; preds = %938
%1056 = load i32, i32* %23
%1057 = add nsw i32 %1056, 2
store i32 %1057, i32* %23
br label %934
1058: ; preds = %934
br label %1059
1059: ; preds = %1058
%1060 = load i32, i32* %25
%1061 = add nsw i32 %1060, 1
store i32 %1061, i32* %25
br label %928
1062: ; preds = %928
br label %1063
1063: ; preds = %1062
%1064 = load i32, i32* %24
%1065 = add nsw i32 %1064, 1
store i32 %1065, i32* %24
br label %920
1066: ; preds = %920
br label %1067
1067: ; preds = %683, %1066, %916
ret void
}

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