void compute_tentative_velocity(float **u, float **v, float **f, float **g,
                                char **flag, int imax, int jmax, float del_t,
                                float delx, float dely, float gamma, float Re) {
  int i, j;
  float 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
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)
movss  %xmm0,-0x30(%rbp)
movss  %xmm1,-0x34(%rbp)
movss  %xmm2,-0x38(%rbp)
movss  %xmm3,-0x3c(%rbp)
movss  %xmm4,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1789 <compute_tentative_velocity+0x689>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1776 <compute_tentative_velocity+0x676>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1739 <compute_tentative_velocity+0x639>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1739 <compute_tentative_velocity+0x639>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xdbf(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xccf(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc54(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xbaa(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xaa6(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa2b(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
divss  -0x40(%rbp),%xmm2
subss  -0x4c(%rbp),%xmm2
subss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1763 <compute_tentative_velocity+0x663>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1768 <compute_tentative_velocity+0x668>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1157 <compute_tentative_velocity+0x57>
jmp    177b <compute_tentative_velocity+0x67b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    113f <compute_tentative_velocity+0x3f>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1dda <compute_tentative_velocity+0xcda>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1dc7 <compute_tentative_velocity+0xcc7>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1d8a <compute_tentative_velocity+0xc8a>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1d8a <compute_tentative_velocity+0xc8a>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x76e(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x66a(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x5ef(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x545(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0x455(%rip),%xmm3
pand   %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x3da(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
divss  -0x40(%rbp),%xmm2
subss  -0x54(%rbp),%xmm2
subss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1db4 <compute_tentative_velocity+0xcb4>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1db9 <compute_tentative_velocity+0xcb9>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    17a3 <compute_tentative_velocity+0x6a3>
jmp    1dcc <compute_tentative_velocity+0xccc>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1790 <compute_tentative_velocity+0x690>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1e45 <compute_tentative_velocity+0xd45>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1de1 <compute_tentative_velocity+0xce1>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1eb0 <compute_tentative_velocity+0xdb0>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1e4c <compute_tentative_velocity+0xd4c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_tentative_velocity>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movss  %xmm4,-0x54(%rsp)
movss  %xmm3,-0x5c(%rsp)
movaps %xmm2,-0x18(%rsp)
movaps %xmm1,-0x28(%rsp)
movss  %xmm0,-0x58(%rsp)
mov    %rcx,-0x30(%rsp)
mov    0x38(%rsp),%ecx
mov    %r9d,%eax
mov    %rax,-0x38(%rsp)
mov    %r9,-0x40(%rsp)
cmp    $0x2,%r9d
jl     13ec <compute_tentative_velocity+0x2ec>
movss  -0x5c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm10
movaps 0xea7(%rip),%xmm11
xorps  %xmm10,%xmm11
movaps -0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm13
movsd  0xeb0(%rip),%xmm9
movaps %xmm13,%xmm0
mulsd  %xmm9,%xmm0
movsd  %xmm0,-0x50(%rsp)
movaps -0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm14
mulsd  %xmm14,%xmm9
lea    0x1(%rcx),%r15d
mov    $0x1,%ebx
movaps 0xe71(%rip),%xmm15
jmp    11be <compute_tentative_velocity+0xbe>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11,%rbx
cmp    -0x38(%rsp),%r11
je     13ec <compute_tentative_velocity+0x2ec>
test   %ecx,%ecx
jle    13e0 <compute_tentative_velocity+0x2e0>
mov    (%r8,%rbx,8),%r12
lea    0x1(%rbx),%r11
mov    $0x1,%eax
jmp    11fd <compute_tentative_velocity+0xfd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rbx,8),%rbp
movss  0x0(%rbp,%rax,4),%xmm0
mov    (%rdx,%rbx,8),%rbp
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %r15,%rax
je     11b0 <compute_tentative_velocity+0xb0>
testb  $0x10,(%r12,%rax,1)
je     11e0 <compute_tentative_velocity+0xe0>
mov    0x8(%r8,%rbx,8),%rbp
testb  $0x10,0x0(%rbp,%rax,1)
je     11e0 <compute_tentative_velocity+0xe0>
mov    -0x8(%rdi,%rbx,8),%r9
mov    (%rdi,%rbx,8),%r10
movss  -0x4(%r10,%rax,4),%xmm5
movss  (%r10,%rax,4),%xmm0
mov    0x8(%rdi,%rbx,8),%rbp
movss  0x0(%rbp,%rax,4),%xmm6
movaps %xmm0,%xmm1
addss  %xmm6,%xmm1
movaps %xmm1,%xmm2
mulss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
andps  %xmm15,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm10,%xmm1
movaps %xmm0,%xmm3
subss  %xmm6,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movss  (%r9,%rax,4),%xmm2
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
movaps %xmm4,%xmm1
mulss  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm3
andps  %xmm15,%xmm4
xorps  %xmm12,%xmm12
cvtss2sd %xmm4,%xmm12
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm11,%xmm12
mulsd  %xmm1,%xmm12
addsd  %xmm3,%xmm12
mov    (%rsi,%rbx,8),%r13
lea    0x1(%rax),%r9
mov    %r9d,%ebp
movss  (%r10,%rbp,4),%xmm3
mov    0x8(%rsi,%rbx,8),%rbp
movss  0x0(%r13,%rax,4),%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
movaps %xmm0,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm1,%xmm4
andps  %xmm15,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm10,%xmm1
movaps %xmm0,%xmm7
subss  %xmm3,%xmm7
cvtss2sd %xmm7,%xmm8
mulsd  %xmm1,%xmm8
movss  -0x4(%r13,%rax,4),%xmm1
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm8
addss  -0x4(%rbp,%rax,4),%xmm1
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm1,%xmm4
cvtss2sd %xmm4,%xmm4
subsd  %xmm4,%xmm8
andps  %xmm15,%xmm1
cvtss2sd %xmm1,%xmm1
movaps %xmm5,%xmm4
subss  %xmm0,%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm11,%xmm1
mulsd  %xmm4,%xmm1
cvtss2sd %xmm2,%xmm2
addsd  %xmm8,%xmm1
xorps  %xmm4,%xmm4
cvtss2sd %xmm6,%xmm4
cvtss2sd %xmm0,%xmm6
mulsd  0xcd4(%rip),%xmm6
addsd  %xmm6,%xmm4
addsd  %xmm4,%xmm2
cvtss2sd %xmm3,%xmm3
addsd  %xmm6,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm5,%xmm4
addsd  %xmm3,%xmm4
divsd  %xmm13,%xmm2
divsd  %xmm13,%xmm2
divsd  %xmm14,%xmm4
divsd  %xmm14,%xmm4
addsd  %xmm2,%xmm4
divsd  -0x50(%rsp),%xmm12
xorps  %xmm2,%xmm2
cvtsd2ss %xmm12,%xmm2
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
divss  -0x54(%rsp),%xmm3
subss  %xmm2,%xmm3
divsd  %xmm9,%xmm1
cvtsd2ss %xmm1,%xmm1
subss  %xmm1,%xmm3
mulss  -0x58(%rsp),%xmm3
addss  %xmm0,%xmm3
mov    (%rdx,%rbx,8),%rbp
movss  %xmm3,0x0(%rbp,%rax,4)
mov    %r9,%rax
cmp    %r15,%rax
jne    11fd <compute_tentative_velocity+0xfd>
jmp    11b0 <compute_tentative_velocity+0xb0>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %rbx,%r11
jmp    11b3 <compute_tentative_velocity+0xb3>
mov    %ecx,%eax
mov    %rax,-0x48(%rsp)
cmpl   $0x0,-0x40(%rsp)
jle    167c <compute_tentative_velocity+0x57c>
movss  -0x5c(%rsp),%xmm0
xorps  %xmm10,%xmm10
cvtss2sd %xmm0,%xmm10
movaps 0xbeb(%rip),%xmm11
xorps  %xmm10,%xmm11
movaps -0x28(%rsp),%xmm0
unpcklps -0x18(%rsp),%xmm0
cvtps2pd %xmm0,%xmm12
movsd  0xbf1(%rip),%xmm1
movapd %xmm12,%xmm8
mulsd  %xmm1,%xmm8
movapd %xmm12,%xmm9
unpckhpd %xmm12,%xmm9
mulsd  %xmm1,%xmm9
mov    -0x40(%rsp),%rax
lea    0x1(%rax),%ebp
mov    -0x48(%rsp),%rax
lea    -0x1(%rax),%r13
mov    $0x1,%eax
movaps 0xbaa(%rip),%xmm13
mov    %rbp,-0x50(%rsp)
jmp    1485 <compute_tentative_velocity+0x385>
nopl   (%rax)
mov    %r12,%rax
mov    0x38(%rsp),%ecx
mov    -0x50(%rsp),%rbp
cmp    %rbp,%r12
je     167c <compute_tentative_velocity+0x57c>
cmp    $0x1,%ecx
jle    1670 <compute_tentative_velocity+0x570>
mov    (%r8,%rax,8),%rbx
lea    0x1(%rax),%r12
mov    %r12d,%r15d
mov    -0x30(%rsp),%rcx
mov    (%rcx,%rax,8),%r11
xor    %r10d,%r10d
jmp    14cb <compute_tentative_velocity+0x3cb>
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rax,8),%rcx
movss  0x4(%rcx,%r10,4),%xmm1
movss  %xmm1,0x4(%r11,%r10,4)
add    $0x1,%r10
cmp    %r10,%r13
je     1470 <compute_tentative_velocity+0x370>
testb  $0x10,0x1(%rbx,%r10,1)
je     14b0 <compute_tentative_velocity+0x3b0>
testb  $0x10,0x2(%rbx,%r10,1)
je     14b0 <compute_tentative_velocity+0x3b0>
mov    -0x8(%rdi,%rax,8),%r14
mov    (%rdi,%rax,8),%rbp
movss  0x4(%rbp,%r10,4),%xmm0
addss  0x8(%rbp,%r10,4),%xmm0
mov    -0x8(%rsi,%rax,8),%rbp
mov    (%rsi,%rax,8),%r9
mov    (%rsi,%r15,8),%rcx
movss  0x4(%rcx,%r10,4),%xmm6
movsd  0x4(%r9,%r10,4),%xmm2
movaps %xmm2,%xmm1
addss  %xmm6,%xmm1
mulss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
andps  %xmm13,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm10,%xmm0
movaps %xmm2,%xmm3
subss  %xmm6,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movss  0x4(%r14,%r10,4),%xmm0
addss  0x8(%r14,%r10,4),%xmm0
addsd  %xmm1,%xmm4
movss  0x4(%rbp,%r10,4),%xmm3
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm4
andps  %xmm13,%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm3,%xmm1
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm11,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm4,%xmm0
divsd  %xmm8,%xmm0
cvtsd2ss %xmm0,%xmm5
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm4
mulss  %xmm1,%xmm4
cvtss2sd %xmm4,%xmm4
andps  %xmm13,%xmm1
cvtss2sd %xmm1,%xmm7
mulsd  %xmm10,%xmm7
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
movss  (%r9,%r10,4),%xmm4
movaps %xmm2,%xmm0
addss  %xmm4,%xmm0
movaps %xmm0,%xmm7
mulss  %xmm0,%xmm7
cvtss2sd %xmm7,%xmm7
subsd  %xmm7,%xmm1
andps  %xmm13,%xmm0
cvtss2sd %xmm0,%xmm0
unpcklps %xmm4,%xmm3
subss  %xmm2,%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm11,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm9,%xmm0
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movaps %xmm2,%xmm4
movss  %xmm6,%xmm4
cvtps2pd %xmm4,%xmm4
addsd  %xmm1,%xmm1
unpcklpd %xmm1,%xmm1
subpd  %xmm1,%xmm4
cvtps2pd %xmm3,%xmm1
addpd  %xmm4,%xmm1
divpd  %xmm12,%xmm1
divpd  %xmm12,%xmm1
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
divss  -0x54(%rsp),%xmm1
subss  %xmm5,%xmm1
subss  %xmm0,%xmm1
mulss  -0x58(%rsp),%xmm1
addss  %xmm2,%xmm1
jmp    14bb <compute_tentative_velocity+0x3bb>
nopl   0x0(%rax)
add    $0x1,%rax
mov    %rax,%r12
jmp    147c <compute_tentative_velocity+0x37c>
test   %ecx,%ecx
jle    1897 <compute_tentative_velocity+0x797>
mov    (%rdi),%r15
mov    (%rdx),%r10
movslq -0x40(%rsp),%rax
mov    (%rdi,%rax,8),%rdi
mov    (%rdx,%rax,8),%rdx
mov    -0x48(%rsp),%rax
lea    0x1(%rax),%r8
mov    $0x1,%eax
cmp    $0x8,%ecx
jae    171e <compute_tentative_velocity+0x61e>
mov    %rax,%rbp
not    %rbp
test   $0x1,%r8b
jne    16d0 <compute_tentative_velocity+0x5d0>
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
add    %r8,%rbp
je     1897 <compute_tentative_velocity+0x797>
nopl   0x0(%rax)
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%r10,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm0
movss  %xmm0,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r8
jne    16e0 <compute_tentative_velocity+0x5e0>
jmp    1897 <compute_tentative_velocity+0x797>
lea    0x4(%r10),%rbp
lea    (%r10,%r8,4),%rbx
lea    0x4(%rdx),%r12
lea    (%rdx,%r8,4),%r11
lea    0x4(%r15),%r14
lea    (%r15,%r8,4),%r13
lea    0x4(%rdi),%rcx
mov    %rcx,-0x50(%rsp)
lea    (%rdi,%r8,4),%r9
cmp    %r11,%rbp
setb   -0x54(%rsp)
cmp    %rbx,%r12
setb   -0x58(%rsp)
cmp    %r13,%rbp
setb   -0x28(%rsp)
cmp    %rbx,%r14
setb   -0x18(%rsp)
cmp    %r9,%rbp
setb   %cl
mov    -0x50(%rsp),%rbp
cmp    %rbx,%rbp
setb   -0x5c(%rsp)
cmp    %r13,%r12
setb   %r13b
cmp    %r11,%r14
setb   -0x5d(%rsp)
cmp    %r9,%r12
setb   %r9b
cmp    %r11,%rbp
setb   %r11b
mov    -0x58(%rsp),%bl
test   %bl,-0x54(%rsp)
jne    16aa <compute_tentative_velocity+0x5aa>
mov    -0x28(%rsp),%bl
and    -0x18(%rsp),%bl
jne    16aa <compute_tentative_velocity+0x5aa>
and    -0x5c(%rsp),%cl
jne    16aa <compute_tentative_velocity+0x5aa>
and    -0x5d(%rsp),%r13b
jne    16aa <compute_tentative_velocity+0x5aa>
and    %r11b,%r9b
jne    16aa <compute_tentative_velocity+0x5aa>
mov    -0x48(%rsp),%rax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbp
mov    %rbp,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rbp,%rbp
je     1951 <compute_tentative_velocity+0x851>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
mov    $0x1,%ebp
nopl   0x0(%rax)
movups (%r15,%rbp,4),%xmm0
movups 0x10(%r15,%rbp,4),%xmm1
movups %xmm0,(%r10,%rbp,4)
movups %xmm1,0x10(%r10,%rbp,4)
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rdx,%rbp,4)
movups %xmm1,0x10(%rdx,%rbp,4)
movups 0x20(%r15,%rbp,4),%xmm0
movups 0x30(%r15,%rbp,4),%xmm1
movups %xmm0,0x20(%r10,%rbp,4)
movups %xmm1,0x30(%r10,%rbp,4)
movups 0x20(%rdi,%rbp,4),%xmm0
movups 0x30(%rdi,%rbp,4),%xmm1
movups %xmm0,0x20(%rdx,%rbp,4)
movups %xmm1,0x30(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1800 <compute_tentative_velocity+0x700>
test   $0x1,%r9b
je     188c <compute_tentative_velocity+0x78c>
movups (%r15,%rbp,4),%xmm0
movups 0x10(%r15,%rbp,4),%xmm1
movups %xmm0,(%r10,%rbp,4)
movups %xmm1,0x10(%r10,%rbp,4)
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rdx,%rbp,4)
movups %xmm1,0x10(%rdx,%rbp,4)
cmp    %rax,-0x48(%rsp)
jne    1948 <compute_tentative_velocity+0x848>
mov    -0x40(%rsp),%rcx
test   %ecx,%ecx
mov    -0x30(%rsp),%rbx
jle    193d <compute_tentative_velocity+0x83d>
mov    0x38(%rsp),%eax
cltq
mov    $0x1,%edx
cmp    $0x1,%ecx
je     191c <compute_tentative_velocity+0x81c>
mov    -0x38(%rsp),%rdi
and    $0xfffffffe,%edi
neg    %rdi
mov    $0x1,%edx
nopl   0x0(%rax)
mov    (%rsi,%rdx,8),%rcx
movss  (%rcx),%xmm0
mov    (%rbx,%rdx,8),%rbp
movss  %xmm0,0x0(%rbp)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
mov    0x8(%rsi,%rdx,8),%rcx
movss  (%rcx),%xmm0
mov    0x8(%rbx,%rdx,8),%rbp
movss  %xmm0,0x0(%rbp)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
lea    (%rdi,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
cmp    $0x1,%rcx
jne    18d0 <compute_tentative_velocity+0x7d0>
testb  $0x1,-0x38(%rsp)
je     193d <compute_tentative_velocity+0x83d>
mov    (%rsi,%rdx,8),%rcx
movss  (%rcx),%xmm0
mov    (%rbx,%rdx,8),%rdx
movss  %xmm0,(%rdx)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    16aa <compute_tentative_velocity+0x5aa>
mov    $0x1,%ebp
test   $0x1,%r9b
jne    1864 <compute_tentative_velocity+0x764>
jmp    188c <compute_tentative_velocity+0x78c>

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

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