void compute_cell_geometry(int ndims, double *coords, int *nodepos,
                           int *facenodes, int *neighbors, double *fnormals,
                           double *fcentroids, int ncells, int *facepos,
                           int *cellfaces, double *ccentroids,
                           double *cvolumes) {
  int i, k, f, c;
  int face, node;
  double x[3];
  double u[3];
  double v[3];
  double w[3];
  double xcell[3];
  double ccell[3];
  double cface[3] = {0};
  int num_faces;
  double volume;
  double tet_volume, subnormal_sign;
  double twothirds = 0.666666666666666666666666666667;
#pragma omp parallel for default(none) private(                                \
    i, k, f, c, face, node, x, u, v, w, xcell, ccell, cface, num_faces,        \
    volume, tet_volume, subnormal_sign)                                        \
    shared(coords, nodepos, facenodes, neighbors, fnormals, fcentroids,        \
           facepos, cellfaces, ccentroids, cvolumes)                           \
        firstprivate(ncells, ndims, twothirds)
  for (c = 0; c < ncells; ++c) {
    for (i = 0; i < ndims; ++i)
      xcell[i] = 0.0;
    for (i = 0; i < ndims; ++i)
      ccell[i] = 0.0;
    for (f = facepos[c]; f < facepos[c + 1]; ++f) {
      face = cellfaces[f];
      for (i = 0; i < ndims; ++i)
        xcell[i] += fcentroids[3 * face + i];
    }
    num_faces = facepos[c + 1] - facepos[c];
    for (i = 0; i < ndims; ++i)
      xcell[i] /= num_faces;
    volume = 0;
    for (f = facepos[c]; f < facepos[c + 1]; ++f) {
      int num_face_nodes;
      for (i = 0; i < ndims; ++i)
        x[i] = 0.0;
      for (i = 0; i < ndims; ++i)
        cface[i] = 0.0;
      face = cellfaces[f];
      for (k = nodepos[face]; k < nodepos[face + 1]; ++k) {
        node = facenodes[k];
        for (i = 0; i < ndims; ++i)
          x[i] += coords[3 * node + i];
      }
      num_face_nodes = nodepos[face + 1] - nodepos[face];
      for (i = 0; i < ndims; ++i)
        x[i] /= num_face_nodes;
      node = facenodes[nodepos[face + 1] - 1];
      for (i = 0; i < ndims; ++i)
        u[i] = coords[3 * node + i] - x[i];
      for (k = nodepos[face]; k < nodepos[face + 1]; ++k) {
        node = facenodes[k];
        for (i = 0; i < ndims; ++i)
          v[i] = coords[3 * node + i] - x[i];
        cross(u, v, w);
        tet_volume = 0;
        for (i = 0; i < ndims; ++i) {
          tet_volume += 0.5 / 3 * w[i] * (x[i] - xcell[i]);
        }
        subnormal_sign = 0.0;
        for (i = 0; i < ndims; ++i) {
          subnormal_sign += w[i] * fnormals[3 * face + i];
        }
        if (subnormal_sign < 0) {
          tet_volume *= -1.0;
        }
        if (!(neighbors[2 * face + 0] == c)) {
          tet_volume *= -1.0;
        }
        volume += tet_volume;
        for (i = 0; i < ndims; ++i)
          cface[i] = (x[i] + (twothirds)*0.5 * (u[i] + v[i]));
        for (i = 0; i < ndims; ++i)
          ccell[i] += tet_volume * 3 / 4.0 * (cface[i] - xcell[i]);
        for (i = 0; i < ndims; ++i)
          u[i] = v[i];
      }
    }
    for (i = 0; i < ndims; ++i)
      ccentroids[3 * c + i] = xcell[i] + ccell[i] / volume;
    cvolumes[c] = volume;
  }
}


x86 assembly (clang, -O0):
<compute_cell_geometry>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x120(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movsd  0xe8c(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1871 <compute_cell_geometry+0x751>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c0 <compute_cell_geometry+0xa0>
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1196 <compute_cell_geometry+0x76>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f1 <compute_cell_geometry+0xd1>
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c7 <compute_cell_geometry+0xa7>
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x20(%rbp),%rcx
mov    -0x40(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1283 <compute_cell_geometry+0x163>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1270 <compute_cell_geometry+0x150>
mov    0x10(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
addsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    122d <compute_cell_geometry+0x10d>
jmp    1275 <compute_cell_geometry+0x155>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ff <compute_cell_geometry+0xdf>
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x124(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e7 <compute_cell_geometry+0x1c7>
cvtsi2sdl -0x124(%rbp),%xmm1
ff
movslq -0x34(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ab <compute_cell_geometry+0x18b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x20(%rbp),%rcx
mov    -0x40(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17f4 <compute_cell_geometry+0x6d4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1347 <compute_cell_geometry+0x227>
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1320 <compute_cell_geometry+0x200>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1378 <compute_cell_geometry+0x258>
movslq -0x34(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    134e <compute_cell_geometry+0x22e>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1412 <compute_cell_geometry+0x2f2>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13ff <compute_cell_geometry+0x2df>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
addsd  -0x60(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13c2 <compute_cell_geometry+0x2a2>
jmp    1404 <compute_cell_geometry+0x2e4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1394 <compute_cell_geometry+0x274>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x14c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1470 <compute_cell_geometry+0x350>
cvtsi2sdl -0x14c(%rbp),%xmm1
ff
movslq -0x34(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    143a <compute_cell_geometry+0x31a>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14d8 <compute_cell_geometry+0x3b8>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
subsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1497 <compute_cell_geometry+0x377>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17e1 <compute_cell_geometry+0x6c1>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1558 <compute_cell_geometry+0x438>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
subsd  -0x60(%rbp,%rax,8),%xmm0
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1514 <compute_cell_geometry+0x3f4>
lea    -0x80(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1040 <cross@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15e1 <compute_cell_geometry+0x4c1>
movslq -0x34(%rbp),%rax
movsd  0xa8d(%rip),%xmm0
mulsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x34(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
movslq -0x34(%rbp),%rax
subsd  -0xe0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1583 <compute_cell_geometry+0x463>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1645 <compute_cell_geometry+0x525>
movslq -0x34(%rbp),%rax
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x30(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15f3 <compute_cell_geometry+0x4d3>
xorps  %xmm0,%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jbe    166e <compute_cell_geometry+0x54e>
movsd  0x9aa(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
je     16a2 <compute_cell_geometry+0x582>
movsd  0x976(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1721 <compute_cell_geometry+0x601>
movslq -0x34(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
movsd  0x941(%rip),%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movslq -0x34(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm2
movslq -0x34(%rbp),%rax
addsd  -0xa0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16c1 <compute_cell_geometry+0x5a1>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1796 <compute_cell_geometry+0x676>
movsd  0x8dc(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
movsd  0x8c4(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x34(%rbp),%rax
subsd  -0xe0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x34(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1728 <compute_cell_geometry+0x608>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17ce <compute_cell_geometry+0x6ae>
movslq -0x34(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x80(%rbp,%rax,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    179d <compute_cell_geometry+0x67d>
jmp    17d3 <compute_cell_geometry+0x6b3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14e6 <compute_cell_geometry+0x3c6>
jmp    17e6 <compute_cell_geometry+0x6c6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1300 <compute_cell_geometry+0x1e0>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    184e <compute_cell_geometry+0x72e>
movslq -0x34(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x34(%rbp),%rax
movsd  -0x100(%rbp,%rax,8),%xmm1
ff ff
divsd  -0x130(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
imul   $0x3,-0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17fb <compute_cell_geometry+0x6db>
movsd  -0x130(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1183 <compute_cell_geometry+0x63>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_cell_geometry>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %r9,0x148(%rsp)
mov    %r8,0x1a8(%rsp)
mov    %rcx,0xd8(%rsp)
mov    %rdx,0x160(%rsp)
mov    %rsi,0x38(%rsp)
mov    0x208(%rsp),%eax
xorpd  %xmm0,%xmm0
movapd %xmm0,0x120(%rsp)
movq   $0x0,0x130(%rsp)
test   %eax,%eax
jle    201d <compute_cell_geometry+0xeed>
mov    0x220(%rsp),%rcx
mov    %edi,%r14d
lea    0x0(,%r14,8),%rbx
mov    %eax,%eax
mov    %rax,0x188(%rsp)
mov    %r14d,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rbp
mov    %rbp,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
lea    -0x2(%r12),%rax
mov    %rax,0xc0(%rsp)
mov    %rax,%rsi
shr    %rsi
add    $0x1,%rsi
mov    %rdx,%rax
mov    %rdx,0x60(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x58(%rsp)
mov    %rsi,%rax
mov    %rsi,0xb8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xb0(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0x150(%rsp)
mov    %rbx,0xc8(%rsp)
and    $0xffffffffffffffe0,%rbx
mov    0x200(%rsp),%rax
lea    -0x1(%r14),%rdx
mov    %rdx,0x158(%rsp)
add    $0x30,%rax
mov    %rax,0x190(%rsp)
mov    0x38(%rsp),%rax
add    $0x30,%rax
mov    %rax,0xd0(%rsp)
mov    0x148(%rsp),%rax
add    $0x18,%rax
mov    %rax,0x198(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x180(%rsp)
movl   $0x0,0x54(%rsp)
xor    %eax,%eax
mov    %r10,0x40(%rsp)
mov    %edi,0x1c(%rsp)
mov    %rbp,0x68(%rsp)
jmp    12bd <compute_cell_geometry+0x18d>
nopl   0x0(%rax)
mov    0x228(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  %xmm4,(%rax,%rcx,8)
addl   $0x3,0x54(%rsp)
mov    0x138(%rsp),%rax
cmp    0x188(%rsp),%rax
je     201d <compute_cell_geometry+0xeed>
mov    %rax,0x48(%rsp)
test   %edi,%edi
jle    12f8 <compute_cell_geometry+0x1c8>
lea    0x20(%rsp),%rdi
xor    %esi,%esi
mov    0xc8(%rsp),%r15
mov    %r15,%rdx
call   1030 <memset@plt>
lea    0xe0(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x1c(%rsp),%edi
mov    0x40(%rsp),%r10
mov    0x210(%rsp),%rax
mov    0x48(%rsp),%rcx
movslq (%rax,%rcx,4),%rbp
mov    0x4(%rax,%rcx,4),%r11d
cmp    %ebp,%r11d
jle    1440 <compute_cell_geometry+0x310>
movslq %r11d,%r8
mov    %rbp,%rcx
jmp    132d <compute_cell_geometry+0x1fd>
nop
add    $0x1,%rcx
cmp    %r8,%rcx
je     1440 <compute_cell_geometry+0x310>
test   %edi,%edi
jle    1320 <compute_cell_geometry+0x1f0>
mov    0x218(%rsp),%rax
movslq (%rax,%rcx,4),%rax
lea    (%rax,%rax,2),%r9
cmp    $0x4,%edi
jae    1350 <compute_cell_geometry+0x220>
xor    %eax,%eax
jmp    1403 <compute_cell_geometry+0x2d3>
nopl   (%rax)
cmpq   $0x0,0x68(%rsp)
je     142f <compute_cell_geometry+0x2ff>
mov    0x190(%rsp),%rax
lea    (%rax,%r9,8),%rdx
mov    0x58(%rsp),%rax
xor    %esi,%esi
nop
movupd -0x30(%rdx,%rsi,8),%xmm0
movupd -0x20(%rdx,%rsi,8),%xmm1
addpd  0x20(%rsp,%rsi,8),%xmm0
addpd  0x30(%rsp,%rsi,8),%xmm1
movapd %xmm0,0x20(%rsp,%rsi,8)
movapd %xmm1,0x30(%rsp,%rsi,8)
movupd -0x10(%rdx,%rsi,8),%xmm0
movupd (%rdx,%rsi,8),%xmm1
addpd  0x40(%rsp,%rsi,8),%xmm0
addpd  0x50(%rsp,%rsi,8),%xmm1
movapd %xmm0,0x40(%rsp,%rsi,8)
movapd %xmm1,0x50(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    1370 <compute_cell_geometry+0x240>
testb  $0x1,0x60(%rsp)
je     13f7 <compute_cell_geometry+0x2c7>
lea    (%rsi,%r9,1),%rax
mov    0x200(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
addpd  0x20(%rsp,%rsi,8),%xmm0
addpd  0x30(%rsp,%rsi,8),%xmm1
movapd %xmm0,0x20(%rsp,%rsi,8)
movapd %xmm1,0x30(%rsp,%rsi,8)
mov    %r10,%rax
cmp    %r14,%r10
je     1320 <compute_cell_geometry+0x1f0>
mov    0x200(%rsp),%rdx
lea    (%rdx,%r9,8),%rdx
nop
movsd  (%rdx,%rax,8),%xmm0
addsd  0x20(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1410 <compute_cell_geometry+0x2e0>
jmp    1320 <compute_cell_geometry+0x1f0>
xor    %esi,%esi
testb  $0x1,0x60(%rsp)
jne    13c8 <compute_cell_geometry+0x298>
jmp    13f7 <compute_cell_geometry+0x2c7>
nopw   0x0(%rax,%rax,1)
test   %edi,%edi
jle    14f9 <compute_cell_geometry+0x3c9>
mov    %r11d,%eax
sub    %ebp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    $0x1,%edi
jne    1460 <compute_cell_geometry+0x330>
xor    %eax,%eax
jmp    14e0 <compute_cell_geometry+0x3b0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xc0(%rsp)
je     1ff6 <compute_cell_geometry+0xec6>
mov    0xb0(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd 0x20(%rsp,%rax,8),%xmm2
movapd 0x30(%rsp,%rax,8),%xmm3
divpd  %xmm1,%xmm2
movapd %xmm2,0x20(%rsp,%rax,8)
divpd  %xmm1,%xmm3
movapd %xmm3,0x30(%rsp,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1490 <compute_cell_geometry+0x360>
testb  $0x1,0xb8(%rsp)
01
je     14d4 <compute_cell_geometry+0x3a4>
movapd 0x20(%rsp,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,0x20(%rsp,%rax,8)
mov    %r12,%rax
cmp    %r14,%r12
je     14f9 <compute_cell_geometry+0x3c9>
nopl   0x0(%rax)
movsd  0x20(%rsp,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    14e0 <compute_cell_geometry+0x3b0>
mov    0x48(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x138(%rsp)
xorpd  %xmm4,%xmm4
cmp    %ebp,%r11d
jle    1ef0 <compute_cell_geometry+0xdc0>
xorpd  %xmm4,%xmm4
jmp    154c <compute_cell_geometry+0x41c>
nopl   (%rax)
mov    0x210(%rsp),%rax
mov    0x138(%rsp),%rcx
mov    (%rax,%rcx,4),%r11d
mov    0x140(%rsp),%rbp
add    $0x1,%rbp
movslq %r11d,%rax
cmp    %rax,%rbp
jge    1ef0 <compute_cell_geometry+0xdc0>
test   %edi,%edi
jle    1598 <compute_cell_geometry+0x468>
mov    %rsp,%rdi
xor    %esi,%esi
mov    0xc8(%rsp),%r15
mov    %r15,%rdx
movapd %xmm4,0x170(%rsp)
mov    %r11d,%r13d
call   1030 <memset@plt>
lea    0x120(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    %r13d,%r11d
movapd 0x170(%rsp),%xmm4
mov    0x1c(%rsp),%edi
mov    0x40(%rsp),%r10
mov    0x218(%rsp),%rax
mov    %rbp,0x140(%rsp)
movslq (%rax,%rbp,4),%rcx
mov    0x160(%rsp),%rax
movslq (%rax,%rcx,4),%r13
mov    %rcx,0x168(%rsp)
movslq 0x4(%rax,%rcx,4),%r8
cmp    %r13d,%r8d
mov    0x68(%rsp),%rbp
jle    1700 <compute_cell_geometry+0x5d0>
mov    %r13,%rcx
jmp    15ed <compute_cell_geometry+0x4bd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r8,%rcx
je     1700 <compute_cell_geometry+0x5d0>
test   %edi,%edi
jle    15e0 <compute_cell_geometry+0x4b0>
mov    0xd8(%rsp),%rax
movslq (%rax,%rcx,4),%rax
lea    (%rax,%rax,2),%rdx
cmp    $0x4,%edi
jae    1610 <compute_cell_geometry+0x4e0>
xor    %eax,%eax
jmp    16c3 <compute_cell_geometry+0x593>
nopl   (%rax)
test   %rbp,%rbp
je     16ed <compute_cell_geometry+0x5bd>
mov    0xd0(%rsp),%rax
lea    (%rax,%rdx,8),%rbp
mov    0x58(%rsp),%rax
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x30(%rbp,%rsi,8),%xmm0
movupd -0x20(%rbp,%rsi,8),%xmm1
addpd  (%rsp,%rsi,8),%xmm0
addpd  0x10(%rsp,%rsi,8),%xmm1
movapd %xmm0,(%rsp,%rsi,8)
movapd %xmm1,0x10(%rsp,%rsi,8)
movupd -0x10(%rbp,%rsi,8),%xmm0
movupd 0x0(%rbp,%rsi,8),%xmm1
addpd  0x20(%rsp,%rsi,8),%xmm0
addpd  0x30(%rsp,%rsi,8),%xmm1
movapd %xmm0,0x20(%rsp,%rsi,8)
movapd %xmm1,0x30(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rax
jne    1630 <compute_cell_geometry+0x500>
testb  $0x1,0x60(%rsp)
je     16b2 <compute_cell_geometry+0x582>
lea    (%rsi,%rdx,1),%rax
mov    0x38(%rsp),%rbp
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
addpd  (%rsp,%rsi,8),%xmm0
addpd  0x10(%rsp,%rsi,8),%xmm1
movapd %xmm0,(%rsp,%rsi,8)
movapd %xmm1,0x10(%rsp,%rsi,8)
mov    %r10,%rax
cmp    %r14,%r10
mov    0x68(%rsp),%rbp
je     15e0 <compute_cell_geometry+0x4b0>
mov    0x38(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
nopl   0x0(%rax)
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    16d0 <compute_cell_geometry+0x5a0>
jmp    15e0 <compute_cell_geometry+0x4b0>
xor    %esi,%esi
testb  $0x1,0x60(%rsp)
jne    1687 <compute_cell_geometry+0x557>
jmp    16b2 <compute_cell_geometry+0x582>
nopl   0x0(%rax,%rax,1)
test   %edi,%edi
jle    18dc <compute_cell_geometry+0x7ac>
mov    %r8d,%eax
sub    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    $0x1,%edi
jne    1730 <compute_cell_geometry+0x600>
xor    %eax,%eax
jmp    17b0 <compute_cell_geometry+0x680>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xc0(%rsp)
je     1ec2 <compute_cell_geometry+0xd92>
mov    0xb0(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd (%rsp,%rcx,8),%xmm2
movapd 0x10(%rsp,%rcx,8),%xmm3
divpd  %xmm1,%xmm2
movapd %xmm2,(%rsp,%rcx,8)
divpd  %xmm1,%xmm3
movapd %xmm3,0x10(%rsp,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rax
jne    1760 <compute_cell_geometry+0x630>
testb  $0x1,0xb8(%rsp)
01
je     17a0 <compute_cell_geometry+0x670>
movapd (%rsp,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,(%rsp,%rcx,8)
mov    %r12,%rax
cmp    %r14,%r12
je     17c7 <compute_cell_geometry+0x697>
nopl   0x0(%rax,%rax,1)
movsd  (%rsp,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    17b0 <compute_cell_geometry+0x680>
test   %edi,%edi
jle    18dc <compute_cell_geometry+0x7ac>
mov    0xd8(%rsp),%rax
movslq -0x4(%rax,%r8,4),%rax
lea    (%rax,%rax,2),%rcx
cmp    $0x4,%edi
jae    17ec <compute_cell_geometry+0x6bc>
xor    %eax,%eax
jmp    18ac <compute_cell_geometry+0x77c>
test   %rbp,%rbp
je     1ed7 <compute_cell_geometry+0xda7>
mov    0xd0(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
mov    0x58(%rsp),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
subpd  (%rsp,%rdx,8),%xmm0
subpd  0x10(%rsp,%rdx,8),%xmm1
movapd %xmm0,0x90(%rsp,%rdx,8)
movapd %xmm1,0xa0(%rsp,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
subpd  0x20(%rsp,%rdx,8),%xmm0
subpd  0x30(%rsp,%rdx,8),%xmm1
movapd %xmm0,0xb0(%rsp,%rdx,8)
movapd %xmm1,0xc0(%rsp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1810 <compute_cell_geometry+0x6e0>
testb  $0x1,0x60(%rsp)
je     18a4 <compute_cell_geometry+0x774>
lea    (%rdx,%rcx,1),%rax
mov    0x38(%rsp),%rsi
movupd (%rsi,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
subpd  (%rsp,%rdx,8),%xmm0
subpd  0x10(%rsp,%rdx,8),%xmm1
movapd %xmm0,0x90(%rsp,%rdx,8)
movapd %xmm1,0xa0(%rsp,%rdx,8)
mov    %r10,%rax
cmp    %r14,%r10
je     18dc <compute_cell_geometry+0x7ac>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rax,8),%xmm0
subsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,0x90(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    18c0 <compute_cell_geometry+0x790>
cmp    %r13d,%r8d
jle    1534 <compute_cell_geometry+0x404>
mov    0x168(%rsp),%rbp
lea    0x0(%rbp,%rbp,2),%eax
add    %rbp,%rbp
movslq %eax,%rcx
mov    0x198(%rsp),%rax
mov    %rcx,0x1a0(%rsp)
lea    (%rax,%rcx,8),%r15
jmp    193f <compute_cell_geometry+0x80f>
nopl   (%rax)
movapd 0x170(%rsp),%xmm4
addsd  %xmm7,%xmm4
add    $0x1,%r13
mov    0x160(%rsp),%rax
mov    0x168(%rsp),%rcx
movslq 0x4(%rax,%rcx,4),%rax
cmp    %rax,%r13
jge    1520 <compute_cell_geometry+0x3f0>
test   %edi,%edi
movapd %xmm4,0x170(%rsp)
jle    1970 <compute_cell_geometry+0x840>
mov    0xd8(%rsp),%rax
movslq (%rax,%r13,4),%rax
lea    (%rax,%rax,2),%rax
cmp    $0x4,%edi
jae    19c0 <compute_cell_geometry+0x890>
xor    %ecx,%ecx
jmp    1a76 <compute_cell_geometry+0x946>
nopl   0x0(%rax,%rax,1)
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
lea    0x100(%rsp),%rdx
xor    %eax,%eax
call   1050 <cross@plt>
movapd 0x16ac(%rip),%xmm6
movsd  0x166c(%rip),%xmm5
movapd 0x168c(%rip),%xmm4
mov    0x1c(%rsp),%edi
mov    0x40(%rsp),%r10
xorpd  %xmm0,%xmm0
xorpd  %xmm7,%xmm7
jmp    1cd0 <compute_cell_geometry+0xba0>
nopw   0x0(%rax,%rax,1)
cmpq   $0x0,0x68(%rsp)
je     1eb0 <compute_cell_geometry+0xd80>
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0x58(%rsp),%rsi
xor    %ecx,%ecx
nop
movupd -0x30(%rdx,%rcx,8),%xmm0
movupd -0x20(%rdx,%rcx,8),%xmm1
subpd  (%rsp,%rcx,8),%xmm0
subpd  0x10(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x70(%rsp,%rcx,8)
movapd %xmm1,0x80(%rsp,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
subpd  0x20(%rsp,%rcx,8),%xmm0
subpd  0x30(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x90(%rsp,%rcx,8)
movapd %xmm1,0xa0(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    19e0 <compute_cell_geometry+0x8b0>
testb  $0x1,0x60(%rsp)
je     1a6e <compute_cell_geometry+0x93e>
lea    (%rcx,%rax,1),%rdx
mov    0x38(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
subpd  (%rsp,%rcx,8),%xmm0
subpd  0x10(%rsp,%rcx,8),%xmm1
movapd %xmm0,0x70(%rsp,%rcx,8)
movapd %xmm1,0x80(%rsp,%rcx,8)
mov    %r10,%rcx
cmp    %r14,%r10
je     1a99 <compute_cell_geometry+0x969>
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nop
movsd  (%rax,%rcx,8),%xmm0
subsd  (%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x70(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1a80 <compute_cell_geometry+0x950>
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
lea    0x100(%rsp),%rdx
xor    %eax,%eax
call   1050 <cross@plt>
mov    0x1c(%rsp),%edi
test   %edi,%edi
jle    1ba0 <compute_cell_geometry+0xa70>
cmpq   $0x0,0x158(%rsp)
je     1bca <compute_cell_geometry+0xa9a>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x40(%rsp),%r10
mov    0x150(%rsp),%rsi
movsd  0x1515(%rip),%xmm4
movsd  0x1515(%rip),%xmm5
movapd 0x1545(%rip),%xmm6
nopl   0x0(%rax,%rax,1)
movsd  0x100(%rsp,%rax,8),%xmm2
mulsd  %xmm4,%xmm2
movsd  (%rsp,%rax,8),%xmm3
movsd  0x8(%rsp,%rax,8),%xmm0
subsd  0x20(%rsp,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  0x108(%rsp,%rax,8),%xmm1
mulsd  %xmm4,%xmm1
subsd  0x28(%rsp,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%r12
jne    1b00 <compute_cell_geometry+0x9d0>
test   $0x1,%r14b
je     1b74 <compute_cell_geometry+0xa44>
movsd  0x100(%rsp,%rax,8),%xmm1
mulsd  %xmm4,%xmm1
movsd  (%rsp,%rax,8),%xmm2
subsd  0x20(%rsp,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
test   %edi,%edi
jle    1c04 <compute_cell_geometry+0xad4>
cmpq   $0x3,0x158(%rsp)
jae    1c15 <compute_cell_geometry+0xae5>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
movapd 0x1497(%rip),%xmm4
jmp    1c88 <compute_cell_geometry+0xb58>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xorpd  %xmm7,%xmm7
mov    0x40(%rsp),%r10
movapd 0x147b(%rip),%xmm4
movsd  0x144b(%rip),%xmm5
movapd 0x147b(%rip),%xmm6
jmp    1cd0 <compute_cell_geometry+0xba0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%r10
mov    0x150(%rsp),%rsi
movsd  0x141b(%rip),%xmm4
movsd  0x141b(%rip),%xmm5
movapd 0x144b(%rip),%xmm6
test   $0x1,%r14b
jne    1b54 <compute_cell_geometry+0xa24>
jmp    1b74 <compute_cell_geometry+0xa44>
xorpd  %xmm7,%xmm7
movapd 0x1420(%rip),%xmm4
jmp    1cd0 <compute_cell_geometry+0xba0>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
movapd 0x140d(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x100(%rsp,%rax,8),%xmm1
movsd  0x108(%rsp,%rax,8),%xmm2
mulsd  -0x18(%r15,%rax,8),%xmm1
mulsd  -0x10(%r15,%rax,8),%xmm2
addsd  %xmm7,%xmm1
movsd  0x110(%rsp,%rax,8),%xmm3
mulsd  -0x8(%r15,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x118(%rsp,%rax,8),%xmm7
mulsd  (%r15,%rax,8),%xmm7
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm7
add    $0x4,%rax
cmp    %rax,%r10
jne    1c30 <compute_cell_geometry+0xb00>
test   %rsi,%rsi
je     1cd0 <compute_cell_geometry+0xba0>
mov    0x1a0(%rsp),%rcx
add    %rax,%rcx
mov    0x148(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rsp,%rax,8),%rax
add    $0x100,%rax
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm7
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1cb0 <compute_cell_geometry+0xb80>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
xorpd  %xmm4,%xmm1
cmpltsd 0x133f(%rip),%xmm7
andpd  %xmm7,%xmm1
andnpd %xmm0,%xmm7
orpd   %xmm1,%xmm7
mov    0x1a8(%rsp),%rax
mov    (%rax,%rbp,4),%eax
cmp    %rax,0x48(%rsp)
je     1d03 <compute_cell_geometry+0xbd3>
xorpd  %xmm4,%xmm7
test   %edi,%edi
jle    1910 <compute_cell_geometry+0x7e0>
xor    %eax,%eax
cmp    $0x4,%edi
jb     1d80 <compute_cell_geometry+0xc50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd 0x90(%rsp,%rax,1),%xmm0
movapd 0xa0(%rsp,%rax,1),%xmm1
addpd  0x70(%rsp,%rax,1),%xmm0
addpd  0x80(%rsp,%rax,1),%xmm1
mulpd  %xmm6,%xmm0
addpd  (%rsp,%rax,1),%xmm0
mulpd  %xmm6,%xmm1
addpd  0x10(%rsp,%rax,1),%xmm1
movapd %xmm0,0x120(%rsp,%rax,1)
movapd %xmm1,0x130(%rsp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1d20 <compute_cell_geometry+0xbf0>
mov    %r10,%rax
cmp    %r14,%r10
je     1daa <compute_cell_geometry+0xc7a>
nopw   0x0(%rax,%rax,1)
movsd  0x90(%rsp,%rax,8),%xmm0
addsd  0x70(%rsp,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,0x120(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1d80 <compute_cell_geometry+0xc50>
test   %edi,%edi
jle    1910 <compute_cell_geometry+0x7e0>
movapd %xmm7,%xmm0
mulsd  0x1252(%rip),%xmm0
mulsd  0x1252(%rip),%xmm0
cmp    $0x4,%edi
jae    1dcf <compute_cell_geometry+0xc9f>
xor    %eax,%eax
jmp    1e40 <compute_cell_geometry+0xd10>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x120(%rsp,%rax,1),%xmm2
movapd 0x130(%rsp,%rax,1),%xmm3
subpd  0x20(%rsp,%rax,1),%xmm2
subpd  0x30(%rsp,%rax,1),%xmm3
mulpd  %xmm1,%xmm2
addpd  0xe0(%rsp,%rax,1),%xmm2
mulpd  %xmm1,%xmm3
addpd  0xf0(%rsp,%rax,1),%xmm3
movapd %xmm2,0xe0(%rsp,%rax,1)
movapd %xmm3,0xf0(%rsp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1de0 <compute_cell_geometry+0xcb0>
mov    %r10,%rax
cmp    %r14,%r10
je     1e6e <compute_cell_geometry+0xd3e>
nopl   0x0(%rax,%rax,1)
movsd  0x120(%rsp,%rax,8),%xmm1
subsd  0x20(%rsp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xe0(%rsp,%rax,8),%xmm1
movsd  %xmm1,0xe0(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1e40 <compute_cell_geometry+0xd10>
test   %edi,%edi
jle    1910 <compute_cell_geometry+0x7e0>
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
mov    0xc8(%rsp),%rdx
movapd %xmm7,0x1b0(%rsp)
call   1040 <memcpy@plt>
movapd 0x1b0(%rsp),%xmm7
mov    0x1c(%rsp),%edi
mov    0x40(%rsp),%r10
jmp    1910 <compute_cell_geometry+0x7e0>
xor    %ecx,%ecx
testb  $0x1,0x60(%rsp)
jne    1a40 <compute_cell_geometry+0x910>
jmp    1a6e <compute_cell_geometry+0x93e>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
jne    1792 <compute_cell_geometry+0x662>
jmp    17a0 <compute_cell_geometry+0x670>
xor    %edx,%edx
testb  $0x1,0x60(%rsp)
jne    1873 <compute_cell_geometry+0x743>
jmp    18a4 <compute_cell_geometry+0x774>
nopl   0x0(%rax)
test   %edi,%edi
jle    1290 <compute_cell_geometry+0x160>
mov    0x54(%rsp),%eax
cmp    $0x1,%edi
jne    1f10 <compute_cell_geometry+0xde0>
xor    %ecx,%ecx
jmp    1fbc <compute_cell_geometry+0xe8c>
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmpq   $0x0,0xc0(%rsp)
je     200b <compute_cell_geometry+0xedb>
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xb0(%rsp),%rsi
xor    %ecx,%ecx
nopl   (%rax)
movapd 0xe0(%rsp,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
addpd  0x20(%rsp,%rcx,8),%xmm1
movupd %xmm1,-0x10(%rdx,%rcx,8)
movapd 0xf0(%rsp,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
addpd  0x30(%rsp,%rcx,8),%xmm1
movupd %xmm1,(%rdx,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1f40 <compute_cell_geometry+0xe10>
testb  $0x1,0xb8(%rsp)
01
je     1fb0 <compute_cell_geometry+0xe80>
mov    0x48(%rsp),%rdx
lea    (%rdx,%rdx,2),%edx
movapd 0xe0(%rsp,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
addpd  0x20(%rsp,%rcx,8),%xmm1
add    %rcx,%rdx
mov    0x220(%rsp),%rcx
movupd %xmm1,(%rcx,%rdx,8)
mov    %r12,%rcx
cmp    %r14,%r12
je     1290 <compute_cell_geometry+0x160>
mov    0x220(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  0xe0(%rsp,%rcx,8),%xmm0
divsd  %xmm4,%xmm0
addsd  0x20(%rsp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1fd0 <compute_cell_geometry+0xea0>
jmp    1290 <compute_cell_geometry+0x160>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
jne    14c4 <compute_cell_geometry+0x394>
jmp    14d4 <compute_cell_geometry+0x3a4>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
jne    1f85 <compute_cell_geometry+0xe55>
jmp    1fb0 <compute_cell_geometry+0xe80>
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @compute_cell_geometry(i32 %0, double* nocapture %1, i32* nocapture %2, i32* nocapture %3, i32* nocapture %4, double* nocapture %5, double* nocapture %6, i32 %7, i32* nocapture %8, i32* nocapture %9, double* nocapture writeonly %10, double* nocapture writeonly %11) {
%13 = alloca [3 x double]
%14 = bitcast [3 x double]* %13 to i8*
%15 = alloca [3 x double]
%16 = bitcast [3 x double]* %15 to i8*
%17 = alloca [3 x double]
%18 = bitcast [3 x double]* %17 to i8*
%19 = alloca [3 x double]
%20 = alloca [3 x double]
%21 = bitcast [3 x double]* %20 to i8*
%22 = alloca [3 x double]
%23 = bitcast [3 x double]* %22 to i8*
%24 = alloca [3 x double]
%25 = bitcast [3 x double]* %24 to i8*
%26 = bitcast [3 x double]* %19 to i8*
%27 = icmp sgt i32 %7, 0
br i1 %27, label %28, label %879
28: ; preds = %12
%29 = icmp sgt i32 %0, 0
%30 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%31 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 0
%32 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 0
%33 = zext i32 %0 to i64
%34 = shl nuw nsw i64 %33, 3
%35 = zext i32 %7 to i64
%36 = and i64 %33, 4294967292
%37 = add nsw i64 %36, -4
%38 = lshr exact i64 %37, 2
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %33, 4294967294
%41 = add nsw i64 %40, -2
%42 = lshr exact i64 %41, 1
%43 = add nuw i64 %42, 1
%44 = add nsw i64 %33, -1
%45 = icmp ult i32 %0, 4
%46 = and i64 %33, 4294967292
%47 = and i64 %39, 1
%48 = icmp eq i64 %37, 0
%49 = and i64 %39, 9223372036854775806
%50 = icmp eq i64 %47, 0
%51 = icmp eq i64 %46, %33
%52 = icmp eq i32 %0, 1
%53 = and i64 %33, 4294967294
%54 = and i64 %43, 1
%55 = icmp eq i64 %41, 0
%56 = and i64 %43, -2
%57 = icmp eq i64 %54, 0
%58 = icmp eq i64 %53, %33
%59 = icmp ult i32 %0, 4
%60 = and i64 %33, 4294967292
%61 = and i64 %39, 1
%62 = icmp eq i64 %37, 0
%63 = and i64 %39, 9223372036854775806
%64 = icmp eq i64 %61, 0
%65 = icmp eq i64 %60, %33
%66 = icmp eq i32 %0, 1
%67 = and i64 %33, 4294967294
%68 = and i64 %43, 1
%69 = icmp eq i64 %41, 0
%70 = and i64 %43, -2
%71 = icmp eq i64 %68, 0
%72 = icmp eq i64 %67, %33
%73 = icmp ult i32 %0, 4
%74 = and i64 %33, 4294967292
%75 = and i64 %39, 1
%76 = icmp eq i64 %37, 0
%77 = and i64 %39, 9223372036854775806
%78 = icmp eq i64 %75, 0
%79 = icmp eq i64 %74, %33
%80 = icmp ult i32 %0, 4
%81 = and i64 %33, 4294967292
%82 = and i64 %39, 1
%83 = icmp eq i64 %37, 0
%84 = and i64 %39, 9223372036854775806
%85 = icmp eq i64 %82, 0
%86 = icmp eq i64 %81, %33
%87 = and i64 %33, 1
%88 = icmp eq i64 %44, 0
%89 = and i64 %33, 4294967294
%90 = icmp eq i64 %87, 0
%91 = and i64 %33, 3
%92 = icmp ult i64 %44, 3
%93 = and i64 %33, 4294967292
%94 = icmp eq i64 %91, 0
%95 = icmp ult i32 %0, 4
%96 = and i64 %33, 4294967292
%97 = icmp eq i64 %96, %33
%98 = icmp ult i32 %0, 4
%99 = and i64 %33, 4294967292
%100 = icmp eq i64 %99, %33
%101 = icmp eq i32 %0, 1
%102 = and i64 %33, 4294967294
%103 = and i64 %43, 1
%104 = icmp eq i64 %41, 0
%105 = and i64 %43, -2
%106 = icmp eq i64 %103, 0
%107 = icmp eq i64 %102, %33
br label %108
108: ; preds = %28, %876
%109 = phi i64 [ 0, %28 ], [ %114, %876 ]
br i1 %29, label %110, label %111
110: ; preds = %108
br label %111
111: ; preds = %108, %110
%112 = getelementptr inbounds i32, i32* %8, i64 %109
%113 = load i32, i32* %112
%114 = add nuw nsw i64 %109, 1
%115 = getelementptr inbounds i32, i32* %8, i64 %114
%116 = load i32, i32* %115
%117 = icmp sgt i32 %116, %113
br i1 %117, label %118, label %206
118: ; preds = %111
%119 = sext i32 %113 to i64
%120 = sext i32 %116 to i64
br label %121
121: ; preds = %118, %203
%122 = phi i64 [ %119, %118 ], [ %204, %203 ]
br i1 %29, label %123, label %203
123: ; preds = %121
%124 = getelementptr inbounds i32, i32* %9, i64 %122
%125 = load i32, i32* %124
%126 = mul nsw i32 %125, 3
%127 = sext i32 %126 to i64
br i1 %45, label %191, label %128
128: ; preds = %123
br i1 %48, label %170, label %129
129: ; preds = %128, %129
%130 = phi i64 [ %167, %129 ], [ 0, %128 ]
%131 = phi i64 [ %168, %129 ], [ 0, %128 ]
%132 = add nsw i64 %130, %127
%133 = getelementptr inbounds double, double* %6, i64 %132
%134 = bitcast double* %133 to <2 x double>*
%135 = load <2 x double>, <2 x double>* %134
%136 = getelementptr inbounds double, double* %133, i64 2
%137 = bitcast double* %136 to <2 x double>*
%138 = load <2 x double>, <2 x double>* %137
%139 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %130
%140 = bitcast double* %139 to <2 x double>*
%141 = load <2 x double>, <2 x double>* %140
%142 = getelementptr inbounds double, double* %139, i64 2
%143 = bitcast double* %142 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = fadd <2 x double> %135, %141
%146 = fadd <2 x double> %138, %144
%147 = bitcast double* %139 to <2 x double>*
store <2 x double> %145, <2 x double>* %147
%148 = bitcast double* %142 to <2 x double>*
store <2 x double> %146, <2 x double>* %148
%149 = or i64 %130, 4
%150 = add nsw i64 %149, %127
%151 = getelementptr inbounds double, double* %6, i64 %150
%152 = bitcast double* %151 to <2 x double>*
%153 = load <2 x double>, <2 x double>* %152
%154 = getelementptr inbounds double, double* %151, i64 2
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %149
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = getelementptr inbounds double, double* %157, i64 2
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = fadd <2 x double> %153, %159
%164 = fadd <2 x double> %156, %162
%165 = bitcast double* %157 to <2 x double>*
store <2 x double> %163, <2 x double>* %165
%166 = bitcast double* %160 to <2 x double>*
store <2 x double> %164, <2 x double>* %166
%167 = add nuw i64 %130, 8
%168 = add i64 %131, 2
%169 = icmp eq i64 %168, %49
br i1 %169, label %170, label %129
170: ; preds = %129, %128
%171 = phi i64 [ 0, %128 ], [ %167, %129 ]
br i1 %50, label %190, label %172
172: ; preds = %170
%173 = add nsw i64 %171, %127
%174 = getelementptr inbounds double, double* %6, i64 %173
%175 = bitcast double* %174 to <2 x double>*
%176 = load <2 x double>, <2 x double>* %175
%177 = getelementptr inbounds double, double* %174, i64 2
%178 = bitcast double* %177 to <2 x double>*
%179 = load <2 x double>, <2 x double>* %178
%180 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %171
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = getelementptr inbounds double, double* %180, i64 2
%184 = bitcast double* %183 to <2 x double>*
%185 = load <2 x double>, <2 x double>* %184
%186 = fadd <2 x double> %176, %182
%187 = fadd <2 x double> %179, %185
%188 = bitcast double* %180 to <2 x double>*
store <2 x double> %186, <2 x double>* %188
%189 = bitcast double* %183 to <2 x double>*
store <2 x double> %187, <2 x double>* %189
br label %190
190: ; preds = %170, %172
br i1 %51, label %203, label %191
191: ; preds = %123, %190
%192 = phi i64 [ 0, %123 ], [ %46, %190 ]
br label %193
193: ; preds = %191, %193
%194 = phi i64 [ %201, %193 ], [ %192, %191 ]
%195 = add nsw i64 %194, %127
%196 = getelementptr inbounds double, double* %6, i64 %195
%197 = load double, double* %196
%198 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %194
%199 = load double, double* %198
%200 = fadd double %197, %199
store double %200, double* %198
%201 = add nuw nsw i64 %194, 1
%202 = icmp eq i64 %201, %33
br i1 %202, label %203, label %193
203: ; preds = %193, %190, %121
%204 = add nsw i64 %122, 1
%205 = icmp eq i64 %204, %120
br i1 %205, label %206, label %121
206: ; preds = %203, %111
br i1 %29, label %207, label %241
207: ; preds = %206
%208 = sub nsw i32 %116, %113
%209 = sitofp i32 %208 to double
br i1 %52, label %239, label %210
210: ; preds = %207
%211 = insertelement <2 x double> poison, double %209, i64 0
%212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %55, label %230, label %213
213: ; preds = %210, %213
%214 = phi i64 [ %227, %213 ], [ 0, %210 ]
%215 = phi i64 [ %228, %213 ], [ 0, %210 ]
%216 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %214
%217 = bitcast double* %216 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = fdiv <2 x double> %218, %212
%220 = bitcast double* %216 to <2 x double>*
store <2 x double> %219, <2 x double>* %220
%221 = or i64 %214, 2
%222 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %221
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = fdiv <2 x double> %224, %212
%226 = bitcast double* %222 to <2 x double>*
store <2 x double> %225, <2 x double>* %226
%227 = add nuw i64 %214, 4
%228 = add nuw i64 %215, 2
%229 = icmp eq i64 %228, %56
br i1 %229, label %230, label %213
230: ; preds = %213, %210
%231 = phi i64 [ 0, %210 ], [ %227, %213 ]
br i1 %57, label %238, label %232
232: ; preds = %230
%233 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %231
%234 = bitcast double* %233 to <2 x double>*
%235 = load <2 x double>, <2 x double>* %234
%236 = fdiv <2 x double> %235, %212
%237 = bitcast double* %233 to <2 x double>*
store <2 x double> %236, <2 x double>* %237
br label %238
238: ; preds = %230, %232
br i1 %58, label %241, label %239
239: ; preds = %207, %238
%240 = phi i64 [ 0, %207 ], [ %53, %238 ]
br label %244
241: ; preds = %244, %238, %206
br i1 %117, label %242, label %251
242: ; preds = %241
%243 = sext i32 %113 to i64
br label %305
244: ; preds = %239, %244
%245 = phi i64 [ %249, %244 ], [ %240, %239 ]
%246 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %245
%247 = load double, double* %246
%248 = fdiv double %247, %209
store double %248, double* %246
%249 = add nuw nsw i64 %245, 1
%250 = icmp eq i64 %249, %33
br i1 %250, label %241, label %244
251: ; preds = %858, %241
%252 = phi double [ 0.000000e+00, %241 ], [ %860, %858 ]
br i1 %29, label %253, label %876
253: ; preds = %251
%254 = mul i64 %109, 3
%255 = and i64 %254, 4294967295
br i1 %101, label %303, label %256
256: ; preds = %253
%257 = insertelement <2 x double> poison, double %252, i64 0
%258 = shufflevector <2 x double> %257, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %104, label %288, label %259
259: ; preds = %256, %259
%260 = phi i64 [ %285, %259 ], [ 0, %256 ]
%261 = phi i64 [ %286, %259 ], [ 0, %256 ]
%262 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %260
%263 = bitcast double* %262 to <2 x double>*
%264 = load <2 x double>, <2 x double>* %263
%265 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %260
%266 = bitcast double* %265 to <2 x double>*
%267 = load <2 x double>, <2 x double>* %266
%268 = fdiv <2 x double> %267, %258
%269 = fadd <2 x double> %264, %268
%270 = add nuw nsw i64 %260, %255
%271 = getelementptr inbounds double, double* %10, i64 %270
%272 = bitcast double* %271 to <2 x double>*
store <2 x double> %269, <2 x double>* %272
%273 = or i64 %260, 2
%274 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %273
%275 = bitcast double* %274 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %273
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = fdiv <2 x double> %279, %258
%281 = fadd <2 x double> %276, %280
%282 = add nuw nsw i64 %273, %255
%283 = getelementptr inbounds double, double* %10, i64 %282
%284 = bitcast double* %283 to <2 x double>*
store <2 x double> %281, <2 x double>* %284
%285 = add nuw i64 %260, 4
%286 = add nuw i64 %261, 2
%287 = icmp eq i64 %286, %105
br i1 %287, label %288, label %259
288: ; preds = %259, %256
%289 = phi i64 [ 0, %256 ], [ %285, %259 ]
br i1 %106, label %302, label %290
290: ; preds = %288
%291 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %289
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %289
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = fdiv <2 x double> %296, %258
%298 = fadd <2 x double> %293, %297
%299 = add nuw nsw i64 %289, %255
%300 = getelementptr inbounds double, double* %10, i64 %299
%301 = bitcast double* %300 to <2 x double>*
store <2 x double> %298, <2 x double>* %301
br label %302
302: ; preds = %288, %290
br i1 %107, label %876, label %303
303: ; preds = %253, %302
%304 = phi i64 [ 0, %253 ], [ %102, %302 ]
br label %864
305: ; preds = %242, %858
%306 = phi i32 [ %116, %242 ], [ %859, %858 ]
%307 = phi i64 [ %243, %242 ], [ %861, %858 ]
%308 = phi double [ 0.000000e+00, %242 ], [ %860, %858 ]
br i1 %29, label %309, label %310
309: ; preds = %305
br label %310
310: ; preds = %305, %309
%311 = getelementptr inbounds i32, i32* %9, i64 %307
%312 = load i32, i32* %311
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i32, i32* %2, i64 %313
%315 = load i32, i32* %314
%316 = add nsw i32 %312, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %2, i64 %317
%319 = load i32, i32* %318
%320 = icmp sgt i32 %319, %315
br i1 %320, label %321, label %409
321: ; preds = %310
%322 = sext i32 %315 to i64
%323 = sext i32 %319 to i64
br label %324
324: ; preds = %321, %406
%325 = phi i64 [ %322, %321 ], [ %407, %406 ]
br i1 %29, label %326, label %406
326: ; preds = %324
%327 = getelementptr inbounds i32, i32* %3, i64 %325
%328 = load i32, i32* %327
%329 = mul nsw i32 %328, 3
%330 = sext i32 %329 to i64
br i1 %59, label %394, label %331
331: ; preds = %326
br i1 %62, label %373, label %332
332: ; preds = %331, %332
%333 = phi i64 [ %370, %332 ], [ 0, %331 ]
%334 = phi i64 [ %371, %332 ], [ 0, %331 ]
%335 = add nsw i64 %333, %330
%336 = getelementptr inbounds double, double* %1, i64 %335
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = getelementptr inbounds double, double* %336, i64 2
%340 = bitcast double* %339 to <2 x double>*
%341 = load <2 x double>, <2 x double>* %340
%342 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %333
%343 = bitcast double* %342 to <2 x double>*
%344 = load <2 x double>, <2 x double>* %343
%345 = getelementptr inbounds double, double* %342, i64 2
%346 = bitcast double* %345 to <2 x double>*
%347 = load <2 x double>, <2 x double>* %346
%348 = fadd <2 x double> %338, %344
%349 = fadd <2 x double> %341, %347
%350 = bitcast double* %342 to <2 x double>*
store <2 x double> %348, <2 x double>* %350
%351 = bitcast double* %345 to <2 x double>*
store <2 x double> %349, <2 x double>* %351
%352 = or i64 %333, 4
%353 = add nsw i64 %352, %330
%354 = getelementptr inbounds double, double* %1, i64 %353
%355 = bitcast double* %354 to <2 x double>*
%356 = load <2 x double>, <2 x double>* %355
%357 = getelementptr inbounds double, double* %354, i64 2
%358 = bitcast double* %357 to <2 x double>*
%359 = load <2 x double>, <2 x double>* %358
%360 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %352
%361 = bitcast double* %360 to <2 x double>*
%362 = load <2 x double>, <2 x double>* %361
%363 = getelementptr inbounds double, double* %360, i64 2
%364 = bitcast double* %363 to <2 x double>*
%365 = load <2 x double>, <2 x double>* %364
%366 = fadd <2 x double> %356, %362
%367 = fadd <2 x double> %359, %365
%368 = bitcast double* %360 to <2 x double>*
store <2 x double> %366, <2 x double>* %368
%369 = bitcast double* %363 to <2 x double>*
store <2 x double> %367, <2 x double>* %369
%370 = add nuw i64 %333, 8
%371 = add i64 %334, 2
%372 = icmp eq i64 %371, %63
br i1 %372, label %373, label %332
373: ; preds = %332, %331
%374 = phi i64 [ 0, %331 ], [ %370, %332 ]
br i1 %64, label %393, label %375
375: ; preds = %373
%376 = add nsw i64 %374, %330
%377 = getelementptr inbounds double, double* %1, i64 %376
%378 = bitcast double* %377 to <2 x double>*
%379 = load <2 x double>, <2 x double>* %378
%380 = getelementptr inbounds double, double* %377, i64 2
%381 = bitcast double* %380 to <2 x double>*
%382 = load <2 x double>, <2 x double>* %381
%383 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %374
%384 = bitcast double* %383 to <2 x double>*
%385 = load <2 x double>, <2 x double>* %384
%386 = getelementptr inbounds double, double* %383, i64 2
%387 = bitcast double* %386 to <2 x double>*
%388 = load <2 x double>, <2 x double>* %387
%389 = fadd <2 x double> %379, %385
%390 = fadd <2 x double> %382, %388
%391 = bitcast double* %383 to <2 x double>*
store <2 x double> %389, <2 x double>* %391
%392 = bitcast double* %386 to <2 x double>*
store <2 x double> %390, <2 x double>* %392
br label %393
393: ; preds = %373, %375
br i1 %65, label %406, label %394
394: ; preds = %326, %393
%395 = phi i64 [ 0, %326 ], [ %60, %393 ]
br label %396
396: ; preds = %394, %396
%397 = phi i64 [ %404, %396 ], [ %395, %394 ]
%398 = add nsw i64 %397, %330
%399 = getelementptr inbounds double, double* %1, i64 %398
%400 = load double, double* %399
%401 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %397
%402 = load double, double* %401
%403 = fadd double %400, %402
store double %403, double* %401
%404 = add nuw nsw i64 %397, 1
%405 = icmp eq i64 %404, %33
br i1 %405, label %406, label %396
406: ; preds = %396, %393, %324
%407 = add nsw i64 %325, 1
%408 = icmp eq i64 %407, %323
br i1 %408, label %409, label %324
409: ; preds = %406, %310
br i1 %29, label %410, label %530
410: ; preds = %409
%411 = sub nsw i32 %319, %315
%412 = sitofp i32 %411 to double
br i1 %66, label %442, label %413
413: ; preds = %410
%414 = insertelement <2 x double> poison, double %412, i64 0
%415 = shufflevector <2 x double> %414, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %69, label %433, label %416
416: ; preds = %413, %416
%417 = phi i64 [ %430, %416 ], [ 0, %413 ]
%418 = phi i64 [ %431, %416 ], [ 0, %413 ]
%419 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %417
%420 = bitcast double* %419 to <2 x double>*
%421 = load <2 x double>, <2 x double>* %420
%422 = fdiv <2 x double> %421, %415
%423 = bitcast double* %419 to <2 x double>*
store <2 x double> %422, <2 x double>* %423
%424 = or i64 %417, 2
%425 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %424
%426 = bitcast double* %425 to <2 x double>*
%427 = load <2 x double>, <2 x double>* %426
%428 = fdiv <2 x double> %427, %415
%429 = bitcast double* %425 to <2 x double>*
store <2 x double> %428, <2 x double>* %429
%430 = add nuw i64 %417, 4
%431 = add nuw i64 %418, 2
%432 = icmp eq i64 %431, %70
br i1 %432, label %433, label %416
433: ; preds = %416, %413
%434 = phi i64 [ 0, %413 ], [ %430, %416 ]
br i1 %71, label %441, label %435
435: ; preds = %433
%436 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %434
%437 = bitcast double* %436 to <2 x double>*
%438 = load <2 x double>, <2 x double>* %437
%439 = fdiv <2 x double> %438, %415
%440 = bitcast double* %436 to <2 x double>*
store <2 x double> %439, <2 x double>* %440
br label %441
441: ; preds = %433, %435
br i1 %72, label %451, label %442
442: ; preds = %410, %441
%443 = phi i64 [ 0, %410 ], [ %67, %441 ]
br label %444
444: ; preds = %442, %444
%445 = phi i64 [ %449, %444 ], [ %443, %442 ]
%446 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %445
%447 = load double, double* %446
%448 = fdiv double %447, %412
store double %448, double* %446
%449 = add nuw nsw i64 %445, 1
%450 = icmp eq i64 %449, %33
br i1 %450, label %451, label %444
451: ; preds = %444, %441
br i1 %29, label %452, label %530
452: ; preds = %451
%453 = add nsw i32 %319, -1
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %3, i64 %454
%456 = load i32, i32* %455
%457 = mul nsw i32 %456, 3
%458 = sext i32 %457 to i64
br i1 %73, label %528, label %459
459: ; preds = %452
br i1 %76, label %505, label %460
460: ; preds = %459, %460
%461 = phi i64 [ %502, %460 ], [ 0, %459 ]
%462 = phi i64 [ %503, %460 ], [ 0, %459 ]
%463 = add nsw i64 %461, %458
%464 = getelementptr inbounds double, double* %1, i64 %463
%465 = bitcast double* %464 to <2 x double>*
%466 = load <2 x double>, <2 x double>* %465
%467 = getelementptr inbounds double, double* %464, i64 2
%468 = bitcast double* %467 to <2 x double>*
%469 = load <2 x double>, <2 x double>* %468
%470 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %461
%471 = bitcast double* %470 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = getelementptr inbounds double, double* %470, i64 2
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = fsub <2 x double> %466, %472
%477 = fsub <2 x double> %469, %475
%478 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %461
%479 = bitcast double* %478 to <2 x double>*
store <2 x double> %476, <2 x double>* %479
%480 = getelementptr inbounds double, double* %478, i64 2
%481 = bitcast double* %480 to <2 x double>*
store <2 x double> %477, <2 x double>* %481
%482 = or i64 %461, 4
%483 = add nsw i64 %482, %458
%484 = getelementptr inbounds double, double* %1, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %482
%491 = bitcast double* %490 to <2 x double>*
%492 = load <2 x double>, <2 x double>* %491
%493 = getelementptr inbounds double, double* %490, i64 2
%494 = bitcast double* %493 to <2 x double>*
%495 = load <2 x double>, <2 x double>* %494
%496 = fsub <2 x double> %486, %492
%497 = fsub <2 x double> %489, %495
%498 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %482
%499 = bitcast double* %498 to <2 x double>*
store <2 x double> %496, <2 x double>* %499
%500 = getelementptr inbounds double, double* %498, i64 2
%501 = bitcast double* %500 to <2 x double>*
store <2 x double> %497, <2 x double>* %501
%502 = add nuw i64 %461, 8
%503 = add i64 %462, 2
%504 = icmp eq i64 %503, %77
br i1 %504, label %505, label %460
505: ; preds = %460, %459
%506 = phi i64 [ 0, %459 ], [ %502, %460 ]
br i1 %78, label %527, label %507
507: ; preds = %505
%508 = add nsw i64 %506, %458
%509 = getelementptr inbounds double, double* %1, i64 %508
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = getelementptr inbounds double, double* %509, i64 2
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %506
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = getelementptr inbounds double, double* %515, i64 2
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = fsub <2 x double> %511, %517
%522 = fsub <2 x double> %514, %520
%523 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %506
%524 = bitcast double* %523 to <2 x double>*
store <2 x double> %521, <2 x double>* %524
%525 = getelementptr inbounds double, double* %523, i64 2
%526 = bitcast double* %525 to <2 x double>*
store <2 x double> %522, <2 x double>* %526
br label %527
527: ; preds = %505, %507
br i1 %79, label %530, label %528
528: ; preds = %452, %527
%529 = phi i64 [ 0, %452 ], [ %74, %527 ]
br label %538
530: ; preds = %538, %527, %409, %451
br i1 %320, label %531, label %858
531: ; preds = %530
%532 = mul nsw i32 %312, 3
%533 = shl nsw i32 %312, 1
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds i32, i32* %4, i64 %534
%536 = sext i32 %532 to i64
%537 = sext i32 %315 to i64
br label %549
538: ; preds = %528, %538
%539 = phi i64 [ %547, %538 ], [ %529, %528 ]
%540 = add nsw i64 %539, %458
%541 = getelementptr inbounds double, double* %1, i64 %540
%542 = load double, double* %541
%543 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %539
%544 = load double, double* %543
%545 = fsub double %542, %544
%546 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %539
store double %545, double* %546
%547 = add nuw nsw i64 %539, 1
%548 = icmp eq i64 %547, %33
br i1 %548, label %530, label %538
549: ; preds = %531, %851
%550 = phi i64 [ %537, %531 ], [ %852, %851 ]
%551 = phi double [ %308, %531 ], [ %749, %851 ]
br i1 %29, label %554, label %552
552: ; preds = %549
%553 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @cross to i32 (double*, double*, double*, ...)*)(double* %30, double* %31, double* %32)
br label %738
554: ; preds = %549
%555 = getelementptr inbounds i32, i32* %3, i64 %550
%556 = load i32, i32* %555
%557 = mul nsw i32 %556, 3
%558 = sext i32 %557 to i64
br i1 %80, label %628, label %559
559: ; preds = %554
br i1 %83, label %605, label %560
560: ; preds = %559, %560
%561 = phi i64 [ %602, %560 ], [ 0, %559 ]
%562 = phi i64 [ %603, %560 ], [ 0, %559 ]
%563 = add nsw i64 %561, %558
%564 = getelementptr inbounds double, double* %1, i64 %563
%565 = bitcast double* %564 to <2 x double>*
%566 = load <2 x double>, <2 x double>* %565
%567 = getelementptr inbounds double, double* %564, i64 2
%568 = bitcast double* %567 to <2 x double>*
%569 = load <2 x double>, <2 x double>* %568
%570 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %561
%571 = bitcast double* %570 to <2 x double>*
%572 = load <2 x double>, <2 x double>* %571
%573 = getelementptr inbounds double, double* %570, i64 2
%574 = bitcast double* %573 to <2 x double>*
%575 = load <2 x double>, <2 x double>* %574
%576 = fsub <2 x double> %566, %572
%577 = fsub <2 x double> %569, %575
%578 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %561
%579 = bitcast double* %578 to <2 x double>*
store <2 x double> %576, <2 x double>* %579
%580 = getelementptr inbounds double, double* %578, i64 2
%581 = bitcast double* %580 to <2 x double>*
store <2 x double> %577, <2 x double>* %581
%582 = or i64 %561, 4
%583 = add nsw i64 %582, %558
%584 = getelementptr inbounds double, double* %1, i64 %583
%585 = bitcast double* %584 to <2 x double>*
%586 = load <2 x double>, <2 x double>* %585
%587 = getelementptr inbounds double, double* %584, i64 2
%588 = bitcast double* %587 to <2 x double>*
%589 = load <2 x double>, <2 x double>* %588
%590 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %582
%591 = bitcast double* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = getelementptr inbounds double, double* %590, i64 2
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = fsub <2 x double> %586, %592
%597 = fsub <2 x double> %589, %595
%598 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %582
%599 = bitcast double* %598 to <2 x double>*
store <2 x double> %596, <2 x double>* %599
%600 = getelementptr inbounds double, double* %598, i64 2
%601 = bitcast double* %600 to <2 x double>*
store <2 x double> %597, <2 x double>* %601
%602 = add nuw i64 %561, 8
%603 = add i64 %562, 2
%604 = icmp eq i64 %603, %84
br i1 %604, label %605, label %560
605: ; preds = %560, %559
%606 = phi i64 [ 0, %559 ], [ %602, %560 ]
br i1 %85, label %627, label %607
607: ; preds = %605
%608 = add nsw i64 %606, %558
%609 = getelementptr inbounds double, double* %1, i64 %608
%610 = bitcast double* %609 to <2 x double>*
%611 = load <2 x double>, <2 x double>* %610
%612 = getelementptr inbounds double, double* %609, i64 2
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %606
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = getelementptr inbounds double, double* %615, i64 2
%619 = bitcast double* %618 to <2 x double>*
%620 = load <2 x double>, <2 x double>* %619
%621 = fsub <2 x double> %611, %617
%622 = fsub <2 x double> %614, %620
%623 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %606
%624 = bitcast double* %623 to <2 x double>*
store <2 x double> %621, <2 x double>* %624
%625 = getelementptr inbounds double, double* %623, i64 2
%626 = bitcast double* %625 to <2 x double>*
store <2 x double> %622, <2 x double>* %626
br label %627
627: ; preds = %605, %607
br i1 %86, label %641, label %628
628: ; preds = %554, %627
%629 = phi i64 [ 0, %554 ], [ %81, %627 ]
br label %630
630: ; preds = %628, %630
%631 = phi i64 [ %639, %630 ], [ %629, %628 ]
%632 = add nsw i64 %631, %558
%633 = getelementptr inbounds double, double* %1, i64 %632
%634 = load double, double* %633
%635 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %631
%636 = load double, double* %635
%637 = fsub double %634, %636
%638 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %631
store double %637, double* %638
%639 = add nuw nsw i64 %631, 1
%640 = icmp eq i64 %639, %33
br i1 %640, label %641, label %630
641: ; preds = %630, %627
%642 = call i32 (double*, double*, double*, ...) bitcast (i32 (...)* @cross to i32 (double*, double*, double*, ...)*)(double* %30, double* %31, double* %32)
br i1 %29, label %643, label %738
643: ; preds = %641
br i1 %88, label %644, label %661
644: ; preds = %661, %643
%645 = phi double [ undef, %643 ], [ %683, %661 ]
%646 = phi i64 [ 0, %643 ], [ %684, %661 ]
%647 = phi double [ 0.000000e+00, %643 ], [ %683, %661 ]
br i1 %90, label %658, label %648
648: ; preds = %644
%649 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %646
%650 = load double, double* %649
%651 = fmul double %650, 0x3FC5555555555555
%652 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %646
%653 = load double, double* %652
%654 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %646
%655 = load double, double* %654
%656 = fsub double %653, %655
%657 = call double @llvm.fmuladd.f64(double %651, double %656, double %647)
br label %658
658: ; preds = %644, %648
%659 = phi double [ %645, %644 ], [ %657, %648 ]
br i1 %29, label %660, label %738
660: ; preds = %658
br i1 %92, label %721, label %687
661: ; preds = %643, %661
%662 = phi i64 [ %684, %661 ], [ 0, %643 ]
%663 = phi double [ %683, %661 ], [ 0.000000e+00, %643 ]
%664 = phi i64 [ %685, %661 ], [ 0, %643 ]
%665 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %662
%666 = load double, double* %665
%667 = fmul double %666, 0x3FC5555555555555
%668 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %662
%669 = load double, double* %668
%670 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %662
%671 = load double, double* %670
%672 = fsub double %669, %671
%673 = call double @llvm.fmuladd.f64(double %667, double %672, double %663)
%674 = or i64 %662, 1
%675 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %674
%676 = load double, double* %675
%677 = fmul double %676, 0x3FC5555555555555
%678 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %674
%679 = load double, double* %678
%680 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %674
%681 = load double, double* %680
%682 = fsub double %679, %681
%683 = call double @llvm.fmuladd.f64(double %677, double %682, double %673)
%684 = add nuw nsw i64 %662, 2
%685 = add i64 %664, 2
%686 = icmp eq i64 %685, %89
br i1 %686, label %644, label %661
687: ; preds = %660, %687
%688 = phi i64 [ %718, %687 ], [ 0, %660 ]
%689 = phi double [ %717, %687 ], [ 0.000000e+00, %660 ]
%690 = phi i64 [ %719, %687 ], [ 0, %660 ]
%691 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %688
%692 = load double, double* %691
%693 = add nsw i64 %688, %536
%694 = getelementptr inbounds double, double* %5, i64 %693
%695 = load double, double* %694
%696 = call double @llvm.fmuladd.f64(double %692, double %695, double %689)
%697 = or i64 %688, 1
%698 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %697
%699 = load double, double* %698
%700 = add nsw i64 %697, %536
%701 = getelementptr inbounds double, double* %5, i64 %700
%702 = load double, double* %701
%703 = call double @llvm.fmuladd.f64(double %699, double %702, double %696)
%704 = or i64 %688, 2
%705 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %704
%706 = load double, double* %705
%707 = add nsw i64 %704, %536
%708 = getelementptr inbounds double, double* %5, i64 %707
%709 = load double, double* %708
%710 = call double @llvm.fmuladd.f64(double %706, double %709, double %703)
%711 = or i64 %688, 3
%712 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %711
%713 = load double, double* %712
%714 = add nsw i64 %711, %536
%715 = getelementptr inbounds double, double* %5, i64 %714
%716 = load double, double* %715
%717 = call double @llvm.fmuladd.f64(double %713, double %716, double %710)
%718 = add nuw nsw i64 %688, 4
%719 = add i64 %690, 4
%720 = icmp eq i64 %719, %93
br i1 %720, label %721, label %687
721: ; preds = %687, %660
%722 = phi double [ undef, %660 ], [ %717, %687 ]
%723 = phi i64 [ 0, %660 ], [ %718, %687 ]
%724 = phi double [ 0.000000e+00, %660 ], [ %717, %687 ]
br i1 %94, label %738, label %725
725: ; preds = %721, %725
%726 = phi i64 [ %735, %725 ], [ %723, %721 ]
%727 = phi double [ %734, %725 ], [ %724, %721 ]
%728 = phi i64 [ %736, %725 ], [ 0, %721 ]
%729 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %726
%730 = load double, double* %729
%731 = add nsw i64 %726, %536
%732 = getelementptr inbounds double, double* %5, i64 %731
%733 = load double, double* %732
%734 = call double @llvm.fmuladd.f64(double %730, double %733, double %727)
%735 = add nuw nsw i64 %726, 1
%736 = add i64 %728, 1
%737 = icmp eq i64 %736, %91
br i1 %737, label %738, label %725
738: ; preds = %721, %725, %641, %552, %658
%739 = phi double [ %659, %658 ], [ 0.000000e+00, %552 ], [ 0.000000e+00, %641 ], [ %659, %725 ], [ %659, %721 ]
%740 = phi double [ 0.000000e+00, %658 ], [ 0.000000e+00, %552 ], [ 0.000000e+00, %641 ], [ %722, %721 ], [ %734, %725 ]
%741 = fcmp olt double %740, 0.000000e+00
%742 = fneg double %739
%743 = select i1 %741, double %742, double %739
%744 = load i32, i32* %535
%745 = zext i32 %744 to i64
%746 = icmp eq i64 %109, %745
%747 = fneg double %743
%748 = select i1 %746, double %743, double %747
%749 = fadd double %551, %748
br i1 %29, label %750, label %851
750: ; preds = %738
br i1 %95, label %782, label %751
751: ; preds = %750, %751
%752 = phi i64 [ %779, %751 ], [ 0, %750 ]
%753 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %752
%754 = bitcast double* %753 to <2 x double>*
%755 = load <2 x double>, <2 x double>* %754
%756 = getelementptr inbounds double, double* %753, i64 2
%757 = bitcast double* %756 to <2 x double>*
%758 = load <2 x double>, <2 x double>* %757
%759 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %752
%760 = bitcast double* %759 to <2 x double>*
%761 = load <2 x double>, <2 x double>* %760
%762 = getelementptr inbounds double, double* %759, i64 2
%763 = bitcast double* %762 to <2 x double>*
%764 = load <2 x double>, <2 x double>* %763
%765 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %752
%766 = bitcast double* %765 to <2 x double>*
%767 = load <2 x double>, <2 x double>* %766
%768 = getelementptr inbounds double, double* %765, i64 2
%769 = bitcast double* %768 to <2 x double>*
%770 = load <2 x double>, <2 x double>* %769
%771 = fadd <2 x double> %761, %767
%772 = fadd <2 x double> %764, %770
%773 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %771, <2 x double> <double 0x3FD5555555555555, double 0x3FD5555555555555>, <2 x double> %755)
%774 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %772, <2 x double> <double 0x3FD5555555555555, double 0x3FD5555555555555>, <2 x double> %758)
%775 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 %752
%776 = bitcast double* %775 to <2 x double>*
store <2 x double> %773, <2 x double>* %776
%777 = getelementptr inbounds double, double* %775, i64 2
%778 = bitcast double* %777 to <2 x double>*
store <2 x double> %774, <2 x double>* %778
%779 = add nuw i64 %752, 4
%780 = icmp eq i64 %779, %96
br i1 %780, label %781, label %751
781: ; preds = %751
br i1 %97, label %784, label %782
782: ; preds = %750, %781
%783 = phi i64 [ 0, %750 ], [ %96, %781 ]
br label %824
784: ; preds = %824, %781
br i1 %29, label %785, label %851
785: ; preds = %784
%786 = fmul double %748, 3.000000e+00
%787 = fmul double %786, 2.500000e-01
br i1 %98, label %822, label %788
788: ; preds = %785
%789 = insertelement <2 x double> poison, double %787, i64 0
%790 = shufflevector <2 x double> %789, <2 x double> poison, <2 x i32> zeroinitializer
%791 = insertelement <2 x double> poison, double %787, i64 0
%792 = shufflevector <2 x double> %791, <2 x double> poison, <2 x i32> zeroinitializer
br label %793
793: ; preds = %793, %788
%794 = phi i64 [ 0, %788 ], [ %819, %793 ]
%795 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 %794
%796 = bitcast double* %795 to <2 x double>*
%797 = load <2 x double>, <2 x double>* %796
%798 = getelementptr inbounds double, double* %795, i64 2
%799 = bitcast double* %798 to <2 x double>*
%800 = load <2 x double>, <2 x double>* %799
%801 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %794
%802 = bitcast double* %801 to <2 x double>*
%803 = load <2 x double>, <2 x double>* %802
%804 = getelementptr inbounds double, double* %801, i64 2
%805 = bitcast double* %804 to <2 x double>*
%806 = load <2 x double>, <2 x double>* %805
%807 = fsub <2 x double> %797, %803
%808 = fsub <2 x double> %800, %806
%809 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %794
%810 = bitcast double* %809 to <2 x double>*
%811 = load <2 x double>, <2 x double>* %810
%812 = getelementptr inbounds double, double* %809, i64 2
%813 = bitcast double* %812 to <2 x double>*
%814 = load <2 x double>, <2 x double>* %813
%815 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %790, <2 x double> %807, <2 x double> %811)
%816 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %792, <2 x double> %808, <2 x double> %814)
%817 = bitcast double* %809 to <2 x double>*
store <2 x double> %815, <2 x double>* %817
%818 = bitcast double* %812 to <2 x double>*
store <2 x double> %816, <2 x double>* %818
%819 = add nuw i64 %794, 4
%820 = icmp eq i64 %819, %99
br i1 %820, label %821, label %793
821: ; preds = %793
br i1 %100, label %837, label %822
822: ; preds = %785, %821
%823 = phi i64 [ 0, %785 ], [ %99, %821 ]
br label %839
824: ; preds = %782, %824
%825 = phi i64 [ %835, %824 ], [ %783, %782 ]
%826 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %825
%827 = load double, double* %826
%828 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %825
%829 = load double, double* %828
%830 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %825
%831 = load double, double* %830
%832 = fadd double %829, %831
%833 = call double @llvm.fmuladd.f64(double %832, double 0x3FD5555555555555, double %827)
%834 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 %825
store double %833, double* %834
%835 = add nuw nsw i64 %825, 1
%836 = icmp eq i64 %835, %33
br i1 %836, label %784, label %824
837: ; preds = %839, %821
br i1 %29, label %838, label %851
838: ; preds = %837
br label %851
839: ; preds = %822, %839
%840 = phi i64 [ %849, %839 ], [ %823, %822 ]
%841 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 %840
%842 = load double, double* %841
%843 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %840
%844 = load double, double* %843
%845 = fsub double %842, %844
%846 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %840
%847 = load double, double* %846
%848 = call double @llvm.fmuladd.f64(double %787, double %845, double %847)
store double %848, double* %846
%849 = add nuw nsw i64 %840, 1
%850 = icmp eq i64 %849, %33
br i1 %850, label %837, label %839
851: ; preds = %738, %784, %838, %837
%852 = add nsw i64 %550, 1
%853 = load i32, i32* %318
%854 = sext i32 %853 to i64
%855 = icmp slt i64 %852, %854
br i1 %855, label %549, label %856
856: ; preds = %851
%857 = load i32, i32* %115
br label %858
858: ; preds = %856, %530
%859 = phi i32 [ %306, %530 ], [ %857, %856 ]
%860 = phi double [ %308, %530 ], [ %749, %856 ]
%861 = add nsw i64 %307, 1
%862 = sext i32 %859 to i64
%863 = icmp slt i64 %861, %862
br i1 %863, label %305, label %251
864: ; preds = %303, %864
%865 = phi i64 [ %874, %864 ], [ %304, %303 ]
%866 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %865
%867 = load double, double* %866
%868 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %865
%869 = load double, double* %868
%870 = fdiv double %869, %252
%871 = fadd double %867, %870
%872 = add nuw nsw i64 %865, %255
%873 = getelementptr inbounds double, double* %10, i64 %872
store double %871, double* %873
%874 = add nuw nsw i64 %865, 1
%875 = icmp eq i64 %874, %33
br i1 %875, label %876, label %864
876: ; preds = %864, %302, %251
%877 = getelementptr inbounds double, double* %11, i64 %109
store double %252, double* %877
%878 = icmp eq i64 %114, %35
br i1 %878, label %879, label %108
879: ; preds = %876, %12
ret void
}