#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ cross(double *, double *, double *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, int);
int log(double);
int /*<<< orphan*/ stderr;
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};
  const double twothirds = 0.666666666666666666666666666667;
  int ndigits;
  ndigits = ((int)(log(ncells) / log(10.0))) + 1;
  for (c = 0; c < ncells; ++c) {
    int num_faces;
    double volume = 0.0;
    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;
    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) {
        double tet_volume, subnormal_sign;
        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 += w[i] * (x[i] - xcell[i]);
        }
        tet_volume *= 0.5 / 3;
        subnormal_sign = 0.0;
        for (i = 0; i < ndims; ++i) {
          subnormal_sign += w[i] * fnormals[3 * face + i];
        }
        if (subnormal_sign < 0.0) {
          tet_volume = -tet_volume;
        }
        if (neighbors[2 * face + 0] != c) {
          tet_volume = -tet_volume;
        }
        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];
      }
    }
    if (!(volume > 0.0)) {
      fprintf(stderr,
              "Internal error in mex_compute_geometry(%*d): "
              "negative volume\n",
              ndigits, c);
    }
    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    $0x160,%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  0xe74(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
cvtsi2sdl 0x18(%rbp),%xmm0
call   1050 <log@plt>
mov    %eax,-0x154(%rbp)
movsd  0xe4c(%rip),%xmm0
call   1050 <log@plt>
mov    %eax,%ecx
mov    -0x154(%rbp),%eax
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1919 <compute_cell_geometry+0x7d9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    121c <compute_cell_geometry+0xdc>
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    11f2 <compute_cell_geometry+0xb2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    124d <compute_cell_geometry+0x10d>
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    1223 <compute_cell_geometry+0xe3>
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    12df <compute_cell_geometry+0x19f>
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    12cc <compute_cell_geometry+0x18c>
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    1289 <compute_cell_geometry+0x149>
jmp    12d1 <compute_cell_geometry+0x191>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    125b <compute_cell_geometry+0x11b>
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,-0x130(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1343 <compute_cell_geometry+0x203>
cvtsi2sdl -0x130(%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    1307 <compute_cell_geometry+0x1c7>
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    1869 <compute_cell_geometry+0x729>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1398 <compute_cell_geometry+0x258>
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    1371 <compute_cell_geometry+0x231>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13c9 <compute_cell_geometry+0x289>
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    139f <compute_cell_geometry+0x25f>
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    1463 <compute_cell_geometry+0x323>
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    1450 <compute_cell_geometry+0x310>
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    1413 <compute_cell_geometry+0x2d3>
jmp    1455 <compute_cell_geometry+0x315>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13e5 <compute_cell_geometry+0x2a5>
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,-0x13c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14c1 <compute_cell_geometry+0x381>
cvtsi2sdl -0x13c(%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    148b <compute_cell_geometry+0x34b>
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    1529 <compute_cell_geometry+0x3e9>
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    14e8 <compute_cell_geometry+0x3a8>
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    1856 <compute_cell_geometry+0x716>
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    15a9 <compute_cell_geometry+0x469>
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    1565 <compute_cell_geometry+0x425>
lea    -0x80(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
call   1060 <cross@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1628 <compute_cell_geometry+0x4e8>
movslq -0x34(%rbp),%rax
movsd  -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
movsd  -0x148(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15d2 <compute_cell_geometry+0x492>
movsd  0x9e0(%rip),%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16a4 <compute_cell_geometry+0x564>
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  -0x150(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1652 <compute_cell_geometry+0x512>
xorps  %xmm0,%xmm0
ucomisd -0x150(%rbp),%xmm0
ff
jbe    16dc <compute_cell_geometry+0x59c>
movsd  -0x148(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x148(%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     171f <compute_cell_geometry+0x5df>
movsd  -0x148(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1796 <compute_cell_geometry+0x656>
movslq -0x34(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
movslq -0x34(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x34(%rbp),%rax
addsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movsd  0x8b5(%rip),%xmm2
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    173e <compute_cell_geometry+0x5fe>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    180b <compute_cell_geometry+0x6cb>
movsd  0x86f(%rip),%xmm0
mulsd  -0x148(%rbp),%xmm0
ff
movsd  0x857(%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    179d <compute_cell_geometry+0x65d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1843 <compute_cell_geometry+0x703>
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    1812 <compute_cell_geometry+0x6d2>
jmp    1848 <compute_cell_geometry+0x708>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1537 <compute_cell_geometry+0x3f7>
jmp    185b <compute_cell_geometry+0x71b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1351 <compute_cell_geometry+0x211>
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     189c <compute_cell_geometry+0x75c>
mov    0x275b(%rip),%rax
mov    (%rax),%edi
mov    -0x12c(%rbp),%edx
mov    -0x40(%rbp),%ecx
lea    0x799(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    18f6 <compute_cell_geometry+0x7b6>
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  -0x138(%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    18a3 <compute_cell_geometry+0x763>
movsd  -0x138(%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    11d4 <compute_cell_geometry+0x94>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_cell_geometry>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
mov    %r9,0x160(%rsp)
mov    %r8,0x1b0(%rsp)
mov    %rcx,0xd8(%rsp)
mov    %rdx,0x178(%rsp)
mov    %rsi,0x40(%rsp)
mov    %edi,%ebp
mov    0x218(%rsp),%ebx
xorps  %xmm0,%xmm0
movaps %xmm0,0x130(%rsp)
movq   $0x0,0x140(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
call   1060 <log@plt>
mov    %eax,%r14d
movsd  0x1e43(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%ecx
mov    %r14d,%eax
cltd
idiv   %ecx
mov    %eax,0x54(%rsp)
test   %ebx,%ebx
jle    20ad <compute_cell_geometry+0xf5d>
mov    0x230(%rsp),%rcx
addl   $0x1,0x54(%rsp)
mov    %ebp,%r15d
lea    0x0(,%r15,8),%rax
mov    %ebx,%edx
mov    %rdx,0x190(%rsp)
mov    %r15d,%r9d
and    $0xfffffffc,%r9d
lea    -0x4(%r9),%rdx
mov    %rdx,0x68(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %r15d,%r12d
and    $0xfffffffe,%r12d
lea    -0x2(%r12),%rdx
mov    %rdx,0xc0(%rsp)
mov    %rdx,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %rsi,%rdx
mov    %rsi,0x60(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x58(%rsp)
mov    %rdi,%rdx
mov    %rdi,0xb8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xb0(%rsp)
mov    %r15d,%edx
and    $0x3,%edx
mov    %rdx,0x168(%rsp)
mov    %rax,0xc8(%rsp)
mov    %rax,%rbx
and    $0xffffffffffffffe0,%rbx
mov    0x210(%rsp),%rax
lea    -0x1(%r15),%rdx
mov    %rdx,0x170(%rsp)
add    $0x30,%rax
mov    %rax,0x198(%rsp)
mov    0x40(%rsp),%rax
add    $0x30,%rax
mov    %rax,0xd0(%rsp)
mov    0x160(%rsp),%rax
add    $0x18,%rax
mov    %rax,0x1a0(%rsp)
lea    0x10(%rcx),%rax
mov    %rax,0x188(%rsp)
xor    %eax,%eax
mov    %rax,0xa8(%rsp)
xor    %eax,%eax
mov    %r9,0x38(%rsp)
mov    %ebp,0x1c(%rsp)
jmp    131b <compute_cell_geometry+0x1cb>
xchg   %ax,%ax
mov    0x238(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  %xmm4,(%rax,%rcx,8)
mov    0xa8(%rsp),%rax
add    $0x3,%eax
mov    %rax,0xa8(%rsp)
mov    0x150(%rsp),%rax
cmp    0x190(%rsp),%rax
je     20ad <compute_cell_geometry+0xf5d>
mov    %rax,0x48(%rsp)
test   %ebp,%ebp
jle    1356 <compute_cell_geometry+0x206>
lea    0x20(%rsp),%rdi
xor    %esi,%esi
mov    0xc8(%rsp),%r14
mov    %r14,%rdx
call   1030 <memset@plt>
lea    0xe0(%rsp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x1c(%rsp),%ebp
mov    0x38(%rsp),%r9
mov    0x220(%rsp),%rax
mov    0x48(%rsp),%rcx
movslq (%rax,%rcx,4),%r13
mov    0x4(%rax,%rcx,4),%r10d
cmp    %r13d,%r10d
jle    14a0 <compute_cell_geometry+0x350>
movslq %r10d,%r8
mov    %r13,%rcx
jmp    138d <compute_cell_geometry+0x23d>
nopl   (%rax)
add    $0x1,%rcx
cmp    %r8,%rcx
je     14a0 <compute_cell_geometry+0x350>
test   %ebp,%ebp
jle    1380 <compute_cell_geometry+0x230>
mov    0x228(%rsp),%rax
movslq (%rax,%rcx,4),%rax
lea    (%rax,%rax,2),%rdx
cmp    $0x4,%ebp
jae    13b0 <compute_cell_geometry+0x260>
xor    %eax,%eax
jmp    1463 <compute_cell_geometry+0x313>
nopl   (%rax)
cmpq   $0x0,0x68(%rsp)
je     148f <compute_cell_geometry+0x33f>
mov    0x198(%rsp),%rax
lea    (%rax,%rdx,8),%rdi
mov    0x58(%rsp),%rax
xor    %esi,%esi
nop
movupd -0x30(%rdi,%rsi,8),%xmm0
movupd -0x20(%rdi,%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(%rdi,%rsi,8),%xmm0
movupd (%rdi,%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    13d0 <compute_cell_geometry+0x280>
testb  $0x1,0x60(%rsp)
je     1457 <compute_cell_geometry+0x307>
lea    (%rsi,%rdx,1),%rax
mov    0x210(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%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    %r9,%rax
cmp    %r15,%r9
je     1380 <compute_cell_geometry+0x230>
mov    0x210(%rsp),%rsi
lea    (%rsi,%rdx,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,%r15
jne    1470 <compute_cell_geometry+0x320>
jmp    1380 <compute_cell_geometry+0x230>
xor    %esi,%esi
testb  $0x1,0x60(%rsp)
jne    1428 <compute_cell_geometry+0x2d8>
jmp    1457 <compute_cell_geometry+0x307>
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
jle    1569 <compute_cell_geometry+0x419>
mov    %r10d,%eax
sub    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    $0x1,%ebp
jne    14d0 <compute_cell_geometry+0x380>
xor    %eax,%eax
jmp    1550 <compute_cell_geometry+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xc0(%rsp)
je     2086 <compute_cell_geometry+0xf36>
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    1500 <compute_cell_geometry+0x3b0>
testb  $0x1,0xb8(%rsp)
01
je     1544 <compute_cell_geometry+0x3f4>
movapd 0x20(%rsp,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,0x20(%rsp,%rax,8)
mov    %r12,%rax
cmp    %r15,%r12
je     1569 <compute_cell_geometry+0x419>
nopl   0x0(%rax)
movsd  0x20(%rsp,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1550 <compute_cell_geometry+0x400>
mov    0x48(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x150(%rsp)
xorpd  %xmm4,%xmm4
cmp    %r13d,%r10d
jle    1f4a <compute_cell_geometry+0xdfa>
xorpd  %xmm4,%xmm4
jmp    15bc <compute_cell_geometry+0x46c>
nopl   (%rax)
mov    0x220(%rsp),%rax
mov    0x150(%rsp),%rcx
mov    (%rax,%rcx,4),%r10d
mov    0x158(%rsp),%r13
add    $0x1,%r13
movslq %r10d,%rax
cmp    %rax,%r13
jge    1f40 <compute_cell_geometry+0xdf0>
test   %ebp,%ebp
jle    1608 <compute_cell_geometry+0x4b8>
mov    %rsp,%rdi
xor    %esi,%esi
mov    0xc8(%rsp),%r14
mov    %r14,%rdx
movapd %xmm4,0x120(%rsp)
mov    %r10d,%ebp
call   1030 <memset@plt>
lea    0x130(%rsp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    %ebp,%r10d
movapd 0x120(%rsp),%xmm4
mov    0x1c(%rsp),%ebp
mov    0x38(%rsp),%r9
mov    0x228(%rsp),%rax
mov    %r13,0x158(%rsp)
movslq (%rax,%r13,4),%rcx
mov    0x178(%rsp),%rax
movslq (%rax,%rcx,4),%r13
mov    %rcx,0x180(%rsp)
movslq 0x4(%rax,%rcx,4),%r8
cmp    %r13d,%r8d
jle    1770 <compute_cell_geometry+0x620>
mov    %r13,%rcx
jmp    165d <compute_cell_geometry+0x50d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
cmp    %r8,%rcx
je     1770 <compute_cell_geometry+0x620>
test   %ebp,%ebp
jle    1650 <compute_cell_geometry+0x500>
mov    0xd8(%rsp),%rax
movslq (%rax,%rcx,4),%rax
lea    (%rax,%rax,2),%rdx
cmp    $0x4,%ebp
jae    1680 <compute_cell_geometry+0x530>
xor    %eax,%eax
jmp    172c <compute_cell_geometry+0x5dc>
nopl   (%rax)
cmpq   $0x0,0x68(%rsp)
je     175d <compute_cell_geometry+0x60d>
mov    0xd0(%rsp),%rax
lea    (%rax,%rdx,8),%rdi
mov    0x58(%rsp),%rax
xor    %esi,%esi
nop
movupd -0x30(%rdi,%rsi,8),%xmm0
movupd -0x20(%rdi,%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(%rdi,%rsi,8),%xmm0
movupd (%rdi,%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    16a0 <compute_cell_geometry+0x550>
testb  $0x1,0x60(%rsp)
je     1720 <compute_cell_geometry+0x5d0>
lea    (%rsi,%rdx,1),%rax
mov    0x40(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%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    %r9,%rax
cmp    %r15,%r9
je     1650 <compute_cell_geometry+0x500>
mov    0x40(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rax,8),%xmm0
addsd  (%rsp,%rax,8),%xmm0
movsd  %xmm0,(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1740 <compute_cell_geometry+0x5f0>
jmp    1650 <compute_cell_geometry+0x500>
xor    %esi,%esi
testb  $0x1,0x60(%rsp)
jne    16f6 <compute_cell_geometry+0x5a6>
jmp    1720 <compute_cell_geometry+0x5d0>
nopl   0x0(%rax,%rax,1)
test   %ebp,%ebp
jle    194c <compute_cell_geometry+0x7fc>
mov    %r8d,%eax
sub    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
cmp    $0x1,%ebp
jne    17a0 <compute_cell_geometry+0x650>
xor    %eax,%eax
jmp    1820 <compute_cell_geometry+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xc0(%rsp)
je     1f12 <compute_cell_geometry+0xdc2>
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    17d0 <compute_cell_geometry+0x680>
testb  $0x1,0xb8(%rsp)
01
je     1810 <compute_cell_geometry+0x6c0>
movapd (%rsp,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,(%rsp,%rcx,8)
mov    %r12,%rax
cmp    %r15,%r12
je     1837 <compute_cell_geometry+0x6e7>
nopl   0x0(%rax,%rax,1)
movsd  (%rsp,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1820 <compute_cell_geometry+0x6d0>
test   %ebp,%ebp
jle    194c <compute_cell_geometry+0x7fc>
mov    0xd8(%rsp),%rax
movslq -0x4(%rax,%r8,4),%rax
lea    (%rax,%rax,2),%rcx
cmp    $0x4,%ebp
jae    185c <compute_cell_geometry+0x70c>
xor    %eax,%eax
jmp    191c <compute_cell_geometry+0x7cc>
cmpq   $0x0,0x68(%rsp)
je     1f27 <compute_cell_geometry+0xdd7>
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    1880 <compute_cell_geometry+0x730>
testb  $0x1,0x60(%rsp)
je     1914 <compute_cell_geometry+0x7c4>
lea    (%rdx,%rcx,1),%rax
mov    0x40(%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    %r9,%rax
cmp    %r15,%r9
je     194c <compute_cell_geometry+0x7fc>
mov    0x40(%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,%r15
jne    1930 <compute_cell_geometry+0x7e0>
cmp    %r13d,%r8d
jle    15a4 <compute_cell_geometry+0x454>
mov    0x180(%rsp),%rcx
lea    (%rcx,%rcx,2),%eax
add    %rcx,%rcx
mov    %rcx,0x1b8(%rsp)
movslq %eax,%rcx
mov    0x1a0(%rsp),%rax
mov    %rcx,0x1a8(%rsp)
lea    (%rax,%rcx,8),%r14
jmp    19bf <compute_cell_geometry+0x86f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x120(%rsp),%xmm4
addsd  %xmm7,%xmm4
add    $0x1,%r13
mov    0x178(%rsp),%rax
mov    0x180(%rsp),%rcx
movslq 0x4(%rax,%rcx,4),%rax
cmp    %rax,%r13
jge    1590 <compute_cell_geometry+0x440>
test   %ebp,%ebp
movapd %xmm4,0x120(%rsp)
jle    19f0 <compute_cell_geometry+0x8a0>
mov    0xd8(%rsp),%rax
movslq (%rax,%r13,4),%rax
lea    (%rax,%rax,2),%rax
cmp    $0x4,%ebp
jae    1a40 <compute_cell_geometry+0x8f0>
xor    %ecx,%ecx
jmp    1af6 <compute_cell_geometry+0x9a6>
nopl   0x0(%rax,%rax,1)
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
lea    0x100(%rsp),%rdx
call   1070 <cross@plt>
movapd 0x162e(%rip),%xmm6
movsd  0x15f6(%rip),%xmm5
movapd 0x160e(%rip),%xmm4
mov    0x1c(%rsp),%ebp
mov    0x38(%rsp),%r9
xorpd  %xmm0,%xmm0
xorpd  %xmm7,%xmm7
jmp    1d20 <compute_cell_geometry+0xbd0>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x68(%rsp)
je     1f00 <compute_cell_geometry+0xdb0>
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    1a60 <compute_cell_geometry+0x910>
testb  $0x1,0x60(%rsp)
je     1aee <compute_cell_geometry+0x99e>
lea    (%rcx,%rax,1),%rdx
mov    0x40(%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    %r9,%rcx
cmp    %r15,%r9
je     1b19 <compute_cell_geometry+0x9c9>
mov    0x40(%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,%r15
jne    1b00 <compute_cell_geometry+0x9b0>
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
lea    0x100(%rsp),%rdx
call   1070 <cross@plt>
mov    0x1c(%rsp),%ebp
test   %ebp,%ebp
jle    1c00 <compute_cell_geometry+0xab0>
cmpq   $0x0,0x170(%rsp)
je     1c2a <compute_cell_geometry+0xada>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x38(%rsp),%r9
mov    0x168(%rsp),%rsi
movapd 0x14c7(%rip),%xmm4
movsd  0x149f(%rip),%xmm5
movapd 0x14c7(%rip),%xmm6
nopl   0x0(%rax)
movsd  (%rsp,%rax,8),%xmm2
movsd  0x8(%rsp,%rax,8),%xmm0
subsd  0x20(%rsp,%rax,8),%xmm2
mulsd  0x100(%rsp,%rax,8),%xmm2
subsd  0x28(%rsp,%rax,8),%xmm0
mulsd  0x108(%rsp,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%r12
jne    1b80 <compute_cell_geometry+0xa30>
test   $0x1,%r15b
je     1bdc <compute_cell_geometry+0xa8c>
movsd  (%rsp,%rax,8),%xmm1
subsd  0x20(%rsp,%rax,8),%xmm1
mulsd  0x100(%rsp,%rax,8),%xmm1
addsd  %xmm1,%xmm0
mulsd  0x1424(%rip),%xmm0
test   %ebp,%ebp
jle    1c64 <compute_cell_geometry+0xb14>
cmpq   $0x3,0x170(%rsp)
jae    1c6d <compute_cell_geometry+0xb1d>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
jmp    1cd8 <compute_cell_geometry+0xb88>
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xorpd  %xmm7,%xmm7
mov    0x38(%rsp),%r9
movapd 0x141b(%rip),%xmm4
movsd  0x13f3(%rip),%xmm5
movapd 0x141b(%rip),%xmm6
jmp    1d20 <compute_cell_geometry+0xbd0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x38(%rsp),%r9
mov    0x168(%rsp),%rsi
movapd 0x13eb(%rip),%xmm4
movsd  0x13c3(%rip),%xmm5
movapd 0x13eb(%rip),%xmm6
test   $0x1,%r15b
jne    1bc4 <compute_cell_geometry+0xa74>
jmp    1bdc <compute_cell_geometry+0xa8c>
xorpd  %xmm7,%xmm7
jmp    1d20 <compute_cell_geometry+0xbd0>
xorpd  %xmm7,%xmm7
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x100(%rsp,%rax,8),%xmm1
movsd  0x108(%rsp,%rax,8),%xmm2
mulsd  -0x18(%r14,%rax,8),%xmm1
mulsd  -0x10(%r14,%rax,8),%xmm2
addsd  %xmm7,%xmm1
movsd  0x110(%rsp,%rax,8),%xmm3
mulsd  -0x8(%r14,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x118(%rsp,%rax,8),%xmm7
mulsd  (%r14,%rax,8),%xmm7
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm7
add    $0x4,%rax
cmp    %rax,%r9
jne    1c80 <compute_cell_geometry+0xb30>
test   %rsi,%rsi
je     1d20 <compute_cell_geometry+0xbd0>
mov    0x1a8(%rsp),%rcx
add    %rax,%rcx
mov    0x160(%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    1d00 <compute_cell_geometry+0xbb0>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
xorpd  %xmm4,%xmm1
cmpltsd 0x12f7(%rip),%xmm7
andpd  %xmm7,%xmm1
andnpd %xmm0,%xmm7
orpd   %xmm1,%xmm7
mov    0x1b0(%rsp),%rax
mov    0x1b8(%rsp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    %rax,0x48(%rsp)
je     1d5b <compute_cell_geometry+0xc0b>
xorpd  %xmm4,%xmm7
test   %ebp,%ebp
jle    1990 <compute_cell_geometry+0x840>
xor    %eax,%eax
cmp    $0x4,%ebp
jb     1dd0 <compute_cell_geometry+0xc80>
nopw   0x0(%rax,%rax,1)
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,0x130(%rsp,%rax,1)
movapd %xmm1,0x140(%rsp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1d70 <compute_cell_geometry+0xc20>
mov    %r9,%rax
cmp    %r15,%r9
je     1dfa <compute_cell_geometry+0xcaa>
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,0x130(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1dd0 <compute_cell_geometry+0xc80>
test   %ebp,%ebp
jle    1990 <compute_cell_geometry+0x840>
movapd %xmm7,%xmm0
mulsd  0x120a(%rip),%xmm0
mulsd  0x120a(%rip),%xmm0
cmp    $0x4,%ebp
jae    1e1f <compute_cell_geometry+0xccf>
xor    %eax,%eax
jmp    1e90 <compute_cell_geometry+0xd40>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movapd 0x130(%rsp,%rax,1),%xmm2
movapd 0x140(%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    1e30 <compute_cell_geometry+0xce0>
mov    %r9,%rax
cmp    %r15,%r9
je     1ebe <compute_cell_geometry+0xd6e>
nopl   0x0(%rax,%rax,1)
movsd  0x130(%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,%r15
jne    1e90 <compute_cell_geometry+0xd40>
test   %ebp,%ebp
jle    1990 <compute_cell_geometry+0x840>
lea    0x90(%rsp),%rdi
lea    0x70(%rsp),%rsi
mov    0xc8(%rsp),%rdx
movapd %xmm7,0x1c0(%rsp)
call   1050 <memcpy@plt>
movapd 0x1c0(%rsp),%xmm7
mov    0x1c(%rsp),%ebp
mov    0x38(%rsp),%r9
jmp    1990 <compute_cell_geometry+0x840>
xor    %ecx,%ecx
testb  $0x1,0x60(%rsp)
jne    1ac0 <compute_cell_geometry+0x970>
jmp    1aee <compute_cell_geometry+0x99e>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
jne    1802 <compute_cell_geometry+0x6b2>
jmp    1810 <compute_cell_geometry+0x6c0>
xor    %edx,%edx
testb  $0x1,0x60(%rsp)
jne    18e3 <compute_cell_geometry+0x793>
jmp    1914 <compute_cell_geometry+0x7c4>
nopl   0x0(%rax)
ucomisd 0x10e0(%rip),%xmm4
ja     1f83 <compute_cell_geometry+0xe33>
movapd %xmm4,0x120(%rsp)
mov    0x3086(%rip),%rax
mov    (%rax),%edi
lea    0x10ed(%rip),%rsi
mov    0x54(%rsp),%edx
mov    0x48(%rsp),%rcx
call   1040 <fprintf@plt>
movapd 0x120(%rsp),%xmm4
mov    0x1c(%rsp),%ebp
mov    0x38(%rsp),%r9
test   %ebp,%ebp
jle    12e0 <compute_cell_geometry+0x190>
mov    0xa8(%rsp),%eax
cmp    $0x1,%ebp
jne    1fa0 <compute_cell_geometry+0xe50>
xor    %ecx,%ecx
jmp    204c <compute_cell_geometry+0xefc>
xchg   %ax,%ax
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmpq   $0x0,0xc0(%rsp)
je     209b <compute_cell_geometry+0xf4b>
mov    0x188(%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    1fd0 <compute_cell_geometry+0xe80>
testb  $0x1,0xb8(%rsp)
01
je     2040 <compute_cell_geometry+0xef0>
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    0x230(%rsp),%rcx
movupd %xmm1,(%rcx,%rdx,8)
mov    %r12,%rcx
cmp    %r15,%r12
je     12e0 <compute_cell_geometry+0x190>
mov    0x230(%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,%r15
jne    2060 <compute_cell_geometry+0xf10>
jmp    12e0 <compute_cell_geometry+0x190>
xor    %eax,%eax
testb  $0x1,0xb8(%rsp)
01
jne    1534 <compute_cell_geometry+0x3e4>
jmp    1544 <compute_cell_geometry+0x3f4>
xor    %ecx,%ecx
testb  $0x1,0xb8(%rsp)
01
jne    2015 <compute_cell_geometry+0xec5>
jmp    2040 <compute_cell_geometry+0xef0>
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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