int pcapack_sweep(const int m, const int n, double *restrict x,
                  double *restrict vec, const int lvec, const int margin,
                  const int fun) {
  int i, j;
  int pos;
  double tmp;
  if (m == 0 || n == 0)
    return 0;
  if (margin != 1 && margin != 2)
    return -6;
  if (fun != 1 && fun != 2 && fun != 3 && fun != 4)
    return -7;
  if (margin == 1 && lvec == m) {
    if (fun == 1) {
      for (j = 0; j < n; j++) {
        for (i = 0; i < m; i++) {
          x[i + m * j] += vec[i];
        }
      };
    } else if (fun == 2) {
      for (j = 0; j < n; j++) {
        for (i = 0; i < m; i++) {
          x[i + m * j] -= vec[i];
        }
      };
    } else if (fun == 3) {
      for (j = 0; j < n; j++) {
        for (i = 0; i < m; i++) {
          x[i + m * j] *= vec[i];
        }
      };
    } else if (fun == 4) {
      for (j = 0; j < n; j++) {
        for (i = 0; i < m; i++) {
          x[i + m * j] /= vec[i];
        }
      };
    }
  } else if (margin == 2 && lvec == n) {
    if (fun == 1) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
      for (j = 0; j < n; j++) {
        tmp = vec[j];
        for (i = 0; i < m; i++) {
          x[i + m * j] += tmp;
        }
      };
    } else if (fun == 2) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
      for (j = 0; j < n; j++) {
        tmp = vec[j];
        for (i = 0; i < m; i++) {
          x[i + m * j] -= tmp;
        }
      };
    } else if (fun == 3) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
      for (j = 0; j < n; j++) {
        tmp = vec[j];
        for (i = 0; i < m; i++) {
          x[i + m * j] *= tmp;
        }
      };
    }
    if (fun == 4) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
      for (j = 0; j < n; j++) {
        tmp = vec[j];
        for (i = 0; i < m; i++) {
          x[i + m * j] /= tmp;
        }
      };
    }
  } else {
    if (fun == 1) {
      if (margin == 1) {
        pos = 1;
        for (j = 0; j < n; j++) {
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + 1) % lvec;
          }
        };
      } else if (margin == 2) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
        for (j = 0; j < n; j++) {
          pos = j % lvec;
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + n) % lvec;
          }
        };
      }
    } else if (fun == 2) {
      if (margin == 1) {
        pos = 1;
        for (j = 0; j < n; j++) {
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + 1) % lvec;
          }
        };
      } else if (margin == 2) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
        for (j = 0; j < n; j++) {
          pos = j % lvec;
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + n) % lvec;
          }
        };
      }
    } else if (fun == 3) {
      if (margin == 1) {
        pos = 1;
        for (j = 0; j < n; j++) {
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + 1) % lvec;
          }
        };
      } else if (margin == 2) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
        for (j = 0; j < n; j++) {
          pos = j % lvec;
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + n) % lvec;
          }
        };
      }
    } else if (fun == 4) {
      if (margin == 1) {
        pos = 1;
        for (j = 0; j < n; j++) {
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + 1) % lvec;
          }
        };
      } else if (margin == 2) {

#pragma omp parallel for default(shared) private(i, j, tmp) if (m * n >        \
                                                                OMP_MIN_SIZE)
        for (j = 0; j < n; j++) {
          pos = j % lvec;
          for (i = 0; i < m; i++) {
            x[i + m * j] += vec[pos];
            pos = (pos + n) % lvec;
          }
        };
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<pcapack_sweep>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
cmpl   $0x0,-0x8(%rbp)
je     1131 <pcapack_sweep+0x31>
cmpl   $0x0,-0xc(%rbp)
jne    113d <pcapack_sweep+0x3d>
movl   $0x0,-0x4(%rbp)
jmp    1b34 <pcapack_sweep+0xa34>
cmpl   $0x1,-0x28(%rbp)
je     115d <pcapack_sweep+0x5d>
cmpl   $0x2,-0x28(%rbp)
je     115d <pcapack_sweep+0x5d>
movl   $0xfffffffa,-0x4(%rbp)
jmp    1b34 <pcapack_sweep+0xa34>
cmpl   $0x1,0x10(%rbp)
je     1191 <pcapack_sweep+0x91>
cmpl   $0x2,0x10(%rbp)
je     1191 <pcapack_sweep+0x91>
cmpl   $0x3,0x10(%rbp)
je     1191 <pcapack_sweep+0x91>
cmpl   $0x4,0x10(%rbp)
je     1191 <pcapack_sweep+0x91>
movl   $0xfffffff9,-0x4(%rbp)
jmp    1b34 <pcapack_sweep+0xa34>
cmpl   $0x1,-0x28(%rbp)
jne    13c3 <pcapack_sweep+0x2c3>
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    13c3 <pcapack_sweep+0x2c3>
cmpl   $0x1,0x10(%rbp)
jne    1227 <pcapack_sweep+0x127>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1222 <pcapack_sweep+0x122>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    120f <pcapack_sweep+0x10f>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cb <pcapack_sweep+0xcb>
jmp    1214 <pcapack_sweep+0x114>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11b8 <pcapack_sweep+0xb8>
jmp    13be <pcapack_sweep+0x2be>
cmpl   $0x2,0x10(%rbp)
jne    12ab <pcapack_sweep+0x1ab>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a6 <pcapack_sweep+0x1a6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1293 <pcapack_sweep+0x193>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    124b <pcapack_sweep+0x14b>
jmp    1298 <pcapack_sweep+0x198>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1238 <pcapack_sweep+0x138>
jmp    13b9 <pcapack_sweep+0x2b9>
cmpl   $0x3,0x10(%rbp)
jne    132b <pcapack_sweep+0x22b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1326 <pcapack_sweep+0x226>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1313 <pcapack_sweep+0x213>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12cf <pcapack_sweep+0x1cf>
jmp    1318 <pcapack_sweep+0x218>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12bc <pcapack_sweep+0x1bc>
jmp    13b4 <pcapack_sweep+0x2b4>
cmpl   $0x4,0x10(%rbp)
jne    13af <pcapack_sweep+0x2af>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13aa <pcapack_sweep+0x2aa>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1397 <pcapack_sweep+0x297>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    134f <pcapack_sweep+0x24f>
jmp    139c <pcapack_sweep+0x29c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    133c <pcapack_sweep+0x23c>
jmp    13af <pcapack_sweep+0x2af>
jmp    13b4 <pcapack_sweep+0x2b4>
jmp    13b9 <pcapack_sweep+0x2b9>
jmp    13be <pcapack_sweep+0x2be>
jmp    1b2d <pcapack_sweep+0xa2d>
cmpl   $0x2,-0x28(%rbp)
jne    1618 <pcapack_sweep+0x518>
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1618 <pcapack_sweep+0x518>
cmpl   $0x1,0x10(%rbp)
jne    1463 <pcapack_sweep+0x363>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    145e <pcapack_sweep+0x35e>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    144b <pcapack_sweep+0x34b>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    140f <pcapack_sweep+0x30f>
jmp    1450 <pcapack_sweep+0x350>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ea <pcapack_sweep+0x2ea>
jmp    1585 <pcapack_sweep+0x485>
cmpl   $0x2,0x10(%rbp)
jne    14f1 <pcapack_sweep+0x3f1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ec <pcapack_sweep+0x3ec>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d9 <pcapack_sweep+0x3d9>
movsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1499 <pcapack_sweep+0x399>
jmp    14de <pcapack_sweep+0x3de>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1474 <pcapack_sweep+0x374>
jmp    1580 <pcapack_sweep+0x480>
cmpl   $0x3,0x10(%rbp)
jne    157b <pcapack_sweep+0x47b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1576 <pcapack_sweep+0x476>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1563 <pcapack_sweep+0x463>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1527 <pcapack_sweep+0x427>
jmp    1568 <pcapack_sweep+0x468>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1502 <pcapack_sweep+0x402>
jmp    157b <pcapack_sweep+0x47b>
jmp    1580 <pcapack_sweep+0x480>
jmp    1585 <pcapack_sweep+0x485>
cmpl   $0x4,0x10(%rbp)
jne    1613 <pcapack_sweep+0x513>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    160e <pcapack_sweep+0x50e>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15fb <pcapack_sweep+0x4fb>
movsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15bb <pcapack_sweep+0x4bb>
jmp    1600 <pcapack_sweep+0x500>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1596 <pcapack_sweep+0x496>
jmp    1613 <pcapack_sweep+0x513>
jmp    1b28 <pcapack_sweep+0xa28>
cmpl   $0x1,0x10(%rbp)
jne    1757 <pcapack_sweep+0x657>
cmpl   $0x1,-0x28(%rbp)
jne    16b6 <pcapack_sweep+0x5b6>
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16b1 <pcapack_sweep+0x5b1>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    169e <pcapack_sweep+0x59e>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164d <pcapack_sweep+0x54d>
jmp    16a3 <pcapack_sweep+0x5a3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    163a <pcapack_sweep+0x53a>
jmp    1752 <pcapack_sweep+0x652>
cmpl   $0x2,-0x28(%rbp)
jne    174d <pcapack_sweep+0x64d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1748 <pcapack_sweep+0x648>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1735 <pcapack_sweep+0x635>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16e4 <pcapack_sweep+0x5e4>
jmp    173a <pcapack_sweep+0x63a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c7 <pcapack_sweep+0x5c7>
jmp    174d <pcapack_sweep+0x64d>
jmp    1752 <pcapack_sweep+0x652>
jmp    1b23 <pcapack_sweep+0xa23>
cmpl   $0x2,0x10(%rbp)
jne    1896 <pcapack_sweep+0x796>
cmpl   $0x1,-0x28(%rbp)
jne    17f5 <pcapack_sweep+0x6f5>
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17f0 <pcapack_sweep+0x6f0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17dd <pcapack_sweep+0x6dd>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    178c <pcapack_sweep+0x68c>
jmp    17e2 <pcapack_sweep+0x6e2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1779 <pcapack_sweep+0x679>
jmp    1891 <pcapack_sweep+0x791>
cmpl   $0x2,-0x28(%rbp)
jne    188c <pcapack_sweep+0x78c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1887 <pcapack_sweep+0x787>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1874 <pcapack_sweep+0x774>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1823 <pcapack_sweep+0x723>
jmp    1879 <pcapack_sweep+0x779>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1806 <pcapack_sweep+0x706>
jmp    188c <pcapack_sweep+0x78c>
jmp    1891 <pcapack_sweep+0x791>
jmp    1b1e <pcapack_sweep+0xa1e>
cmpl   $0x3,0x10(%rbp)
jne    19d5 <pcapack_sweep+0x8d5>
cmpl   $0x1,-0x28(%rbp)
jne    1934 <pcapack_sweep+0x834>
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    192f <pcapack_sweep+0x82f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    191c <pcapack_sweep+0x81c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18cb <pcapack_sweep+0x7cb>
jmp    1921 <pcapack_sweep+0x821>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18b8 <pcapack_sweep+0x7b8>
jmp    19d0 <pcapack_sweep+0x8d0>
cmpl   $0x2,-0x28(%rbp)
jne    19cb <pcapack_sweep+0x8cb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19c6 <pcapack_sweep+0x8c6>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19b3 <pcapack_sweep+0x8b3>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1962 <pcapack_sweep+0x862>
jmp    19b8 <pcapack_sweep+0x8b8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1945 <pcapack_sweep+0x845>
jmp    19cb <pcapack_sweep+0x8cb>
jmp    19d0 <pcapack_sweep+0x8d0>
jmp    1b19 <pcapack_sweep+0xa19>
cmpl   $0x4,0x10(%rbp)
jne    1b14 <pcapack_sweep+0xa14>
cmpl   $0x1,-0x28(%rbp)
jne    1a73 <pcapack_sweep+0x973>
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a6e <pcapack_sweep+0x96e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1a5b <pcapack_sweep+0x95b>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a0a <pcapack_sweep+0x90a>
jmp    1a60 <pcapack_sweep+0x960>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19f7 <pcapack_sweep+0x8f7>
jmp    1b0f <pcapack_sweep+0xa0f>
cmpl   $0x2,-0x28(%rbp)
jne    1b0a <pcapack_sweep+0xa0a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b05 <pcapack_sweep+0xa05>
mov    -0x30(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1af2 <pcapack_sweep+0x9f2>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1aa1 <pcapack_sweep+0x9a1>
jmp    1af7 <pcapack_sweep+0x9f7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a84 <pcapack_sweep+0x984>
jmp    1b0a <pcapack_sweep+0xa0a>
jmp    1b0f <pcapack_sweep+0xa0f>
jmp    1b14 <pcapack_sweep+0xa14>
jmp    1b19 <pcapack_sweep+0xa19>
jmp    1b1e <pcapack_sweep+0xa1e>
jmp    1b23 <pcapack_sweep+0xa23>
jmp    1b28 <pcapack_sweep+0xa28>
jmp    1b2d <pcapack_sweep+0xa2d>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<pcapack_sweep>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
je     1c6f <pcapack_sweep+0xb6f>
test   %esi,%esi
je     1c6f <pcapack_sweep+0xb6f>
mov    %rdx,%r15
lea    -0x3(%r9),%edx
mov    $0xfffffffa,%eax
cmp    $0xfffffffe,%edx
jb     1c71 <pcapack_sweep+0xb71>
mov    0x38(%rsp),%r12d
lea    -0x5(%r12),%edx
mov    $0xfffffff9,%eax
cmp    $0xfffffffc,%edx
jb     1c71 <pcapack_sweep+0xb71>
cmp    %edi,%r8d
jne    12e9 <pcapack_sweep+0x1e9>
cmp    $0x1,%r9d
jne    12e9 <pcapack_sweep+0x1e9>
add    $0xffffffff,%r12d
cmp    $0x3,%r12d
ja     1c6f <pcapack_sweep+0xb6f>
lea    0x1eb1(%rip),%rax
movslq (%rax,%r12,4),%rdx
add    %rax,%rdx
jmp    *%rdx
mov    $0x0,%eax
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r12d
mov    %edi,%edx
mov    %edx,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%r14
mov    %r14,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
lea    0x30(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r13
xor    %esi,%esi
mov    %r15,%rbp
jmp    11e5 <pcapack_sweep+0xe5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    %r13,%rbx
add    %r13,%rbp
xor    %eax,%eax
cmp    %r12,%rsi
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    11d0 <pcapack_sweep+0xd0>
cmp    $0x4,%edi
jae    11f5 <pcapack_sweep+0xf5>
xor    %eax,%eax
jmp    12c0 <pcapack_sweep+0x1c0>
test   %r14,%r14
je     12df <pcapack_sweep+0x1df>
mov    %r8,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movupd -0x30(%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rbx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm3
movupd %xmm2,-0x30(%rbx,%rax,8)
movupd %xmm0,-0x20(%rbx,%rax,8)
movupd 0x20(%rcx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x30(%rcx,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbx,%rax,8)
movupd %xmm1,(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    1210 <pcapack_sweep+0x110>
test   $0x1,%r11b
je     12ae <pcapack_sweep+0x1ae>
mov    %rsi,%r10
imul   -0x20(%rsp),%r10
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
add    %rax,%r10
movupd (%r15,%r10,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r15,%r10,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%r10,8)
movupd %xmm0,0x10(%r15,%r10,8)
mov    %r9,%rax
cmp    %rdx,%r9
je     11d0 <pcapack_sweep+0xd0>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    12c0 <pcapack_sweep+0x1c0>
jmp    11d0 <pcapack_sweep+0xd0>
xor    %eax,%eax
test   $0x1,%r11b
jne    1275 <pcapack_sweep+0x175>
jmp    12ae <pcapack_sweep+0x1ae>
cmp    %esi,%r8d
jne    146e <pcapack_sweep+0x36e>
cmp    $0x2,%r9d
jne    146e <pcapack_sweep+0x36e>
lea    -0x1(%r12),%eax
cmp    $0x3,%eax
ja     1c6f <pcapack_sweep+0xb6f>
lea    0x1cff(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add    %rdx,%rax
jmp    *%rax
test   %esi,%esi
jle    1c6f <pcapack_sweep+0xb6f>
movslq %edi,%rdx
mov    %esi,%r9d
mov    %edi,%eax
mov    %eax,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rbp
mov    %rbp,-0x20(%rsp)
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rbp
mov    %rbx,-0x18(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x8(%rsp)
lea    0x30(%r15),%rbp
mov    %rdx,-0x10(%rsp)
lea    0x0(,%rdx,8),%r13
xor    %ebx,%ebx
mov    %r15,%r11
jmp    1381 <pcapack_sweep+0x281>
add    $0x1,%rbx
add    %r13,%rbp
add    %r13,%r11
cmp    %r9,%rbx
je     1c1e <pcapack_sweep+0xb1e>
test   %edi,%edi
jle    136e <pcapack_sweep+0x26e>
movsd  (%rcx,%rbx,8),%xmm0
cmp    $0x4,%edi
jae    1396 <pcapack_sweep+0x296>
xor    %edx,%edx
jmp    1450 <pcapack_sweep+0x350>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x20(%rsp)
je     1404 <pcapack_sweep+0x304>
mov    -0x8(%rsp),%r14
xor    %r8d,%r8d
xchg   %ax,%ax
movupd -0x30(%rbp,%r8,8),%xmm2
movupd -0x20(%rbp,%r8,8),%xmm3
movupd -0x10(%rbp,%r8,8),%xmm4
movupd 0x0(%rbp,%r8,8),%xmm5
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbp,%r8,8)
movupd %xmm3,-0x20(%rbp,%r8,8)
addpd  %xmm1,%xmm4
addpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rbp,%r8,8)
movupd %xmm5,0x0(%rbp,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r14
jne    13b0 <pcapack_sweep+0x2b0>
jmp    1407 <pcapack_sweep+0x307>
xor    %r8d,%r8d
testb  $0x1,-0x18(%rsp)
je     143c <pcapack_sweep+0x33c>
mov    %rbx,%rdx
imul   -0x10(%rsp),%rdx
add    %rdx,%r8
movupd (%r15,%r8,8),%xmm2
movupd 0x10(%r15,%r8,8),%xmm3
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%r8,8)
movupd %xmm3,0x10(%r15,%r8,8)
mov    %r10,%rdx
cmp    %rax,%r10
je     136e <pcapack_sweep+0x26e>
nopl   0x0(%rax,%rax,1)
movsd  (%r11,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r11,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1450 <pcapack_sweep+0x350>
jmp    136e <pcapack_sweep+0x26e>
add    $0xffffffff,%r12d
cmp    $0x3,%r12d
ja     1c6f <pcapack_sweep+0xb6f>
lea    0x1b7d(%rip),%rax
movslq (%rax,%r12,4),%rdx
add    %rax,%rdx
jmp    *%rdx
mov    $0x0,%eax
cmp    $0x1,%r9d
jne    1fbd <pcapack_sweep+0xebd>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%r9
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%ebp
and    $0xfffffffe,%ebp
lea    0x8(%r15),%rbx
lea    0x0(,%r9,8),%r14
mov    $0x1,%edx
xor    %r12d,%r12d
jmp    14da <pcapack_sweep+0x3da>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    14c8 <pcapack_sweep+0x3c8>
xor    %esi,%esi
cmp    $0x1,%edi
je     152d <pcapack_sweep+0x42d>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    14f0 <pcapack_sweep+0x3f0>
test   $0x1,%r10b
je     14c8 <pcapack_sweep+0x3c8>
mov    %r12,%r13
imul   %r9,%r13
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r13,%rsi
addsd  (%r15,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
jmp    14c8 <pcapack_sweep+0x3c8>
mov    $0x0,%eax
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r12d
mov    %edi,%edx
mov    %edx,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%r14
mov    %r14,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
lea    0x30(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r13
xor    %esi,%esi
mov    %r15,%rbp
jmp    15c5 <pcapack_sweep+0x4c5>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %r13,%rbx
add    %r13,%rbp
xor    %eax,%eax
cmp    %r12,%rsi
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    15b0 <pcapack_sweep+0x4b0>
cmp    $0x4,%edi
jae    15d5 <pcapack_sweep+0x4d5>
xor    %eax,%eax
jmp    16a0 <pcapack_sweep+0x5a0>
test   %r14,%r14
je     16bf <pcapack_sweep+0x5bf>
mov    %r8,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movupd -0x30(%rbx,%rax,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rax,8),%xmm0
subpd  %xmm1,%xmm0
movupd -0x10(%rbx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm3
movupd %xmm2,-0x30(%rbx,%rax,8)
movupd %xmm0,-0x20(%rbx,%rax,8)
movupd 0x20(%rcx,%rax,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x30(%rcx,%rax,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rbx,%rax,8)
movupd %xmm3,(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    15f0 <pcapack_sweep+0x4f0>
test   $0x1,%r11b
je     168e <pcapack_sweep+0x58e>
mov    %rsi,%r10
imul   -0x20(%rsp),%r10
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
add    %rax,%r10
movupd (%r15,%r10,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r15,%r10,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%r10,8)
movupd %xmm0,0x10(%r15,%r10,8)
mov    %r9,%rax
cmp    %rdx,%r9
je     15b0 <pcapack_sweep+0x4b0>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
subsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    16a0 <pcapack_sweep+0x5a0>
jmp    15b0 <pcapack_sweep+0x4b0>
xor    %eax,%eax
test   $0x1,%r11b
jne    1655 <pcapack_sweep+0x555>
jmp    168e <pcapack_sweep+0x58e>
mov    $0x0,%eax
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r12d
mov    %edi,%edx
mov    %edx,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%r14
mov    %r14,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
lea    0x30(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r13
xor    %esi,%esi
mov    %r15,%rbp
jmp    1735 <pcapack_sweep+0x635>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
add    %r13,%rbx
add    %r13,%rbp
xor    %eax,%eax
cmp    %r12,%rsi
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1720 <pcapack_sweep+0x620>
cmp    $0x4,%edi
jae    1745 <pcapack_sweep+0x645>
xor    %eax,%eax
jmp    1810 <pcapack_sweep+0x710>
test   %r14,%r14
je     182f <pcapack_sweep+0x72f>
mov    %r8,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movupd -0x30(%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd -0x10(%rbx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm3
movupd %xmm2,-0x30(%rbx,%rax,8)
movupd %xmm0,-0x20(%rbx,%rax,8)
movupd 0x20(%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x30(%rcx,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbx,%rax,8)
movupd %xmm1,(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    1760 <pcapack_sweep+0x660>
test   $0x1,%r11b
je     17fe <pcapack_sweep+0x6fe>
mov    %rsi,%r10
imul   -0x20(%rsp),%r10
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
add    %rax,%r10
movupd (%r15,%r10,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r15,%r10,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%r10,8)
movupd %xmm0,0x10(%r15,%r10,8)
mov    %r9,%rax
cmp    %rdx,%r9
je     1720 <pcapack_sweep+0x620>
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1810 <pcapack_sweep+0x710>
jmp    1720 <pcapack_sweep+0x620>
xor    %eax,%eax
test   $0x1,%r11b
jne    17c5 <pcapack_sweep+0x6c5>
jmp    17fe <pcapack_sweep+0x6fe>
mov    $0x0,%eax
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r12d
mov    %edi,%ebx
mov    %ebx,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%r9
mov    %r9,%r11
shr    %r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
lea    0x10(%r15),%rdx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r13
xor    %esi,%esi
mov    %r15,%rbp
jmp    18a5 <pcapack_sweep+0x7a5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    %r13,%rdx
add    %r13,%rbp
xor    %eax,%eax
cmp    %r12,%rsi
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1890 <pcapack_sweep+0x790>
cmp    $0x1,%edi
jne    18b5 <pcapack_sweep+0x7b5>
xor    %eax,%eax
jmp    1940 <pcapack_sweep+0x840>
test   %r9,%r9
je     195f <pcapack_sweep+0x85f>
mov    %r8,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rcx,%rax,8),%xmm0
movupd -0x10(%rdx,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd (%rdx,%rax,8),%xmm0
movupd %xmm1,-0x10(%rdx,%rax,8)
movupd 0x10(%rcx,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%r10
jne    18d0 <pcapack_sweep+0x7d0>
test   $0x1,%r11b
je     192a <pcapack_sweep+0x82a>
mov    %rsi,%r10
imul   -0x20(%rsp),%r10
movupd (%rcx,%rax,8),%xmm0
add    %rax,%r10
movupd (%r15,%r10,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r15,%r10,8)
mov    %r14,%rax
cmp    %rbx,%r14
je     1890 <pcapack_sweep+0x790>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
divsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1940 <pcapack_sweep+0x840>
jmp    1890 <pcapack_sweep+0x790>
xor    %eax,%eax
test   $0x1,%r11b
jne    1909 <pcapack_sweep+0x809>
jmp    192a <pcapack_sweep+0x82a>
test   %esi,%esi
jle    1c6f <pcapack_sweep+0xb6f>
movslq %edi,%rdx
mov    %esi,%r9d
mov    %edi,%eax
mov    %eax,%r14d
and    $0xfffffffc,%r14d
lea    -0x4(%r14),%rbp
mov    %rbp,-0x20(%rsp)
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rbp
mov    %rbx,-0x18(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x8(%rsp)
lea    0x30(%r15),%rbp
mov    %rdx,-0x10(%rsp)
lea    0x0(,%rdx,8),%r13
xor    %ebx,%ebx
mov    %r15,%r10
jmp    19d0 <pcapack_sweep+0x8d0>
add    $0x1,%rbx
add    %r13,%rbp
add    %r13,%r10
cmp    %r9,%rbx
je     1c1e <pcapack_sweep+0xb1e>
test   %edi,%edi
jle    19bd <pcapack_sweep+0x8bd>
movsd  (%rcx,%rbx,8),%xmm0
cmp    $0x4,%edi
jae    19e5 <pcapack_sweep+0x8e5>
xor    %edx,%edx
jmp    1aa0 <pcapack_sweep+0x9a0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x20(%rsp)
je     1a54 <pcapack_sweep+0x954>
mov    -0x8(%rsp),%r8
xor    %r11d,%r11d
nopl   (%rax)
movupd -0x30(%rbp,%r11,8),%xmm2
movupd -0x20(%rbp,%r11,8),%xmm3
movupd -0x10(%rbp,%r11,8),%xmm4
movupd 0x0(%rbp,%r11,8),%xmm5
subpd  %xmm1,%xmm2
subpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbp,%r11,8)
movupd %xmm3,-0x20(%rbp,%r11,8)
subpd  %xmm1,%xmm4
subpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rbp,%r11,8)
movupd %xmm5,0x0(%rbp,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%r8
jne    1a00 <pcapack_sweep+0x900>
jmp    1a57 <pcapack_sweep+0x957>
xor    %r11d,%r11d
testb  $0x1,-0x18(%rsp)
je     1a8c <pcapack_sweep+0x98c>
mov    %rbx,%rdx
imul   -0x10(%rsp),%rdx
add    %rdx,%r11
movupd (%r15,%r11,8),%xmm2
movupd 0x10(%r15,%r11,8),%xmm3
subpd  %xmm1,%xmm2
subpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%r11,8)
movupd %xmm3,0x10(%r15,%r11,8)
mov    %r14,%rdx
cmp    %rax,%r14
je     19bd <pcapack_sweep+0x8bd>
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1aa0 <pcapack_sweep+0x9a0>
jmp    19bd <pcapack_sweep+0x8bd>
test   %esi,%esi
jle    1c6f <pcapack_sweep+0xb6f>
movslq %edi,%rdx
mov    %esi,%r9d
mov    %edi,%eax
mov    %eax,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rbp
mov    %rbp,-0x20(%rsp)
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rbp
mov    %rbx,-0x18(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x8(%rsp)
lea    0x30(%r15),%rbp
mov    %rdx,-0x10(%rsp)
lea    0x0(,%rdx,8),%r13
xor    %ebx,%ebx
mov    %r15,%r14
jmp    1b25 <pcapack_sweep+0xa25>
add    $0x1,%rbx
add    %r13,%rbp
add    %r13,%r14
cmp    %r9,%rbx
je     1c1e <pcapack_sweep+0xb1e>
test   %edi,%edi
jle    1b12 <pcapack_sweep+0xa12>
movsd  (%rcx,%rbx,8),%xmm0
cmp    $0x4,%edi
jae    1b3a <pcapack_sweep+0xa3a>
xor    %edx,%edx
jmp    1c00 <pcapack_sweep+0xb00>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x20(%rsp)
je     1bb4 <pcapack_sweep+0xab4>
mov    -0x8(%rsp),%r8
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x30(%rbp,%r11,8),%xmm2
movupd -0x20(%rbp,%r11,8),%xmm3
movupd -0x10(%rbp,%r11,8),%xmm4
movupd 0x0(%rbp,%r11,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbp,%r11,8)
movupd %xmm3,-0x20(%rbp,%r11,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rbp,%r11,8)
movupd %xmm5,0x0(%rbp,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%r8
jne    1b60 <pcapack_sweep+0xa60>
jmp    1bb7 <pcapack_sweep+0xab7>
xor    %r11d,%r11d
testb  $0x1,-0x18(%rsp)
je     1bec <pcapack_sweep+0xaec>
mov    %rbx,%rdx
imul   -0x10(%rsp),%rdx
add    %rdx,%r11
movupd (%r15,%r11,8),%xmm2
movupd 0x10(%r15,%r11,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%r11,8)
movupd %xmm3,0x10(%r15,%r11,8)
mov    %r10,%rdx
cmp    %rax,%r10
je     1b12 <pcapack_sweep+0xa12>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1c00 <pcapack_sweep+0xb00>
jmp    1b12 <pcapack_sweep+0xa12>
cmp    $0x4,%r12d
jne    1c6f <pcapack_sweep+0xb6f>
mov    $0x0,%eax
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r12d
mov    %edi,%ebx
mov    %ebx,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%r9
mov    %r9,%r11
shr    %r11
add    $0x1,%r11
mov    %r11,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x20(%rsp)
lea    0x10(%r15),%rdx
mov    %rax,-0x18(%rsp)
lea    0x0(,%rax,8),%r13
xor    %r8d,%r8d
mov    %r15,%rbp
jmp    1c91 <pcapack_sweep+0xb91>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
nopl   0x0(%rax)
add    $0x1,%r8
add    %r13,%rdx
add    %r13,%rbp
xor    %eax,%eax
cmp    %r12,%r8
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1c80 <pcapack_sweep+0xb80>
movsd  (%rcx,%r8,8),%xmm0
cmp    $0x1,%edi
jne    1ca4 <pcapack_sweep+0xba4>
xor    %eax,%eax
jmp    1d20 <pcapack_sweep+0xc20>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
test   %r9,%r9
je     1d3e <pcapack_sweep+0xc3e>
mov    -0x20(%rsp),%r10
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x10(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rdx,%rax,8)
divpd  %xmm1,%xmm3
movupd %xmm3,(%rdx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%r10
jne    1cc0 <pcapack_sweep+0xbc0>
test   $0x1,%r11b
je     1d0a <pcapack_sweep+0xc0a>
mov    %r8,%rsi
imul   -0x18(%rsp),%rsi
add    %rsi,%rax
movupd (%r15,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rax,8)
mov    %r14,%rax
cmp    %rbx,%r14
je     1c80 <pcapack_sweep+0xb80>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1d20 <pcapack_sweep+0xc20>
jmp    1c80 <pcapack_sweep+0xb80>
xor    %eax,%eax
test   $0x1,%r11b
jne    1cee <pcapack_sweep+0xbee>
jmp    1d0a <pcapack_sweep+0xc0a>
mov    $0x0,%eax
cmp    $0x1,%r9d
jne    207a <pcapack_sweep+0xf7a>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%r9
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%ebp
and    $0xfffffffe,%ebp
lea    0x8(%r15),%rbx
lea    0x0(,%r9,8),%r14
mov    $0x1,%edx
xor    %r12d,%r12d
jmp    1d96 <pcapack_sweep+0xc96>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1d84 <pcapack_sweep+0xc84>
xor    %esi,%esi
cmp    $0x1,%edi
je     1ded <pcapack_sweep+0xced>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    1db0 <pcapack_sweep+0xcb0>
test   $0x1,%r10b
je     1d84 <pcapack_sweep+0xc84>
mov    %r12,%r13
imul   %r9,%r13
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r13,%rsi
addsd  (%r15,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
jmp    1d84 <pcapack_sweep+0xc84>
mov    $0x0,%eax
cmp    $0x1,%r9d
jne    213a <pcapack_sweep+0x103a>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%r9
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%ebp
and    $0xfffffffe,%ebp
lea    0x8(%r15),%rbx
lea    0x0(,%r9,8),%r14
mov    $0x1,%edx
xor    %r12d,%r12d
jmp    1e6b <pcapack_sweep+0xd6b>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1e59 <pcapack_sweep+0xd59>
xor    %esi,%esi
cmp    $0x1,%edi
je     1ebd <pcapack_sweep+0xdbd>
cs nopw 0x0(%rax,%rax,1)
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    1e80 <pcapack_sweep+0xd80>
test   $0x1,%r10b
je     1e59 <pcapack_sweep+0xd59>
mov    %r12,%r13
imul   %r9,%r13
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r13,%rsi
addsd  (%r15,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
jmp    1e59 <pcapack_sweep+0xd59>
mov    $0x0,%eax
cmp    $0x1,%r9d
jne    21fa <pcapack_sweep+0x10fa>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%r9
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%ebp
and    $0xfffffffe,%ebp
lea    0x8(%r15),%rbx
lea    0x0(,%r9,8),%r14
mov    $0x1,%edx
xor    %r12d,%r12d
jmp    1f3b <pcapack_sweep+0xe3b>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1f29 <pcapack_sweep+0xe29>
xor    %esi,%esi
cmp    $0x1,%edi
je     1f8d <pcapack_sweep+0xe8d>
cs nopw 0x0(%rax,%rax,1)
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    1f50 <pcapack_sweep+0xe50>
test   $0x1,%r10b
je     1f29 <pcapack_sweep+0xe29>
mov    %r12,%r13
imul   %r9,%r13
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r13,%rsi
addsd  (%r15,%rsi,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
add    $0x1,%eax
cltd
idiv   %r8d
jmp    1f29 <pcapack_sweep+0xe29>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%r13d
and    $0xfffffffe,%r13d
lea    0x8(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r14
xor    %r12d,%r12d
jmp    1ffd <pcapack_sweep+0xefd>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    1feb <pcapack_sweep+0xeeb>
xor    %ebp,%ebp
mov    %r12d,%eax
cmp    $0x1,%edi
je     204b <pcapack_sweep+0xf4b>
nopl   0x0(%rax,%rax,1)
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
add    %esi,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    %esi,%eax
add    $0x2,%rbp
cmp    %rbp,%r13
jne    2010 <pcapack_sweep+0xf10>
test   $0x1,%r10b
je     1feb <pcapack_sweep+0xeeb>
mov    %r12,%r9
imul   -0x20(%rsp),%r9
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r9,%rbp
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
jmp    1feb <pcapack_sweep+0xeeb>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%r13d
and    $0xfffffffe,%r13d
lea    0x8(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r14
xor    %r12d,%r12d
jmp    20ba <pcapack_sweep+0xfba>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    20a8 <pcapack_sweep+0xfa8>
xor    %ebp,%ebp
mov    %r12d,%eax
cmp    $0x1,%edi
je     210b <pcapack_sweep+0x100b>
nopl   0x0(%rax,%rax,1)
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
add    %esi,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    %esi,%eax
add    $0x2,%rbp
cmp    %rbp,%r13
jne    20d0 <pcapack_sweep+0xfd0>
test   $0x1,%r10b
je     20a8 <pcapack_sweep+0xfa8>
mov    %r12,%r9
imul   -0x20(%rsp),%r9
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r9,%rbp
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
jmp    20a8 <pcapack_sweep+0xfa8>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%r13d
and    $0xfffffffe,%r13d
lea    0x8(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r14
xor    %r12d,%r12d
jmp    217a <pcapack_sweep+0x107a>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    2168 <pcapack_sweep+0x1068>
xor    %ebp,%ebp
mov    %r12d,%eax
cmp    $0x1,%edi
je     21cb <pcapack_sweep+0x10cb>
nopl   0x0(%rax,%rax,1)
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
add    %esi,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    %esi,%eax
add    $0x2,%rbp
cmp    %rbp,%r13
jne    2190 <pcapack_sweep+0x1090>
test   $0x1,%r10b
je     2168 <pcapack_sweep+0x1068>
mov    %r12,%r9
imul   -0x20(%rsp),%r9
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r9,%rbp
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
jmp    2168 <pcapack_sweep+0x1068>
test   %esi,%esi
jle    1c71 <pcapack_sweep+0xb71>
movslq %edi,%rax
mov    %esi,%r11d
mov    %edi,%r10d
mov    %r10d,%r13d
and    $0xfffffffe,%r13d
lea    0x8(%r15),%rbx
mov    %rax,-0x20(%rsp)
lea    0x0(,%rax,8),%r14
xor    %r12d,%r12d
jmp    223a <pcapack_sweep+0x113a>
add    $0x1,%r12
add    %r14,%rbx
xor    %eax,%eax
cmp    %r11,%r12
je     1c71 <pcapack_sweep+0xb71>
test   %edi,%edi
jle    2228 <pcapack_sweep+0x1128>
xor    %ebp,%ebp
mov    %r12d,%eax
cmp    $0x1,%edi
je     228b <pcapack_sweep+0x118b>
nopl   0x0(%rax,%rax,1)
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  -0x8(%rbx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
add    %esi,%eax
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    %esi,%eax
add    $0x2,%rbp
cmp    %rbp,%r13
jne    2250 <pcapack_sweep+0x1150>
test   $0x1,%r10b
je     2228 <pcapack_sweep+0x1128>
mov    %r12,%r9
imul   -0x20(%rsp),%r9
cltd
idiv   %r8d
movslq %edx,%rax
movsd  (%rcx,%rax,8),%xmm0
add    %r9,%rbp
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
jmp    2228 <pcapack_sweep+0x1128>

LLVM IR (-O0):
define i32 @pcapack_sweep(i32 %0, i32 %1, double* noalias %2, double* noalias %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca double
store i32 %0, i32* %9
store i32 %1, i32* %10
store double* %2, double** %11
store double* %3, double** %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
%20 = load i32, i32* %9
%21 = icmp eq i32 %20, 0
br i1 %21, label %25, label %22
22: ; preds = %7
%23 = load i32, i32* %10
%24 = icmp eq i32 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %22, %7
store i32 0, i32* %8
br label %737
26: ; preds = %22
%27 = load i32, i32* %14
%28 = icmp ne i32 %27, 1
br i1 %28, label %29, label %33
29: ; preds = %26
%30 = load i32, i32* %14
%31 = icmp ne i32 %30, 2
br i1 %31, label %32, label %33
32: ; preds = %29
store i32 -6, i32* %8
br label %737
33: ; preds = %29, %26
%34 = load i32, i32* %15
%35 = icmp ne i32 %34, 1
br i1 %35, label %36, label %46
36: ; preds = %33
%37 = load i32, i32* %15
%38 = icmp ne i32 %37, 2
br i1 %38, label %39, label %46
39: ; preds = %36
%40 = load i32, i32* %15
%41 = icmp ne i32 %40, 3
br i1 %41, label %42, label %46
42: ; preds = %39
%43 = load i32, i32* %15
%44 = icmp ne i32 %43, 4
br i1 %44, label %45, label %46
45: ; preds = %42
store i32 -7, i32* %8
br label %737
46: ; preds = %42, %39, %36, %33
%47 = load i32, i32* %14
%48 = icmp eq i32 %47, 1
br i1 %48, label %49, label %205
49: ; preds = %46
%50 = load i32, i32* %13
%51 = load i32, i32* %9
%52 = icmp eq i32 %50, %51
br i1 %52, label %53, label %205
53: ; preds = %49
%54 = load i32, i32* %15
%55 = icmp eq i32 %54, 1
br i1 %55, label %56, label %90
56: ; preds = %53
store i32 0, i32* %17
br label %57
57: ; preds = %86, %56
%58 = load i32, i32* %17
%59 = load i32, i32* %10
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %89
61: ; preds = %57
store i32 0, i32* %16
br label %62
62: ; preds = %82, %61
%63 = load i32, i32* %16
%64 = load i32, i32* %9
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %85
66: ; preds = %62
%67 = load double*, double** %12
%68 = load i32, i32* %16
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
%71 = load double, double* %70
%72 = load double*, double** %11
%73 = load i32, i32* %16
%74 = load i32, i32* %9
%75 = load i32, i32* %17
%76 = mul nsw i32 %74, %75
%77 = add nsw i32 %73, %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %72, i64 %78
%80 = load double, double* %79
%81 = fadd double %80, %71
store double %81, double* %79
br label %82
82: ; preds = %66
%83 = load i32, i32* %16
%84 = add nsw i32 %83, 1
store i32 %84, i32* %16
br label %62
85: ; preds = %62
br label %86
86: ; preds = %85
%87 = load i32, i32* %17
%88 = add nsw i32 %87, 1
store i32 %88, i32* %17
br label %57
89: ; preds = %57
br label %204
90: ; preds = %53
%91 = load i32, i32* %15
%92 = icmp eq i32 %91, 2
br i1 %92, label %93, label %127
93: ; preds = %90
store i32 0, i32* %17
br label %94
94: ; preds = %123, %93
%95 = load i32, i32* %17
%96 = load i32, i32* %10
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %126
98: ; preds = %94
store i32 0, i32* %16
br label %99
99: ; preds = %119, %98
%100 = load i32, i32* %16
%101 = load i32, i32* %9
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %122
103: ; preds = %99
%104 = load double*, double** %12
%105 = load i32, i32* %16
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = load double*, double** %11
%110 = load i32, i32* %16
%111 = load i32, i32* %9
%112 = load i32, i32* %17
%113 = mul nsw i32 %111, %112
%114 = add nsw i32 %110, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %109, i64 %115
%117 = load double, double* %116
%118 = fsub double %117, %108
store double %118, double* %116
br label %119
119: ; preds = %103
%120 = load i32, i32* %16
%121 = add nsw i32 %120, 1
store i32 %121, i32* %16
br label %99
122: ; preds = %99
br label %123
123: ; preds = %122
%124 = load i32, i32* %17
%125 = add nsw i32 %124, 1
store i32 %125, i32* %17
br label %94
126: ; preds = %94
br label %203
127: ; preds = %90
%128 = load i32, i32* %15
%129 = icmp eq i32 %128, 3
br i1 %129, label %130, label %164
130: ; preds = %127
store i32 0, i32* %17
br label %131
131: ; preds = %160, %130
%132 = load i32, i32* %17
%133 = load i32, i32* %10
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %163
135: ; preds = %131
store i32 0, i32* %16
br label %136
136: ; preds = %156, %135
%137 = load i32, i32* %16
%138 = load i32, i32* %9
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %159
140: ; preds = %136
%141 = load double*, double** %12
%142 = load i32, i32* %16
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %11
%147 = load i32, i32* %16
%148 = load i32, i32* %9
%149 = load i32, i32* %17
%150 = mul nsw i32 %148, %149
%151 = add nsw i32 %147, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %146, i64 %152
%154 = load double, double* %153
%155 = fmul double %154, %145
store double %155, double* %153
br label %156
156: ; preds = %140
%157 = load i32, i32* %16
%158 = add nsw i32 %157, 1
store i32 %158, i32* %16
br label %136
159: ; preds = %136
br label %160
160: ; preds = %159
%161 = load i32, i32* %17
%162 = add nsw i32 %161, 1
store i32 %162, i32* %17
br label %131
163: ; preds = %131
br label %202
164: ; preds = %127
%165 = load i32, i32* %15
%166 = icmp eq i32 %165, 4
br i1 %166, label %167, label %201
167: ; preds = %164
store i32 0, i32* %17
br label %168
168: ; preds = %197, %167
%169 = load i32, i32* %17
%170 = load i32, i32* %10
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %200
172: ; preds = %168
store i32 0, i32* %16
br label %173
173: ; preds = %193, %172
%174 = load i32, i32* %16
%175 = load i32, i32* %9
%176 = icmp slt i32 %174, %175
br i1 %176, label %177, label %196
177: ; preds = %173
%178 = load double*, double** %12
%179 = load i32, i32* %16
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = load double*, double** %11
%184 = load i32, i32* %16
%185 = load i32, i32* %9
%186 = load i32, i32* %17
%187 = mul nsw i32 %185, %186
%188 = add nsw i32 %184, %187
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %183, i64 %189
%191 = load double, double* %190
%192 = fdiv double %191, %182
store double %192, double* %190
br label %193
193: ; preds = %177
%194 = load i32, i32* %16
%195 = add nsw i32 %194, 1
store i32 %195, i32* %16
br label %173
196: ; preds = %173
br label %197
197: ; preds = %196
%198 = load i32, i32* %17
%199 = add nsw i32 %198, 1
store i32 %199, i32* %17
br label %168
200: ; preds = %168
br label %201
201: ; preds = %200, %164
br label %202
202: ; preds = %201, %163
br label %203
203: ; preds = %202, %126
br label %204
204: ; preds = %203, %89
br label %736
205: ; preds = %49, %46
%206 = load i32, i32* %14
%207 = icmp eq i32 %206, 2
br i1 %207, label %208, label %367
208: ; preds = %205
%209 = load i32, i32* %13
%210 = load i32, i32* %10
%211 = icmp eq i32 %209, %210
br i1 %211, label %212, label %367
212: ; preds = %208
%213 = load i32, i32* %15
%214 = icmp eq i32 %213, 1
br i1 %214, label %215, label %250
215: ; preds = %212
store i32 0, i32* %17
br label %216
216: ; preds = %246, %215
%217 = load i32, i32* %17
%218 = load i32, i32* %10
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %249
220: ; preds = %216
%221 = load double*, double** %12
%222 = load i32, i32* %17
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %221, i64 %223
%225 = load double, double* %224
store double %225, double* %19
store i32 0, i32* %16
br label %226
226: ; preds = %242, %220
%227 = load i32, i32* %16
%228 = load i32, i32* %9
%229 = icmp slt i32 %227, %228
br i1 %229, label %230, label %245
230: ; preds = %226
%231 = load double, double* %19
%232 = load double*, double** %11
%233 = load i32, i32* %16
%234 = load i32, i32* %9
%235 = load i32, i32* %17
%236 = mul nsw i32 %234, %235
%237 = add nsw i32 %233, %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %232, i64 %238
%240 = load double, double* %239
%241 = fadd double %240, %231
store double %241, double* %239
br label %242
242: ; preds = %230
%243 = load i32, i32* %16
%244 = add nsw i32 %243, 1
store i32 %244, i32* %16
br label %226
245: ; preds = %226
br label %246
246: ; preds = %245
%247 = load i32, i32* %17
%248 = add nsw i32 %247, 1
store i32 %248, i32* %17
br label %216
249: ; preds = %216
br label %328
250: ; preds = %212
%251 = load i32, i32* %15
%252 = icmp eq i32 %251, 2
br i1 %252, label %253, label %288
253: ; preds = %250
store i32 0, i32* %17
br label %254
254: ; preds = %284, %253
%255 = load i32, i32* %17
%256 = load i32, i32* %10
%257 = icmp slt i32 %255, %256
br i1 %257, label %258, label %287
258: ; preds = %254
%259 = load double*, double** %12
%260 = load i32, i32* %17
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %259, i64 %261
%263 = load double, double* %262
store double %263, double* %19
store i32 0, i32* %16
br label %264
264: ; preds = %280, %258
%265 = load i32, i32* %16
%266 = load i32, i32* %9
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %283
268: ; preds = %264
%269 = load double, double* %19
%270 = load double*, double** %11
%271 = load i32, i32* %16
%272 = load i32, i32* %9
%273 = load i32, i32* %17
%274 = mul nsw i32 %272, %273
%275 = add nsw i32 %271, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %270, i64 %276
%278 = load double, double* %277
%279 = fsub double %278, %269
store double %279, double* %277
br label %280
280: ; preds = %268
%281 = load i32, i32* %16
%282 = add nsw i32 %281, 1
store i32 %282, i32* %16
br label %264
283: ; preds = %264
br label %284
284: ; preds = %283
%285 = load i32, i32* %17
%286 = add nsw i32 %285, 1
store i32 %286, i32* %17
br label %254
287: ; preds = %254
br label %327
288: ; preds = %250
%289 = load i32, i32* %15
%290 = icmp eq i32 %289, 3
br i1 %290, label %291, label %326
291: ; preds = %288
store i32 0, i32* %17
br label %292
292: ; preds = %322, %291
%293 = load i32, i32* %17
%294 = load i32, i32* %10
%295 = icmp slt i32 %293, %294
br i1 %295, label %296, label %325
296: ; preds = %292
%297 = load double*, double** %12
%298 = load i32, i32* %17
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %297, i64 %299
%301 = load double, double* %300
store double %301, double* %19
store i32 0, i32* %16
br label %302
302: ; preds = %318, %296
%303 = load i32, i32* %16
%304 = load i32, i32* %9
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %321
306: ; preds = %302
%307 = load double, double* %19
%308 = load double*, double** %11
%309 = load i32, i32* %16
%310 = load i32, i32* %9
%311 = load i32, i32* %17
%312 = mul nsw i32 %310, %311
%313 = add nsw i32 %309, %312
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %308, i64 %314
%316 = load double, double* %315
%317 = fmul double %316, %307
store double %317, double* %315
br label %318
318: ; preds = %306
%319 = load i32, i32* %16
%320 = add nsw i32 %319, 1
store i32 %320, i32* %16
br label %302
321: ; preds = %302
br label %322
322: ; preds = %321
%323 = load i32, i32* %17
%324 = add nsw i32 %323, 1
store i32 %324, i32* %17
br label %292
325: ; preds = %292
br label %326
326: ; preds = %325, %288
br label %327
327: ; preds = %326, %287
br label %328
328: ; preds = %327, %249
%329 = load i32, i32* %15
%330 = icmp eq i32 %329, 4
br i1 %330, label %331, label %366
331: ; preds = %328
store i32 0, i32* %17
br label %332
332: ; preds = %362, %331
%333 = load i32, i32* %17
%334 = load i32, i32* %10
%335 = icmp slt i32 %333, %334
br i1 %335, label %336, label %365
336: ; preds = %332
%337 = load double*, double** %12
%338 = load i32, i32* %17
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %337, i64 %339
%341 = load double, double* %340
store double %341, double* %19
store i32 0, i32* %16
br label %342
342: ; preds = %358, %336
%343 = load i32, i32* %16
%344 = load i32, i32* %9
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %361
346: ; preds = %342
%347 = load double, double* %19
%348 = load double*, double** %11
%349 = load i32, i32* %16
%350 = load i32, i32* %9
%351 = load i32, i32* %17
%352 = mul nsw i32 %350, %351
%353 = add nsw i32 %349, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %348, i64 %354
%356 = load double, double* %355
%357 = fdiv double %356, %347
store double %357, double* %355
br label %358
358: ; preds = %346
%359 = load i32, i32* %16
%360 = add nsw i32 %359, 1
store i32 %360, i32* %16
br label %342
361: ; preds = %342
br label %362
362: ; preds = %361
%363 = load i32, i32* %17
%364 = add nsw i32 %363, 1
store i32 %364, i32* %17
br label %332
365: ; preds = %332
br label %366
366: ; preds = %365, %328
br label %735
367: ; preds = %208, %205
%368 = load i32, i32* %15
%369 = icmp eq i32 %368, 1
br i1 %369, label %370, label %458
370: ; preds = %367
%371 = load i32, i32* %14
%372 = icmp eq i32 %371, 1
br i1 %372, label %373, label %411
373: ; preds = %370
store i32 1, i32* %18
store i32 0, i32* %17
br label %374
374: ; preds = %407, %373
%375 = load i32, i32* %17
%376 = load i32, i32* %10
%377 = icmp slt i32 %375, %376
br i1 %377, label %378, label %410
378: ; preds = %374
store i32 0, i32* %16
br label %379
379: ; preds = %403, %378
%380 = load i32, i32* %16
%381 = load i32, i32* %9
%382 = icmp slt i32 %380, %381
br i1 %382, label %383, label %406
383: ; preds = %379
%384 = load double*, double** %12
%385 = load i32, i32* %18
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = load double*, double** %11
%390 = load i32, i32* %16
%391 = load i32, i32* %9
%392 = load i32, i32* %17
%393 = mul nsw i32 %391, %392
%394 = add nsw i32 %390, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %389, i64 %395
%397 = load double, double* %396
%398 = fadd double %397, %388
store double %398, double* %396
%399 = load i32, i32* %18
%400 = add nsw i32 %399, 1
%401 = load i32, i32* %13
%402 = srem i32 %400, %401
store i32 %402, i32* %18
br label %403
403: ; preds = %383
%404 = load i32, i32* %16
%405 = add nsw i32 %404, 1
store i32 %405, i32* %16
br label %379
406: ; preds = %379
br label %407
407: ; preds = %406
%408 = load i32, i32* %17
%409 = add nsw i32 %408, 1
store i32 %409, i32* %17
br label %374
410: ; preds = %374
br label %457
411: ; preds = %370
%412 = load i32, i32* %14
%413 = icmp eq i32 %412, 2
br i1 %413, label %414, label %456
414: ; preds = %411
store i32 0, i32* %17
br label %415
415: ; preds = %452, %414
%416 = load i32, i32* %17
%417 = load i32, i32* %10
%418 = icmp slt i32 %416, %417
br i1 %418, label %419, label %455
419: ; preds = %415
%420 = load i32, i32* %17
%421 = load i32, i32* %13
%422 = srem i32 %420, %421
store i32 %422, i32* %18
store i32 0, i32* %16
br label %423
423: ; preds = %448, %419
%424 = load i32, i32* %16
%425 = load i32, i32* %9
%426 = icmp slt i32 %424, %425
br i1 %426, label %427, label %451
427: ; preds = %423
%428 = load double*, double** %12
%429 = load i32, i32* %18
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %428, i64 %430
%432 = load double, double* %431
%433 = load double*, double** %11
%434 = load i32, i32* %16
%435 = load i32, i32* %9
%436 = load i32, i32* %17
%437 = mul nsw i32 %435, %436
%438 = add nsw i32 %434, %437
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %433, i64 %439
%441 = load double, double* %440
%442 = fadd double %441, %432
store double %442, double* %440
%443 = load i32, i32* %18
%444 = load i32, i32* %10
%445 = add nsw i32 %443, %444
%446 = load i32, i32* %13
%447 = srem i32 %445, %446
store i32 %447, i32* %18
br label %448
448: ; preds = %427
%449 = load i32, i32* %16
%450 = add nsw i32 %449, 1
store i32 %450, i32* %16
br label %423
451: ; preds = %423
br label %452
452: ; preds = %451
%453 = load i32, i32* %17
%454 = add nsw i32 %453, 1
store i32 %454, i32* %17
br label %415
455: ; preds = %415
br label %456
456: ; preds = %455, %411
br label %457
457: ; preds = %456, %410
br label %734
458: ; preds = %367
%459 = load i32, i32* %15
%460 = icmp eq i32 %459, 2
br i1 %460, label %461, label %549
461: ; preds = %458
%462 = load i32, i32* %14
%463 = icmp eq i32 %462, 1
br i1 %463, label %464, label %502
464: ; preds = %461
store i32 1, i32* %18
store i32 0, i32* %17
br label %465
465: ; preds = %498, %464
%466 = load i32, i32* %17
%467 = load i32, i32* %10
%468 = icmp slt i32 %466, %467
br i1 %468, label %469, label %501
469: ; preds = %465
store i32 0, i32* %16
br label %470
470: ; preds = %494, %469
%471 = load i32, i32* %16
%472 = load i32, i32* %9
%473 = icmp slt i32 %471, %472
br i1 %473, label %474, label %497
474: ; preds = %470
%475 = load double*, double** %12
%476 = load i32, i32* %18
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %475, i64 %477
%479 = load double, double* %478
%480 = load double*, double** %11
%481 = load i32, i32* %16
%482 = load i32, i32* %9
%483 = load i32, i32* %17
%484 = mul nsw i32 %482, %483
%485 = add nsw i32 %481, %484
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %480, i64 %486
%488 = load double, double* %487
%489 = fadd double %488, %479
store double %489, double* %487
%490 = load i32, i32* %18
%491 = add nsw i32 %490, 1
%492 = load i32, i32* %13
%493 = srem i32 %491, %492
store i32 %493, i32* %18
br label %494
494: ; preds = %474
%495 = load i32, i32* %16
%496 = add nsw i32 %495, 1
store i32 %496, i32* %16
br label %470
497: ; preds = %470
br label %498
498: ; preds = %497
%499 = load i32, i32* %17
%500 = add nsw i32 %499, 1
store i32 %500, i32* %17
br label %465
501: ; preds = %465
br label %548
502: ; preds = %461
%503 = load i32, i32* %14
%504 = icmp eq i32 %503, 2
br i1 %504, label %505, label %547
505: ; preds = %502
store i32 0, i32* %17
br label %506
506: ; preds = %543, %505
%507 = load i32, i32* %17
%508 = load i32, i32* %10
%509 = icmp slt i32 %507, %508
br i1 %509, label %510, label %546
510: ; preds = %506
%511 = load i32, i32* %17
%512 = load i32, i32* %13
%513 = srem i32 %511, %512
store i32 %513, i32* %18
store i32 0, i32* %16
br label %514
514: ; preds = %539, %510
%515 = load i32, i32* %16
%516 = load i32, i32* %9
%517 = icmp slt i32 %515, %516
br i1 %517, label %518, label %542
518: ; preds = %514
%519 = load double*, double** %12
%520 = load i32, i32* %18
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double*, double** %11
%525 = load i32, i32* %16
%526 = load i32, i32* %9
%527 = load i32, i32* %17
%528 = mul nsw i32 %526, %527
%529 = add nsw i32 %525, %528
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds double, double* %524, i64 %530
%532 = load double, double* %531
%533 = fadd double %532, %523
store double %533, double* %531
%534 = load i32, i32* %18
%535 = load i32, i32* %10
%536 = add nsw i32 %534, %535
%537 = load i32, i32* %13
%538 = srem i32 %536, %537
store i32 %538, i32* %18
br label %539
539: ; preds = %518
%540 = load i32, i32* %16
%541 = add nsw i32 %540, 1
store i32 %541, i32* %16
br label %514
542: ; preds = %514
br label %543
543: ; preds = %542
%544 = load i32, i32* %17
%545 = add nsw i32 %544, 1
store i32 %545, i32* %17
br label %506
546: ; preds = %506
br label %547
547: ; preds = %546, %502
br label %548
548: ; preds = %547, %501
br label %733
549: ; preds = %458
%550 = load i32, i32* %15
%551 = icmp eq i32 %550, 3
br i1 %551, label %552, label %640
552: ; preds = %549
%553 = load i32, i32* %14
%554 = icmp eq i32 %553, 1
br i1 %554, label %555, label %593
555: ; preds = %552
store i32 1, i32* %18
store i32 0, i32* %17
br label %556
556: ; preds = %589, %555
%557 = load i32, i32* %17
%558 = load i32, i32* %10
%559 = icmp slt i32 %557, %558
br i1 %559, label %560, label %592
560: ; preds = %556
store i32 0, i32* %16
br label %561
561: ; preds = %585, %560
%562 = load i32, i32* %16
%563 = load i32, i32* %9
%564 = icmp slt i32 %562, %563
br i1 %564, label %565, label %588
565: ; preds = %561
%566 = load double*, double** %12
%567 = load i32, i32* %18
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds double, double* %566, i64 %568
%570 = load double, double* %569
%571 = load double*, double** %11
%572 = load i32, i32* %16
%573 = load i32, i32* %9
%574 = load i32, i32* %17
%575 = mul nsw i32 %573, %574
%576 = add nsw i32 %572, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %571, i64 %577
%579 = load double, double* %578
%580 = fadd double %579, %570
store double %580, double* %578
%581 = load i32, i32* %18
%582 = add nsw i32 %581, 1
%583 = load i32, i32* %13
%584 = srem i32 %582, %583
store i32 %584, i32* %18
br label %585
585: ; preds = %565
%586 = load i32, i32* %16
%587 = add nsw i32 %586, 1
store i32 %587, i32* %16
br label %561
588: ; preds = %561
br label %589
589: ; preds = %588
%590 = load i32, i32* %17
%591 = add nsw i32 %590, 1
store i32 %591, i32* %17
br label %556
592: ; preds = %556
br label %639
593: ; preds = %552
%594 = load i32, i32* %14
%595 = icmp eq i32 %594, 2
br i1 %595, label %596, label %638
596: ; preds = %593
store i32 0, i32* %17
br label %597
597: ; preds = %634, %596
%598 = load i32, i32* %17
%599 = load i32, i32* %10
%600 = icmp slt i32 %598, %599
br i1 %600, label %601, label %637
601: ; preds = %597
%602 = load i32, i32* %17
%603 = load i32, i32* %13
%604 = srem i32 %602, %603
store i32 %604, i32* %18
store i32 0, i32* %16
br label %605
605: ; preds = %630, %601
%606 = load i32, i32* %16
%607 = load i32, i32* %9
%608 = icmp slt i32 %606, %607
br i1 %608, label %609, label %633
609: ; preds = %605
%610 = load double*, double** %12
%611 = load i32, i32* %18
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %610, i64 %612
%614 = load double, double* %613
%615 = load double*, double** %11
%616 = load i32, i32* %16
%617 = load i32, i32* %9
%618 = load i32, i32* %17
%619 = mul nsw i32 %617, %618
%620 = add nsw i32 %616, %619
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %615, i64 %621
%623 = load double, double* %622
%624 = fadd double %623, %614
store double %624, double* %622
%625 = load i32, i32* %18
%626 = load i32, i32* %10
%627 = add nsw i32 %625, %626
%628 = load i32, i32* %13
%629 = srem i32 %627, %628
store i32 %629, i32* %18
br label %630
630: ; preds = %609
%631 = load i32, i32* %16
%632 = add nsw i32 %631, 1
store i32 %632, i32* %16
br label %605
633: ; preds = %605
br label %634
634: ; preds = %633
%635 = load i32, i32* %17
%636 = add nsw i32 %635, 1
store i32 %636, i32* %17
br label %597
637: ; preds = %597
br label %638
638: ; preds = %637, %593
br label %639
639: ; preds = %638, %592
br label %732
640: ; preds = %549
%641 = load i32, i32* %15
%642 = icmp eq i32 %641, 4
br i1 %642, label %643, label %731
643: ; preds = %640
%644 = load i32, i32* %14
%645 = icmp eq i32 %644, 1
br i1 %645, label %646, label %684
646: ; preds = %643
store i32 1, i32* %18
store i32 0, i32* %17
br label %647
647: ; preds = %680, %646
%648 = load i32, i32* %17
%649 = load i32, i32* %10
%650 = icmp slt i32 %648, %649
br i1 %650, label %651, label %683
651: ; preds = %647
store i32 0, i32* %16
br label %652
652: ; preds = %676, %651
%653 = load i32, i32* %16
%654 = load i32, i32* %9
%655 = icmp slt i32 %653, %654
br i1 %655, label %656, label %679
656: ; preds = %652
%657 = load double*, double** %12
%658 = load i32, i32* %18
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
%661 = load double, double* %660
%662 = load double*, double** %11
%663 = load i32, i32* %16
%664 = load i32, i32* %9
%665 = load i32, i32* %17
%666 = mul nsw i32 %664, %665
%667 = add nsw i32 %663, %666
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds double, double* %662, i64 %668
%670 = load double, double* %669
%671 = fadd double %670, %661
store double %671, double* %669
%672 = load i32, i32* %18
%673 = add nsw i32 %672, 1
%674 = load i32, i32* %13
%675 = srem i32 %673, %674
store i32 %675, i32* %18
br label %676
676: ; preds = %656
%677 = load i32, i32* %16
%678 = add nsw i32 %677, 1
store i32 %678, i32* %16
br label %652
679: ; preds = %652
br label %680
680: ; preds = %679
%681 = load i32, i32* %17
%682 = add nsw i32 %681, 1
store i32 %682, i32* %17
br label %647
683: ; preds = %647
br label %730
684: ; preds = %643
%685 = load i32, i32* %14
%686 = icmp eq i32 %685, 2
br i1 %686, label %687, label %729
687: ; preds = %684
store i32 0, i32* %17
br label %688
688: ; preds = %725, %687
%689 = load i32, i32* %17
%690 = load i32, i32* %10
%691 = icmp slt i32 %689, %690
br i1 %691, label %692, label %728
692: ; preds = %688
%693 = load i32, i32* %17
%694 = load i32, i32* %13
%695 = srem i32 %693, %694
store i32 %695, i32* %18
store i32 0, i32* %16
br label %696
696: ; preds = %721, %692
%697 = load i32, i32* %16
%698 = load i32, i32* %9
%699 = icmp slt i32 %697, %698
br i1 %699, label %700, label %724
700: ; preds = %696
%701 = load double*, double** %12
%702 = load i32, i32* %18
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds double, double* %701, i64 %703
%705 = load double, double* %704
%706 = load double*, double** %11
%707 = load i32, i32* %16
%708 = load i32, i32* %9
%709 = load i32, i32* %17
%710 = mul nsw i32 %708, %709
%711 = add nsw i32 %707, %710
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds double, double* %706, i64 %712
%714 = load double, double* %713
%715 = fadd double %714, %705
store double %715, double* %713
%716 = load i32, i32* %18
%717 = load i32, i32* %10
%718 = add nsw i32 %716, %717
%719 = load i32, i32* %13
%720 = srem i32 %718, %719
store i32 %720, i32* %18
br label %721
721: ; preds = %700
%722 = load i32, i32* %16
%723 = add nsw i32 %722, 1
store i32 %723, i32* %16
br label %696
724: ; preds = %696
br label %725
725: ; preds = %724
%726 = load i32, i32* %17
%727 = add nsw i32 %726, 1
store i32 %727, i32* %17
br label %688
728: ; preds = %688
br label %729
729: ; preds = %728, %684
br label %730
730: ; preds = %729, %683
br label %731
731: ; preds = %730, %640
br label %732
732: ; preds = %731, %639
br label %733
733: ; preds = %732, %548
br label %734
734: ; preds = %733, %457
br label %735
735: ; preds = %734, %366
br label %736
736: ; preds = %735, %204
store i32 0, i32* %8
br label %737
737: ; preds = %736, %45, %32, %25
%738 = load i32, i32* %8
ret i32 %738
}

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