void compute_tentative_velocity(double **u, double **v, double **f, double **g,
                                char **flag, int imax, int jmax, double del_t,
                                double delx, double dely, double gamma,
                                double Re) {
  int i, j;
  double du2dx, duvdy, duvdx, dv2dy, laplu, laplv;
  for (i = 1; i <= imax - 1; i++) {
    for (j = 1; j <= jmax; j++) {
      if ((flag[i][j] & 0x0010) && (flag[i + 1][j] & 0x0010)) {
        du2dx =
            ((u[i][j] + u[i + 1][j]) * (u[i][j] + u[i + 1][j]) +
             gamma * fabs(u[i][j] + u[i + 1][j]) * (u[i][j] - u[i + 1][j]) -
             (u[i - 1][j] + u[i][j]) * (u[i - 1][j] + u[i][j]) -
             gamma * fabs(u[i - 1][j] + u[i][j]) * (u[i - 1][j] - u[i][j])) /
            (4.0 * delx);
        duvdy = ((v[i][j] + v[i + 1][j]) * (u[i][j] + u[i][j + 1]) +
                 gamma * fabs(v[i][j] + v[i + 1][j]) * (u[i][j] - u[i][j + 1]) -
                 (v[i][j - 1] + v[i + 1][j - 1]) * (u[i][j - 1] + u[i][j]) -
                 gamma * fabs(v[i][j - 1] + v[i + 1][j - 1]) *
                     (u[i][j - 1] - u[i][j])) /
                (4.0 * dely);
        laplu = (u[i + 1][j] - 2.0 * u[i][j] + u[i - 1][j]) / delx / delx +
                (u[i][j + 1] - 2.0 * u[i][j] + u[i][j - 1]) / dely / dely;
        f[i][j] = u[i][j] + del_t * (laplu / Re - du2dx - duvdy);
      } else {
        f[i][j] = u[i][j];
      }
    }
  }
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax - 1; j++) {
      if ((flag[i][j] & 0x0010) && (flag[i][j + 1] & 0x0010)) {
        duvdx = ((u[i][j] + u[i][j + 1]) * (v[i][j] + v[i + 1][j]) +
                 gamma * fabs(u[i][j] + u[i][j + 1]) * (v[i][j] - v[i + 1][j]) -
                 (u[i - 1][j] + u[i - 1][j + 1]) * (v[i - 1][j] + v[i][j]) -
                 gamma * fabs(u[i - 1][j] + u[i - 1][j + 1]) *
                     (v[i - 1][j] - v[i][j])) /
                (4.0 * delx);
        dv2dy =
            ((v[i][j] + v[i][j + 1]) * (v[i][j] + v[i][j + 1]) +
             gamma * fabs(v[i][j] + v[i][j + 1]) * (v[i][j] - v[i][j + 1]) -
             (v[i][j - 1] + v[i][j]) * (v[i][j - 1] + v[i][j]) -
             gamma * fabs(v[i][j - 1] + v[i][j]) * (v[i][j - 1] - v[i][j])) /
            (4.0 * dely);
        laplv = (v[i + 1][j] - 2.0 * v[i][j] + v[i - 1][j]) / delx / delx +
                (v[i][j + 1] - 2.0 * v[i][j] + v[i][j - 1]) / dely / dely;
        g[i][j] = v[i][j] + del_t * (laplv / Re - duvdx - dv2dy);
      } else {
        g[i][j] = v[i][j];
      }
    }
  }
  for (j = 1; j <= jmax; j++) {
    f[0][j] = u[0][j];
    f[imax][j] = u[imax][j];
  }
  for (i = 1; i <= imax; i++) {
    g[i][0] = v[i][0];
    g[i][jmax] = v[i][jmax];
  }
}


x86 assembly (clang, -O0):
<compute_tentative_velocity>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1725 <compute_tentative_velocity+0x625>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1712 <compute_tentative_velocity+0x612>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     16d5 <compute_tentative_velocity+0x5d5>
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     16d5 <compute_tentative_velocity+0x5d5>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0xdcb(%rip),%xmm4
pand   %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movaps 0xcd0(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc62(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0xbcb(%rip),%xmm4
pand   %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movaps 0xabc(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xa4e(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  -0x48(%rbp),%xmm1
divsd  -0x48(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
divsd  -0x58(%rbp),%xmm2
subsd  -0x68(%rbp),%xmm2
subsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ff <compute_tentative_velocity+0x5ff>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1704 <compute_tentative_velocity+0x604>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    115b <compute_tentative_velocity+0x5b>
jmp    1717 <compute_tentative_velocity+0x617>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1143 <compute_tentative_velocity+0x43>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1d0e <compute_tentative_velocity+0xc0e>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1cfb <compute_tentative_velocity+0xbfb>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1cbe <compute_tentative_velocity+0xbbe>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1cbe <compute_tentative_velocity+0xbbe>
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0x7e2(%rip),%xmm4
pand   %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movaps 0x6d3(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x665(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
movaps 0x5ce(%rip),%xmm4
pand   %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movaps 0x4d3(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x465(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  -0x48(%rbp),%xmm1
divsd  -0x48(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
divsd  -0x58(%rbp),%xmm2
subsd  -0x78(%rbp),%xmm2
subsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ce8 <compute_tentative_velocity+0xbe8>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ced <compute_tentative_velocity+0xbed>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    173f <compute_tentative_velocity+0x63f>
jmp    1d00 <compute_tentative_velocity+0xc00>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    172c <compute_tentative_velocity+0x62c>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1d79 <compute_tentative_velocity+0xc79>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1d15 <compute_tentative_velocity+0xc15>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1de4 <compute_tentative_velocity+0xce4>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1d80 <compute_tentative_velocity+0xc80>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_tentative_velocity>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movapd %xmm0,%xmm14
mov    %rcx,-0x10(%rsp)
mov    0x38(%rsp),%ecx
mov    %r9d,%eax
mov    %rax,-0x30(%rsp)
mov    %r9,-0x48(%rsp)
cmp    $0x2,%r9d
jl     136c <compute_tentative_velocity+0x26c>
movsd  0xec9(%rip),%xmm0
movapd %xmm1,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm5,-0x28(%rsp)
mulsd  %xmm2,%xmm0
movsd  %xmm0,-0x40(%rsp)
lea    0x1(%rcx),%r15d
mov    $0x1,%r13d
movapd 0xeae(%rip),%xmm11
jmp    117e <compute_tentative_velocity+0x7e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r11,%r13
cmp    -0x30(%rsp),%r11
je     136c <compute_tentative_velocity+0x26c>
test   %ecx,%ecx
jle    1360 <compute_tentative_velocity+0x260>
mov    (%r8,%r13,8),%r12
lea    0x1(%r13),%r11
mov    $0x1,%eax
jmp    11bd <compute_tentative_velocity+0xbd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%r13,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
mov    (%rdx,%r13,8),%rbp
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %r15,%rax
je     1170 <compute_tentative_velocity+0x70>
testb  $0x10,(%r12,%rax,1)
je     11a0 <compute_tentative_velocity+0xa0>
mov    0x8(%r8,%r13,8),%rbp
testb  $0x10,0x0(%rbp,%rax,1)
je     11a0 <compute_tentative_velocity+0xa0>
mov    -0x8(%rdi,%r13,8),%r10
mov    (%rdi,%r13,8),%r9
movsd  -0x8(%r9,%rax,8),%xmm12
movsd  (%r9,%rax,8),%xmm9
mov    0x8(%rdi,%r13,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm15
movapd %xmm9,%xmm5
addsd  %xmm15,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm11,%xmm6
mulsd  %xmm3,%xmm6
movapd %xmm9,%xmm7
subsd  %xmm15,%xmm7
mulsd  %xmm6,%xmm7
mulsd  %xmm5,%xmm5
addsd  %xmm7,%xmm5
movapd %xmm4,%xmm0
movapd %xmm14,%xmm10
movsd  (%r10,%rax,8),%xmm14
movapd %xmm9,%xmm6
addsd  %xmm14,%xmm6
movapd %xmm6,%xmm7
mulsd  %xmm6,%xmm7
subsd  %xmm7,%xmm5
andpd  %xmm11,%xmm6
movapd %xmm9,%xmm7
mulsd  0xdb2(%rip),%xmm7
addsd  %xmm7,%xmm15
addsd  %xmm14,%xmm15
subsd  %xmm9,%xmm14
mulsd  %xmm3,%xmm6
mulsd  %xmm14,%xmm6
subsd  %xmm6,%xmm5
mov    (%rsi,%r13,8),%rbp
lea    0x1(%rax),%r10
mov    %r10d,%ebx
movsd  (%r9,%rbx,8),%xmm14
mov    0x8(%rsi,%r13,8),%rbx
movsd  0x0(%rbp,%rax,8),%xmm6
addsd  (%rbx,%rax,8),%xmm6
movapd %xmm9,%xmm13
addsd  %xmm14,%xmm13
mulsd  %xmm6,%xmm13
andpd  %xmm11,%xmm6
mulsd  %xmm3,%xmm6
movapd %xmm9,%xmm8
subsd  %xmm14,%xmm8
mulsd  %xmm6,%xmm8
movsd  -0x8(%rbp,%rax,8),%xmm6
addsd  %xmm8,%xmm13
addsd  -0x8(%rbx,%rax,8),%xmm6
movapd %xmm9,%xmm4
addsd  %xmm12,%xmm4
mulsd  %xmm6,%xmm4
subsd  %xmm4,%xmm13
addsd  %xmm14,%xmm7
movapd %xmm10,%xmm14
movapd %xmm0,%xmm4
andpd  %xmm11,%xmm6
addsd  %xmm12,%xmm7
subsd  %xmm9,%xmm12
mulsd  %xmm3,%xmm6
mulsd  %xmm12,%xmm6
subsd  %xmm6,%xmm13
divsd  %xmm1,%xmm15
divsd  %xmm1,%xmm15
divsd  %xmm2,%xmm7
divsd  %xmm2,%xmm7
addsd  %xmm15,%xmm7
divsd  -0x28(%rsp),%xmm5
divsd  %xmm0,%xmm7
subsd  %xmm5,%xmm7
divsd  -0x40(%rsp),%xmm13
subsd  %xmm13,%xmm7
mulsd  %xmm10,%xmm7
addsd  %xmm9,%xmm7
mov    (%rdx,%r13,8),%rbp
movsd  %xmm7,0x0(%rbp,%rax,8)
mov    %r10,%rax
cmp    %r15,%rax
jne    11bd <compute_tentative_velocity+0xbd>
jmp    1170 <compute_tentative_velocity+0x70>
nop
add    $0x1,%r13
mov    %r13,%r11
jmp    1173 <compute_tentative_velocity+0x73>
mov    %ecx,%eax
mov    %rax,-0x28(%rsp)
cmpl   $0x0,-0x48(%rsp)
jle    15ac <compute_tentative_velocity+0x4ac>
movsd  0xc7a(%rip),%xmm5
movapd %xmm1,%xmm8
mulsd  %xmm5,%xmm8
mulsd  %xmm2,%xmm5
mov    -0x48(%rsp),%rax
lea    0x1(%rax),%ebp
unpcklpd %xmm5,%xmm4
unpcklpd %xmm2,%xmm1
mov    -0x28(%rsp),%rax
lea    -0x1(%rax),%r13
mov    $0x1,%eax
movapd 0xc55(%rip),%xmm9
mov    %rbp,-0x40(%rsp)
jmp    13e5 <compute_tentative_velocity+0x2e5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rax
mov    0x38(%rsp),%ecx
mov    -0x40(%rsp),%rbp
cmp    %rbp,%r12
je     15ac <compute_tentative_velocity+0x4ac>
cmp    $0x1,%ecx
jle    15a0 <compute_tentative_velocity+0x4a0>
mov    (%r8,%rax,8),%rbx
lea    0x1(%rax),%r12
mov    %r12d,%r14d
mov    -0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%r11
xor    %r10d,%r10d
jmp    142b <compute_tentative_velocity+0x32b>
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rax,8),%rcx
movsd  0x8(%rcx,%r10,8),%xmm5
movsd  %xmm5,0x8(%r11,%r10,8)
add    $0x1,%r10
cmp    %r10,%r13
je     13d0 <compute_tentative_velocity+0x2d0>
testb  $0x10,0x1(%rbx,%r10,1)
je     1410 <compute_tentative_velocity+0x310>
testb  $0x10,0x2(%rbx,%r10,1)
je     1410 <compute_tentative_velocity+0x310>
mov    (%rdi,%rax,8),%rbp
movsd  0x8(%rbp,%r10,8),%xmm0
addsd  0x10(%rbp,%r10,8),%xmm0
mov    -0x8(%rdi,%rax,8),%rbp
mov    -0x8(%rsi,%rax,8),%r15
mov    (%rsi,%rax,8),%r9
movsd  (%r9,%r10,8),%xmm10
movsd  0x8(%r9,%r10,8),%xmm13
mov    (%rsi,%r14,8),%rcx
movsd  0x8(%rcx,%r10,8),%xmm5
movapd %xmm13,%xmm7
addsd  %xmm5,%xmm7
mulsd  %xmm0,%xmm7
andpd  %xmm9,%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm13,%xmm6
subsd  %xmm5,%xmm6
mulsd  %xmm0,%xmm6
movsd  0x8(%rbp,%r10,8),%xmm0
addsd  0x10(%rbp,%r10,8),%xmm0
addsd  %xmm6,%xmm7
movsd  0x8(%r15,%r10,8),%xmm11
movapd %xmm13,%xmm6
addsd  %xmm11,%xmm6
mulsd  %xmm0,%xmm6
subsd  %xmm6,%xmm7
andpd  %xmm9,%xmm0
movapd %xmm11,%xmm6
subsd  %xmm13,%xmm6
mulsd  %xmm3,%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm0,%xmm7
divsd  %xmm8,%xmm7
movsd  0x10(%r9,%r10,8),%xmm12
movapd %xmm13,%xmm6
addsd  %xmm12,%xmm6
movapd %xmm6,%xmm0
andpd  %xmm9,%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm13,%xmm2
subsd  %xmm12,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm6
addsd  %xmm2,%xmm6
movapd %xmm13,%xmm0
addsd  %xmm10,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm6
andpd  %xmm9,%xmm0
unpcklpd %xmm10,%xmm11
subsd  %xmm13,%xmm10
mulsd  %xmm3,%xmm0
mulsd  %xmm10,%xmm0
subsd  %xmm0,%xmm6
unpcklpd %xmm12,%xmm5
movapd %xmm13,%xmm0
addsd  %xmm13,%xmm0
unpcklpd %xmm0,%xmm0
subpd  %xmm0,%xmm5
addpd  %xmm11,%xmm5
divpd  %xmm1,%xmm5
divpd  %xmm1,%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
addpd  %xmm5,%xmm0
unpcklpd %xmm6,%xmm0
divpd  %xmm4,%xmm0
movapd %xmm0,%xmm5
subsd  %xmm7,%xmm5
unpckhpd %xmm0,%xmm0
subsd  %xmm0,%xmm5
mulsd  %xmm14,%xmm5
addsd  %xmm13,%xmm5
jmp    141b <compute_tentative_velocity+0x31b>
xchg   %ax,%ax
add    $0x1,%rax
mov    %rax,%r12
jmp    13dc <compute_tentative_velocity+0x2dc>
test   %ecx,%ecx
mov    -0x48(%rsp),%r11
jle    17df <compute_tentative_velocity+0x6df>
mov    (%rdi),%r15
mov    (%rdx),%r9
movslq %r11d,%rax
mov    (%rdi,%rax,8),%rdi
mov    (%rdx,%rax,8),%rdx
mov    -0x28(%rsp),%rax
lea    0x1(%rax),%r8
mov    $0x1,%eax
cmp    $0x4,%ecx
jae    164e <compute_tentative_velocity+0x54e>
mov    %rax,%rbp
not    %rbp
test   $0x1,%r8b
jne    1603 <compute_tentative_velocity+0x503>
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    %r8,%rbp
je     17df <compute_tentative_velocity+0x6df>
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r9,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    1610 <compute_tentative_velocity+0x510>
jmp    17df <compute_tentative_velocity+0x6df>
lea    0x8(%r9),%rbp
lea    (%r9,%r8,8),%r14
lea    0x8(%rdx),%r12
lea    (%rdx,%r8,8),%r11
lea    0x8(%r15),%r10
mov    %r10,-0x38(%rsp)
lea    (%r15,%r8,8),%r13
lea    0x8(%rdi),%rbx
mov    %rbx,-0x8(%rsp)
lea    (%rdi,%r8,8),%rbx
cmp    %r11,%rbp
setb   -0x40(%rsp)
cmp    %r14,%r12
setb   -0x49(%rsp)
cmp    %r13,%rbp
setb   -0x4a(%rsp)
cmp    %r14,%r10
setb   -0x4b(%rsp)
cmp    %rbx,%rbp
setb   %r10b
mov    -0x8(%rsp),%rbp
cmp    %r14,%rbp
setb   -0x4c(%rsp)
cmp    %r13,%r12
setb   %r13b
cmp    %r11,-0x38(%rsp)
setb   -0x38(%rsp)
cmp    %rbx,%r12
setb   %r14b
cmp    %r11,%rbp
setb   %bpl
mov    -0x49(%rsp),%bl
test   %bl,-0x40(%rsp)
jne    18a5 <compute_tentative_velocity+0x7a5>
mov    -0x4b(%rsp),%bl
and    %bl,-0x4a(%rsp)
mov    -0x48(%rsp),%r11
jne    15dd <compute_tentative_velocity+0x4dd>
and    -0x4c(%rsp),%r10b
jne    15dd <compute_tentative_velocity+0x4dd>
and    -0x38(%rsp),%r13b
jne    15dd <compute_tentative_velocity+0x4dd>
and    %bpl,%r14b
jne    15dd <compute_tentative_velocity+0x4dd>
mov    -0x28(%rsp),%rax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rbp
mov    %rbp,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rbp,%rbp
je     1891 <compute_tentative_velocity+0x791>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
mov    $0x1,%ebp
nopw   0x0(%rax,%rax,1)
movups (%r15,%rbp,8),%xmm0
movups 0x10(%r15,%rbp,8),%xmm1
movups %xmm0,(%r9,%rbp,8)
movups %xmm1,0x10(%r9,%rbp,8)
movups (%rdi,%rbp,8),%xmm0
movups 0x10(%rdi,%rbp,8),%xmm1
movups %xmm0,(%rdx,%rbp,8)
movups %xmm1,0x10(%rdx,%rbp,8)
movups 0x20(%r15,%rbp,8),%xmm0
movups 0x30(%r15,%rbp,8),%xmm1
movups %xmm0,0x20(%r9,%rbp,8)
movups %xmm1,0x30(%r9,%rbp,8)
movupd 0x20(%rdi,%rbp,8),%xmm0
movupd 0x30(%rdi,%rbp,8),%xmm1
movupd %xmm0,0x20(%rdx,%rbp,8)
movupd %xmm1,0x30(%rdx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1740 <compute_tentative_velocity+0x640>
test   $0x1,%r10b
je     17d4 <compute_tentative_velocity+0x6d4>
movups (%r15,%rbp,8),%xmm0
movups 0x10(%r15,%rbp,8),%xmm1
movups %xmm0,(%r9,%rbp,8)
movups %xmm1,0x10(%r9,%rbp,8)
movupd (%rdi,%rbp,8),%xmm0
movupd 0x10(%rdi,%rbp,8),%xmm1
movupd %xmm0,(%rdx,%rbp,8)
movupd %xmm1,0x10(%rdx,%rbp,8)
cmp    %rax,-0x28(%rsp)
jne    1888 <compute_tentative_velocity+0x788>
test   %r11d,%r11d
mov    -0x10(%rsp),%rbx
jle    187d <compute_tentative_velocity+0x77d>
movslq %ecx,%rax
mov    $0x1,%edx
cmp    $0x1,%r11d
je     185c <compute_tentative_velocity+0x75c>
mov    -0x30(%rsp),%rdi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdx,8),%rcx
movsd  (%rcx),%xmm0
mov    (%rbx,%rdx,8),%rbp
movsd  %xmm0,0x0(%rbp)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
mov    0x8(%rsi,%rdx,8),%rcx
movsd  (%rcx),%xmm0
mov    0x8(%rbx,%rdx,8),%rbp
movsd  %xmm0,0x0(%rbp)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
lea    (%rdi,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
cmp    $0x1,%rcx
jne    1810 <compute_tentative_velocity+0x710>
testb  $0x1,-0x30(%rsp)
je     187d <compute_tentative_velocity+0x77d>
mov    (%rsi,%rdx,8),%rcx
movsd  (%rcx),%xmm0
mov    (%rbx,%rdx,8),%rdx
movsd  %xmm0,(%rdx)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    15dd <compute_tentative_velocity+0x4dd>
mov    $0x1,%ebp
test   $0x1,%r10b
jne    17a8 <compute_tentative_velocity+0x6a8>
jmp    17d4 <compute_tentative_velocity+0x6d4>
mov    -0x48(%rsp),%r11
jmp    15dd <compute_tentative_velocity+0x4dd>

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

LLVM IR (-O2):
define void @compute_tentative_velocity(double** nocapture %0, double** nocapture %1, double** nocapture %2, double** nocapture %3, i8** nocapture %4, i32 %5, i32 %6, double %7, double %8, double %9, double %10, double %11) {
%13 = icmp sgt i32 %5, 1
br i1 %13, label %14, label %37
14: ; preds = %12
%15 = icmp slt i32 %6, 1
%16 = fmul double %8, 4.000000e+00
%17 = fmul double %9, 4.000000e+00
%18 = add i32 %6, 1
%19 = zext i32 %5 to i64
%20 = zext i32 %18 to i64
br label %21
21: ; preds = %14, %148
%22 = phi i64 [ 1, %14 ], [ %149, %148 ]
br i1 %15, label %23, label %25
23: ; preds = %21
%24 = add nuw nsw i64 %22, 1
br label %148
25: ; preds = %21
%26 = getelementptr inbounds i8*, i8** %4, i64 %22
%27 = load i8*, i8** %26
%28 = add nuw nsw i64 %22, 1
%29 = getelementptr inbounds i8*, i8** %4, i64 %28
%30 = getelementptr inbounds double*, double** %0, i64 %22
%31 = getelementptr inbounds double*, double** %0, i64 %28
%32 = add nsw i64 %22, -1
%33 = getelementptr inbounds double*, double** %0, i64 %32
%34 = getelementptr inbounds double*, double** %1, i64 %22
%35 = getelementptr inbounds double*, double** %1, i64 %28
%36 = getelementptr inbounds double*, double** %2, i64 %22
br label %52
37: ; preds = %148, %12
%38 = icmp slt i32 %5, 1
br i1 %38, label %168, label %39
39: ; preds = %37
%40 = icmp sgt i32 %6, 1
%41 = fmul double %8, 4.000000e+00
%42 = fmul double %9, 4.000000e+00
%43 = add nuw i32 %5, 1
%44 = zext i32 %43 to i64
%45 = zext i32 %6 to i64
%46 = insertelement <2 x double> poison, double %11, i64 0
%47 = insertelement <2 x double> %46, double %42, i64 1
%48 = insertelement <2 x double> poison, double %8, i64 0
%49 = insertelement <2 x double> %48, double %9, i64 1
%50 = insertelement <2 x double> poison, double %8, i64 0
%51 = insertelement <2 x double> %50, double %9, i64 1
br label %151
52: ; preds = %25, %145
%53 = phi i64 [ 1, %25 ], [ %146, %145 ]
%54 = getelementptr inbounds i8, i8* %27, i64 %53
%55 = load i8, i8* %54
%56 = and i8 %55, 16
%57 = icmp eq i8 %56, 0
br i1 %57, label %138, label %58
58: ; preds = %52
%59 = load i8*, i8** %29
%60 = getelementptr inbounds i8, i8* %59, i64 %53
%61 = load i8, i8* %60
%62 = and i8 %61, 16
%63 = icmp eq i8 %62, 0
br i1 %63, label %138, label %64
64: ; preds = %58
%65 = load double*, double** %30
%66 = getelementptr inbounds double, double* %65, i64 %53
%67 = load double, double* %66
%68 = load double*, double** %31
%69 = getelementptr inbounds double, double* %68, i64 %53
%70 = load double, double* %69
%71 = fadd double %67, %70
%72 = tail call double @llvm.fabs.f64(double %71)
%73 = fmul double %72, %10
%74 = fsub double %67, %70
%75 = fmul double %74, %73
%76 = tail call double @llvm.fmuladd.f64(double %71, double %71, double %75)
%77 = load double*, double** %33
%78 = getelementptr inbounds double, double* %77, i64 %53
%79 = load double, double* %78
%80 = fadd double %67, %79
%81 = fneg double %80
%82 = tail call double @llvm.fmuladd.f64(double %81, double %80, double %76)
%83 = tail call double @llvm.fabs.f64(double %80)
%84 = fsub double %79, %67
%85 = fneg double %83
%86 = fmul double %85, %10
%87 = tail call double @llvm.fmuladd.f64(double %86, double %84, double %82)
%88 = fdiv double %87, %16
%89 = load double*, double** %34
%90 = getelementptr inbounds double, double* %89, i64 %53
%91 = load double, double* %90
%92 = load double*, double** %35
%93 = getelementptr inbounds double, double* %92, i64 %53
%94 = load double, double* %93
%95 = fadd double %91, %94
%96 = add nuw nsw i64 %53, 1
%97 = and i64 %96, 4294967295
%98 = getelementptr inbounds double, double* %65, i64 %97
%99 = load double, double* %98
%100 = fadd double %67, %99
%101 = tail call double @llvm.fabs.f64(double %95)
%102 = fmul double %101, %10
%103 = fsub double %67, %99
%104 = fmul double %103, %102
%105 = tail call double @llvm.fmuladd.f64(double %95, double %100, double %104)
%106 = add nsw i64 %53, -1
%107 = getelementptr inbounds double, double* %89, i64 %106
%108 = load double, double* %107
%109 = getelementptr inbounds double, double* %92, i64 %106
%110 = load double, double* %109
%111 = fadd double %108, %110
%112 = getelementptr inbounds double, double* %65, i64 %106
%113 = load double, double* %112
%114 = fadd double %67, %113
%115 = fneg double %111
%116 = tail call double @llvm.fmuladd.f64(double %115, double %114, double %105)
%117 = tail call double @llvm.fabs.f64(double %111)
%118 = fsub double %113, %67
%119 = fneg double %117
%120 = fmul double %119, %10
%121 = tail call double @llvm.fmuladd.f64(double %120, double %118, double %116)
%122 = fdiv double %121, %17
%123 = tail call double @llvm.fmuladd.f64(double %67, double -2.000000e+00, double %70)
%124 = fadd double %123, %79
%125 = fdiv double %124, %8
%126 = fdiv double %125, %8
%127 = tail call double @llvm.fmuladd.f64(double %67, double -2.000000e+00, double %99)
%128 = fadd double %127, %113
%129 = fdiv double %128, %9
%130 = fdiv double %129, %9
%131 = fadd double %126, %130
%132 = fdiv double %131, %11
%133 = fsub double %132, %88
%134 = fsub double %133, %122
%135 = tail call double @llvm.fmuladd.f64(double %7, double %134, double %67)
%136 = load double*, double** %36
%137 = getelementptr inbounds double, double* %136, i64 %53
store double %135, double* %137
br label %145
138: ; preds = %58, %52
%139 = load double*, double** %30
%140 = getelementptr inbounds double, double* %139, i64 %53
%141 = load double, double* %140
%142 = load double*, double** %36
%143 = getelementptr inbounds double, double* %142, i64 %53
store double %141, double* %143
%144 = add nuw nsw i64 %53, 1
br label %145
145: ; preds = %64, %138
%146 = phi i64 [ %96, %64 ], [ %144, %138 ]
%147 = icmp eq i64 %146, %20
br i1 %147, label %148, label %52
148: ; preds = %145, %23
%149 = phi i64 [ %24, %23 ], [ %28, %145 ]
%150 = icmp eq i64 %149, %19
br i1 %150, label %37, label %21
151: ; preds = %39, %408
%152 = phi i64 [ 1, %39 ], [ %409, %408 ]
br i1 %40, label %155, label %153
153: ; preds = %151
%154 = add nuw nsw i64 %152, 1
br label %408
155: ; preds = %151
%156 = getelementptr inbounds i8*, i8** %4, i64 %152
%157 = load i8*, i8** %156
%158 = getelementptr inbounds double*, double** %0, i64 %152
%159 = getelementptr inbounds double*, double** %1, i64 %152
%160 = add nuw nsw i64 %152, 1
%161 = and i64 %160, 4294967295
%162 = getelementptr inbounds double*, double** %1, i64 %161
%163 = add nsw i64 %152, -1
%164 = getelementptr inbounds double*, double** %0, i64 %163
%165 = getelementptr inbounds double*, double** %1, i64 %163
%166 = getelementptr inbounds double*, double** %3, i64 %152
%167 = load double*, double** %166
br label %313
168: ; preds = %408, %37
%169 = icmp slt i32 %6, 1
br i1 %169, label %411, label %170
170: ; preds = %168
%171 = load double*, double** %0
%172 = load double*, double** %2
%173 = sext i32 %5 to i64
%174 = getelementptr inbounds double*, double** %0, i64 %173
%175 = load double*, double** %174
%176 = getelementptr inbounds double*, double** %2, i64 %173
%177 = load double*, double** %176
%178 = add nuw i32 %6, 1
%179 = zext i32 %178 to i64
%180 = add nsw i64 %179, -1
%181 = icmp ult i64 %180, 4
br i1 %181, label %296, label %182
182: ; preds = %170
%183 = getelementptr double, double* %172, i64 1
%184 = getelementptr double, double* %172, i64 %179
%185 = getelementptr double, double* %177, i64 1
%186 = getelementptr double, double* %177, i64 %179
%187 = getelementptr double, double* %171, i64 1
%188 = getelementptr double, double* %171, i64 %179
%189 = getelementptr double, double* %175, i64 1
%190 = getelementptr double, double* %175, i64 %179
%191 = icmp ult double* %183, %186
%192 = icmp ult double* %185, %184
%193 = and i1 %191, %192
%194 = icmp ult double* %183, %188
%195 = icmp ult double* %187, %184
%196 = and i1 %194, %195
%197 = or i1 %193, %196
%198 = icmp ult double* %183, %190
%199 = icmp ult double* %189, %184
%200 = and i1 %198, %199
%201 = or i1 %197, %200
%202 = icmp ult double* %185, %188
%203 = icmp ult double* %187, %186
%204 = and i1 %202, %203
%205 = or i1 %201, %204
%206 = icmp ult double* %185, %190
%207 = icmp ult double* %189, %186
%208 = and i1 %206, %207
%209 = or i1 %205, %208
br i1 %209, label %296, label %210
210: ; preds = %182
%211 = and i64 %180, -4
%212 = or i64 %211, 1
%213 = add nsw i64 %211, -4
%214 = lshr exact i64 %213, 2
%215 = add nuw nsw i64 %214, 1
%216 = and i64 %215, 1
%217 = icmp eq i64 %213, 0
br i1 %217, label %270, label %218
218: ; preds = %210
%219 = and i64 %215, 9223372036854775806
br label %220
220: ; preds = %220, %218
%221 = phi i64 [ 0, %218 ], [ %265, %220 ]
%222 = phi i64 [ 0, %218 ], [ %266, %220 ]
%223 = or i64 %221, 1
%224 = getelementptr inbounds double, double* %171, i64 %223
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %224, i64 2
%228 = bitcast double* %227 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = getelementptr inbounds double, double* %172, i64 %223
%231 = bitcast double* %230 to <2 x double>*
store <2 x double> %226, <2 x double>* %231
%232 = getelementptr inbounds double, double* %230, i64 2
%233 = bitcast double* %232 to <2 x double>*
store <2 x double> %229, <2 x double>* %233
%234 = getelementptr inbounds double, double* %175, i64 %223
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = getelementptr inbounds double, double* %234, i64 2
%238 = bitcast double* %237 to <2 x double>*
%239 = load <2 x double>, <2 x double>* %238
%240 = getelementptr inbounds double, double* %177, i64 %223
%241 = bitcast double* %240 to <2 x double>*
store <2 x double> %236, <2 x double>* %241
%242 = getelementptr inbounds double, double* %240, i64 2
%243 = bitcast double* %242 to <2 x double>*
store <2 x double> %239, <2 x double>* %243
%244 = or i64 %221, 5
%245 = getelementptr inbounds double, double* %171, i64 %244
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds double, double* %245, i64 2
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = getelementptr inbounds double, double* %172, i64 %244
%252 = bitcast double* %251 to <2 x double>*
store <2 x double> %247, <2 x double>* %252
%253 = getelementptr inbounds double, double* %251, i64 2
%254 = bitcast double* %253 to <2 x double>*
store <2 x double> %250, <2 x double>* %254
%255 = getelementptr inbounds double, double* %175, i64 %244
%256 = bitcast double* %255 to <2 x double>*
%257 = load <2 x double>, <2 x double>* %256
%258 = getelementptr inbounds double, double* %255, i64 2
%259 = bitcast double* %258 to <2 x double>*
%260 = load <2 x double>, <2 x double>* %259
%261 = getelementptr inbounds double, double* %177, i64 %244
%262 = bitcast double* %261 to <2 x double>*
store <2 x double> %257, <2 x double>* %262
%263 = getelementptr inbounds double, double* %261, i64 2
%264 = bitcast double* %263 to <2 x double>*
store <2 x double> %260, <2 x double>* %264
%265 = add nuw i64 %221, 8
%266 = add i64 %222, 2
%267 = icmp eq i64 %266, %219
br i1 %267, label %268, label %220
268: ; preds = %220
%269 = or i64 %265, 1
br label %270
270: ; preds = %268, %210
%271 = phi i64 [ 1, %210 ], [ %269, %268 ]
%272 = icmp eq i64 %216, 0
br i1 %272, label %294, label %273
273: ; preds = %270
%274 = getelementptr inbounds double, double* %171, i64 %271
%275 = bitcast double* %274 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = getelementptr inbounds double, double* %274, i64 2
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = getelementptr inbounds double, double* %172, i64 %271
%281 = bitcast double* %280 to <2 x double>*
store <2 x double> %276, <2 x double>* %281
%282 = getelementptr inbounds double, double* %280, i64 2
%283 = bitcast double* %282 to <2 x double>*
store <2 x double> %279, <2 x double>* %283
%284 = getelementptr inbounds double, double* %175, i64 %271
%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 = getelementptr inbounds double, double* %177, i64 %271
%291 = bitcast double* %290 to <2 x double>*
store <2 x double> %286, <2 x double>* %291
%292 = getelementptr inbounds double, double* %290, i64 2
%293 = bitcast double* %292 to <2 x double>*
store <2 x double> %289, <2 x double>* %293
br label %294
294: ; preds = %270, %273
%295 = icmp eq i64 %180, %211
br i1 %295, label %411, label %296
296: ; preds = %182, %170, %294
%297 = phi i64 [ 1, %182 ], [ 1, %170 ], [ %212, %294 ]
%298 = xor i64 %297, -1
%299 = and i64 %179, 1
%300 = icmp eq i64 %299, 0
br i1 %300, label %301, label %309
301: ; preds = %296
%302 = getelementptr inbounds double, double* %171, i64 %297
%303 = load double, double* %302
%304 = getelementptr inbounds double, double* %172, i64 %297
store double %303, double* %304
%305 = getelementptr inbounds double, double* %175, i64 %297
%306 = load double, double* %305
%307 = getelementptr inbounds double, double* %177, i64 %297
store double %306, double* %307
%308 = add nuw nsw i64 %297, 1
br label %309
309: ; preds = %301, %296
%310 = phi i64 [ %297, %296 ], [ %308, %301 ]
%311 = sub nsw i64 0, %179
%312 = icmp eq i64 %298, %311
br i1 %312, label %411, label %419
313: ; preds = %155, %404
%314 = phi i64 [ 1, %155 ], [ %319, %404 ]
%315 = getelementptr inbounds i8, i8* %157, i64 %314
%316 = load i8, i8* %315
%317 = and i8 %316, 16
%318 = icmp eq i8 %317, 0
%319 = add nuw nsw i64 %314, 1
br i1 %318, label %400, label %320
320: ; preds = %313
%321 = getelementptr inbounds i8, i8* %157, i64 %319
%322 = load i8, i8* %321
%323 = and i8 %322, 16
%324 = icmp eq i8 %323, 0
br i1 %324, label %400, label %325
325: ; preds = %320
%326 = load double*, double** %158
%327 = getelementptr inbounds double, double* %326, i64 %314
%328 = load double, double* %327
%329 = getelementptr inbounds double, double* %326, i64 %319
%330 = load double, double* %329
%331 = fadd double %328, %330
%332 = load double*, double** %159
%333 = getelementptr inbounds double, double* %332, i64 %314
%334 = load double, double* %333
%335 = load double*, double** %162
%336 = getelementptr inbounds double, double* %335, i64 %314
%337 = load double, double* %336
%338 = fadd double %334, %337
%339 = tail call double @llvm.fabs.f64(double %331)
%340 = fmul double %339, %10
%341 = fsub double %334, %337
%342 = fmul double %340, %341
%343 = tail call double @llvm.fmuladd.f64(double %331, double %338, double %342)
%344 = load double*, double** %164
%345 = getelementptr inbounds double, double* %344, i64 %314
%346 = load double, double* %345
%347 = getelementptr inbounds double, double* %344, i64 %319
%348 = load double, double* %347
%349 = fadd double %346, %348
%350 = load double*, double** %165
%351 = getelementptr inbounds double, double* %350, i64 %314
%352 = load double, double* %351
%353 = fadd double %334, %352
%354 = fneg double %349
%355 = tail call double @llvm.fmuladd.f64(double %354, double %353, double %343)
%356 = tail call double @llvm.fabs.f64(double %349)
%357 = fsub double %352, %334
%358 = fneg double %356
%359 = fmul double %358, %10
%360 = tail call double @llvm.fmuladd.f64(double %359, double %357, double %355)
%361 = fdiv double %360, %41
%362 = getelementptr inbounds double, double* %332, i64 %319
%363 = load double, double* %362
%364 = fadd double %334, %363
%365 = tail call double @llvm.fabs.f64(double %364)
%366 = fmul double %365, %10
%367 = fsub double %334, %363
%368 = fmul double %367, %366
%369 = tail call double @llvm.fmuladd.f64(double %364, double %364, double %368)
%370 = add nsw i64 %314, -1
%371 = getelementptr inbounds double, double* %332, i64 %370
%372 = load double, double* %371
%373 = fadd double %334, %372
%374 = fneg double %373
%375 = tail call double @llvm.fmuladd.f64(double %374, double %373, double %369)
%376 = tail call double @llvm.fabs.f64(double %373)
%377 = fsub double %372, %334
%378 = fneg double %376
%379 = fmul double %378, %10
%380 = tail call double @llvm.fmuladd.f64(double %379, double %377, double %375)
%381 = insertelement <2 x double> poison, double %334, i64 0
%382 = shufflevector <2 x double> %381, <2 x double> poison, <2 x i32> zeroinitializer
%383 = insertelement <2 x double> poison, double %337, i64 0
%384 = insertelement <2 x double> %383, double %363, i64 1
%385 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %382, <2 x double> <double -2.000000e+00, double -2.000000e+00>, <2 x double> %384)
%386 = insertelement <2 x double> poison, double %352, i64 0
%387 = insertelement <2 x double> %386, double %372, i64 1
%388 = fadd <2 x double> %385, %387
%389 = fdiv <2 x double> %388, %49
%390 = fdiv <2 x double> %389, %51
%391 = shufflevector <2 x double> %390, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%392 = fadd <2 x double> %390, %391
%393 = insertelement <2 x double> %392, double %380, i64 1
%394 = fdiv <2 x double> %393, %47
%395 = extractelement <2 x double> %394, i64 0
%396 = fsub double %395, %361
%397 = extractelement <2 x double> %394, i64 1
%398 = fsub double %396, %397
%399 = tail call double @llvm.fmuladd.f64(double %7, double %398, double %334)
br label %404
400: ; preds = %313, %320
%401 = load double*, double** %159
%402 = getelementptr inbounds double, double* %401, i64 %314
%403 = load double, double* %402
br label %404
404: ; preds = %325, %400
%405 = phi double [ %399, %325 ], [ %403, %400 ]
%406 = getelementptr inbounds double, double* %167, i64 %314
store double %405, double* %406
%407 = icmp eq i64 %319, %45
br i1 %407, label %408, label %313
408: ; preds = %404, %153
%409 = phi i64 [ %154, %153 ], [ %160, %404 ]
%410 = icmp eq i64 %409, %44
br i1 %410, label %168, label %151
411: ; preds = %309, %419, %294, %168
br i1 %38, label %471, label %412
412: ; preds = %411
%413 = sext i32 %6 to i64
%414 = zext i32 %5 to i64
%415 = and i64 %414, 1
%416 = icmp eq i32 %5, 1
br i1 %416, label %459, label %417
417: ; preds = %412
%418 = and i64 %414, 4294967294
br label %436
419: ; preds = %309, %419
%420 = phi i64 [ %434, %419 ], [ %310, %309 ]
%421 = getelementptr inbounds double, double* %171, i64 %420
%422 = load double, double* %421
%423 = getelementptr inbounds double, double* %172, i64 %420
store double %422, double* %423
%424 = getelementptr inbounds double, double* %175, i64 %420
%425 = load double, double* %424
%426 = getelementptr inbounds double, double* %177, i64 %420
store double %425, double* %426
%427 = add nuw nsw i64 %420, 1
%428 = getelementptr inbounds double, double* %171, i64 %427
%429 = load double, double* %428
%430 = getelementptr inbounds double, double* %172, i64 %427
store double %429, double* %430
%431 = getelementptr inbounds double, double* %175, i64 %427
%432 = load double, double* %431
%433 = getelementptr inbounds double, double* %177, i64 %427
store double %432, double* %433
%434 = add nuw nsw i64 %420, 2
%435 = icmp eq i64 %434, %179
br i1 %435, label %411, label %419
436: ; preds = %436, %417
%437 = phi i64 [ 1, %417 ], [ %456, %436 ]
%438 = phi i64 [ 0, %417 ], [ %457, %436 ]
%439 = getelementptr inbounds double*, double** %1, i64 %437
%440 = load double*, double** %439
%441 = load double, double* %440
%442 = getelementptr inbounds double*, double** %3, i64 %437
%443 = load double*, double** %442
store double %441, double* %443
%444 = getelementptr inbounds double, double* %440, i64 %413
%445 = load double, double* %444
%446 = getelementptr inbounds double, double* %443, i64 %413
store double %445, double* %446
%447 = add nuw nsw i64 %437, 1
%448 = getelementptr inbounds double*, double** %1, i64 %447
%449 = load double*, double** %448
%450 = load double, double* %449
%451 = getelementptr inbounds double*, double** %3, i64 %447
%452 = load double*, double** %451
store double %450, double* %452
%453 = getelementptr inbounds double, double* %449, i64 %413
%454 = load double, double* %453
%455 = getelementptr inbounds double, double* %452, i64 %413
store double %454, double* %455
%456 = add nuw nsw i64 %437, 2
%457 = add i64 %438, 2
%458 = icmp eq i64 %457, %418
br i1 %458, label %459, label %436
459: ; preds = %436, %412
%460 = phi i64 [ 1, %412 ], [ %456, %436 ]
%461 = icmp eq i64 %415, 0
br i1 %461, label %471, label %462
462: ; preds = %459
%463 = getelementptr inbounds double*, double** %1, i64 %460
%464 = load double*, double** %463
%465 = load double, double* %464
%466 = getelementptr inbounds double*, double** %3, i64 %460
%467 = load double*, double** %466
store double %465, double* %467
%468 = getelementptr inbounds double, double* %464, i64 %413
%469 = load double, double* %468
%470 = getelementptr inbounds double, double* %467, i64 %413
store double %469, double* %470
br label %471
471: ; preds = %462, %459, %411
ret void
}