#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 */
double dVxTetra3D(double *, double *, double *, double *, double *, double *,
                  double *, double *, double *);
void dJacx3D(double *result, const double *yc, const double *x, const double *m,
             const int n) {
  const int m1 = m[0], m2 = m[1], m3 = m[2];
  double yA[3], yB[3], yC[3], yD[3], yE[3], yF[3], yG[3], yH[3], yABDC[3],
      yBDHF[3], yABFE[3], yCAEG[3], yDCGH[3], yEFHG[3], yM[3];
  double xA[3], xB[3], xC[3], xD[3], xE[3], xF[3], xG[3], xH[3], xABDC[3],
      xBDHF[3], xABFE[3], xCAEG[3], xDCGH[3], xEFHG[3], xM[3];
  double cofDy[9];
  double res;
  int id, i1, i2, i3, r, comp, idn;
  const int nn = (m1 + 1) * (m2 + 1) * (m3 + 1);
  const int inc_x = 1;
  const int inc_y = m1 + 1;
  const int inc_z = (m1 + 1) * (m2 + 1);
  const double *rptr;
#pragma omp parallel for default(shared) private(                              \
    rptr, id, i1, i2, i3, r, comp, idn, res, cofDy, yA, yB, yC, yD, yE, yF,    \
    yG, yH, yABDC, yBDHF, yABFE, yCAEG, yDCGH, yEFHG, yM, xA, xB, xC, xD, xE,  \
    xF, xG, xH, xABDC, xBDHF, xABFE, xCAEG, xDCGH, xEFHG, xM)
  for (i1 = 0; i1 < m1; i1++) {
    for (i2 = 0; i2 < m2; i2++) {
      for (i3 = 0; i3 < m3; i3++) {
        idn = i1 + i2 * inc_y + i3 * inc_z;
        comp = 0;
        for (r = 0; r < 3; r++) {
          rptr = yc + idn + comp;
          yA[r] = *rptr;
          rptr += inc_x;
          yB[r] = *rptr;
          rptr += inc_y;
          yD[r] = *rptr;
          rptr -= inc_x;
          yC[r] = *rptr;
          rptr += inc_z;
          yG[r] = *rptr;
          rptr += inc_x;
          yH[r] = *rptr;
          rptr -= inc_y;
          yF[r] = *rptr;
          rptr -= inc_x;
          yE[r] = *rptr;
          yABDC[r] = 0.25 * (yA[r] + yB[r] + yD[r] + yC[r]);
          yBDHF[r] = 0.25 * (yB[r] + yD[r] + yH[r] + yF[r]);
          yABFE[r] = 0.25 * (yA[r] + yB[r] + yF[r] + yE[r]);
          yCAEG[r] = 0.25 * (yC[r] + yA[r] + yE[r] + yG[r]);
          yDCGH[r] = 0.25 * (yD[r] + yC[r] + yG[r] + yH[r]);
          yEFHG[r] = 0.25 * (yE[r] + yF[r] + yH[r] + yG[r]);
          yM[r] = 0.5 * (yABDC[r] + yEFHG[r]);
          rptr = x + idn + comp;
          xA[r] = *rptr;
          rptr += inc_x;
          xB[r] = *rptr;
          rptr += inc_y;
          xD[r] = *rptr;
          rptr -= inc_x;
          xC[r] = *rptr;
          rptr += inc_z;
          xG[r] = *rptr;
          rptr += inc_x;
          xH[r] = *rptr;
          rptr -= inc_y;
          xF[r] = *rptr;
          rptr -= inc_x;
          xE[r] = *rptr;
          xABDC[r] = 0.25 * (xA[r] + xB[r] + xD[r] + xC[r]);
          xBDHF[r] = 0.25 * (xB[r] + xD[r] + xH[r] + xF[r]);
          xABFE[r] = 0.25 * (xA[r] + xB[r] + xF[r] + xE[r]);
          xCAEG[r] = 0.25 * (xC[r] + xA[r] + xE[r] + xG[r]);
          xDCGH[r] = 0.25 * (xD[r] + xC[r] + xG[r] + xH[r]);
          xEFHG[r] = 0.25 * (xE[r] + xF[r] + xH[r] + xG[r]);
          xM[r] = 0.5 * (xABDC[r] + xEFHG[r]);
          comp += nn;
        }
        res = -dVxTetra3D(cofDy, yA, yB, yABDC, yM, xA, xB, xABDC, xM);
        res += -dVxTetra3D(cofDy, yB, yD, yABDC, yM, xB, xD, xABDC, xM);
        res += -dVxTetra3D(cofDy, yD, yC, yABDC, yM, xD, xC, xABDC, xM);
        res += -dVxTetra3D(cofDy, yC, yA, yABDC, yM, xC, xA, xABDC, xM);
        res += dVxTetra3D(cofDy, yB, yD, yBDHF, yM, xB, xD, xBDHF, xM);
        res += dVxTetra3D(cofDy, yD, yH, yBDHF, yM, xD, xH, xBDHF, xM);
        res += dVxTetra3D(cofDy, yH, yF, yBDHF, yM, xH, xF, xBDHF, xM);
        res += dVxTetra3D(cofDy, yF, yB, yBDHF, yM, xF, xB, xBDHF, xM);
        res += dVxTetra3D(cofDy, yA, yB, yABFE, yM, xA, xB, xABFE, xM);
        res += dVxTetra3D(cofDy, yB, yF, yABFE, yM, xB, xF, xABFE, xM);
        res += dVxTetra3D(cofDy, yF, yE, yABFE, yM, xF, xE, xABFE, xM);
        res += dVxTetra3D(cofDy, yE, yA, yABFE, yM, xE, xA, xABFE, xM);
        res += dVxTetra3D(cofDy, yC, yA, yCAEG, yM, xC, xA, xCAEG, xM);
        res += dVxTetra3D(cofDy, yA, yE, yCAEG, yM, xA, xE, xCAEG, xM);
        res += dVxTetra3D(cofDy, yE, yG, yCAEG, yM, xE, xG, xCAEG, xM);
        res += dVxTetra3D(cofDy, yG, yC, yCAEG, yM, xG, xC, xCAEG, xM);
        res += dVxTetra3D(cofDy, yD, yC, yDCGH, yM, xD, xC, xDCGH, xM);
        res += dVxTetra3D(cofDy, yC, yG, yDCGH, yM, xC, xG, xDCGH, xM);
        res += dVxTetra3D(cofDy, yG, yH, yDCGH, yM, xG, xH, xDCGH, xM);
        res += dVxTetra3D(cofDy, yH, yD, yDCGH, yM, xH, xD, xDCGH, xM);
        res += dVxTetra3D(cofDy, yE, yF, yEFHG, yM, xE, xF, xEFHG, xM);
        res += dVxTetra3D(cofDy, yF, yH, yEFHG, yM, xF, xH, xEFHG, xM);
        res += dVxTetra3D(cofDy, yH, yG, yEFHG, yM, xH, xG, xEFHG, xM);
        res += dVxTetra3D(cofDy, yG, yE, yEFHG, yM, xG, xE, xEFHG, xM);
        id = i1 + m1 * (i2 + i3 * m2);
        result[id] = res;
      }
    }
  }
}


x86 assembly (clang, -O0):
<dJacx3D>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x20(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cvttsd2si 0x8(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
cvttsd2si 0x10(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x468(%rbp)
movl   $0x1,-0x46c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x470(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x474(%rbp)
movl   $0x0,-0x450(%rbp)
mov    -0x450(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2437 <dJacx3D+0x1327>
movl   $0x0,-0x454(%rbp)
mov    -0x454(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    241e <dJacx3D+0x130e>
movl   $0x0,-0x458(%rbp)
mov    -0x458(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2405 <dJacx3D+0x12f5>
mov    -0x450(%rbp),%eax
mov    -0x454(%rbp),%ecx
imul   -0x470(%rbp),%ecx
add    %ecx,%eax
mov    -0x458(%rbp),%ecx
imul   -0x474(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x464(%rbp)
movl   $0x0,-0x460(%rbp)
movl   $0x0,-0x45c(%rbp)
cmpl   $0x3,-0x45c(%rbp)
jge    1a53 <dJacx3D+0x943>
mov    -0x10(%rbp),%rax
movslq -0x464(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x460(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x480(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x470(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x474(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x470(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1bf5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b9c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b46(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x190(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x45c(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1aed(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a91(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a35(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x1f0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x19f1(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
mov    -0x18(%rbp),%rax
movslq -0x464(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x460(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
mov    -0x470(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x270(%rbp,%rax,8)
ff ff
mov    -0x474(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x2f0(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x310(%rbp,%rax,8)
ff ff
mov    -0x470(%rbp),%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
mov    -0x480(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x250(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x290(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x270(%rbp,%rax,8),%xmm1
ff ff
movsd  0x17f7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x330(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x290(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x310(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2d0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x179b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x350(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x250(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2d0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2b0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x173f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x270(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x230(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2b0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2f0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x16e3(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x390(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x290(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x270(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2f0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x310(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1687(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x3b0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x2b0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2d0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x310(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x2f0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x162b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x3d0(%rbp,%rax,8)
ff ff
movslq -0x45c(%rbp),%rax
movsd  -0x330(%rbp,%rax,8),%xmm1
ff ff
movslq -0x45c(%rbp),%rax
addsd  -0x3d0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x15e7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x45c(%rbp),%rax
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
mov    -0x468(%rbp),%eax
add    -0x460(%rbp),%eax
mov    %eax,-0x460(%rbp)
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    1224 <dJacx3D+0x114>
lea    -0x440(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x70(%rbp),%rdx
lea    -0x150(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x250(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0xb0(%rbp),%rdx
lea    -0x150(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x290(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x90(%rbp),%rdx
lea    -0x150(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x270(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x50(%rbp),%rdx
lea    -0x150(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x230(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0xb0(%rbp),%rdx
lea    -0x170(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x290(%rbp),%r11
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x130(%rbp),%rdx
lea    -0x170(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x310(%rbp),%r11
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0xf0(%rbp),%rdx
lea    -0x170(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x2d0(%rbp),%r11
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x70(%rbp),%rdx
lea    -0x170(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x250(%rbp),%r11
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x70(%rbp),%rdx
lea    -0x190(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x250(%rbp),%r11
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
lea    -0x440(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0xf0(%rbp),%rdx
lea    -0x190(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x2d0(%rbp),%r11
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0x190(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x2b0(%rbp),%r11
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x50(%rbp),%rdx
lea    -0x190(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x230(%rbp),%r11
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x50(%rbp),%rdx
lea    -0x1b0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x230(%rbp),%r11
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0x1b0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x2b0(%rbp),%r11
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x110(%rbp),%rdx
lea    -0x1b0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x2f0(%rbp),%r11
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x90(%rbp),%rdx
lea    -0x1b0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x270(%rbp),%r11
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x90(%rbp),%rdx
lea    -0x1d0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x270(%rbp),%r11
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x110(%rbp),%rdx
lea    -0x1d0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x2f0(%rbp),%r11
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x130(%rbp),%rdx
lea    -0x1d0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x310(%rbp),%r11
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0xb0(%rbp),%rdx
lea    -0x1d0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x290(%rbp),%r11
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0xf0(%rbp),%rdx
lea    -0x1f0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x2d0(%rbp),%r11
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x130(%rbp),%rdx
lea    -0x1f0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x310(%rbp),%r11
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x110(%rbp),%rdx
lea    -0x1f0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x2f0(%rbp),%r11
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
lea    -0x440(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0x1f0(%rbp),%rcx
lea    -0x210(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x2b0(%rbp),%r11
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <dVxTetra3D@plt>
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
mov    -0x450(%rbp),%eax
mov    -0x28(%rbp),%ecx
mov    -0x454(%rbp),%edx
mov    -0x458(%rbp),%esi
imul   -0x2c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x44c(%rbp)
movsd  -0x448(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x44c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    11d7 <dJacx3D+0xc7>
jmp    240a <dJacx3D+0x12fa>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    11be <dJacx3D+0xae>
jmp    2423 <dJacx3D+0x1313>
mov    -0x450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x450(%rbp)
jmp    11a5 <dJacx3D+0x95>
add    $0x4a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dJacx3D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x508,%rsp
mov    %rdi,0x370(%rsp)
cvttsd2si (%rcx),%eax
test   %eax,%eax
jle    1fb4 <dJacx3D+0xea4>
cvttsd2si 0x8(%rcx),%ebx
cvttsd2si 0x10(%rcx),%r8d
lea    0x1(%rax),%ecx
lea    0x1(%rbx),%edi
imul   %ecx,%edi
lea    0x1(%r8),%ebp
imul   %edi,%ebp
mov    %ecx,%ecx
movslq %edi,%rdi
movslq %ebp,%r9
mov    %rbx,0x330(%rsp)
movslq %ebx,%rbp
mov    %eax,%eax
mov    %rax,0xd8(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,0x90(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x340(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rax,0x358(%rsp)
shl    $0x3,%r9
lea    (%rsi,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0x88(%rsp)
lea    (%rdi,%rcx,1),%rax
lea    0x8(%rsi,%rax,8),%rbx
mov    %rbx,0x80(%rsp)
lea    0x8(%rsi,%rdi,8),%rsi
mov    %rsi,0x78(%rsp)
lea    0x8(%rdx,%rcx,8),%rcx
mov    %rcx,0x70(%rsp)
lea    0x8(%rdx,%rax,8),%rax
mov    %rax,0x68(%rsp)
lea    0x8(%rdx,%rdi,8),%rax
mov    %rax,0x60(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,0x58(%rsp)
movsd  0xe08(%rip),%xmm10
movsd  0xe07(%rip),%xmm11
mov    %rbp,0x360(%rsp)
mov    %ebp,%eax
mov    %rax,0x338(%rsp)
mov    %r8,0x348(%rsp)
mov    %r8d,%eax
mov    %rax,0x350(%rsp)
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r9,0x368(%rsp)
jmp    1298 <dJacx3D+0x188>
nopw   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rcx
add    $0x1,%rcx
addq   $0x8,0x90(%rsp)
addq   $0x8,0x88(%rsp)
addq   $0x8,0x80(%rsp)
addq   $0x8,0x78(%rsp)
addq   $0x8,0x58(%rsp)
addq   $0x8,0x70(%rsp)
addq   $0x8,0x68(%rsp)
addq   $0x8,0x60(%rsp)
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
cmp    0xd8(%rsp),%rcx
je     1fb4 <dJacx3D+0xea4>
cmpl   $0x0,0x330(%rsp)
jle    1240 <dJacx3D+0x130>
mov    0x60(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x68(%rsp),%rax
mov    %rax,0xc8(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x78(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    0x80(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x88(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0x98(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
jmp    1387 <dJacx3D+0x277>
nopl   0x0(%rax)
mov    0x50(%rsp),%rcx
add    $0x1,%rcx
mov    0x340(%rsp),%rax
add    %rax,0x98(%rsp)
add    %rax,0xa0(%rsp)
add    %rax,0xa8(%rsp)
add    %rax,0xb0(%rsp)
add    %rax,0xb8(%rsp)
add    %rax,0xc0(%rsp)
add    %rax,0xc8(%rsp)
add    %rax,0xd0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
cmp    0x338(%rsp),%rcx
je     1240 <dJacx3D+0x130>
cmpl   $0x0,0x348(%rsp)
jle    1320 <dJacx3D+0x210>
mov    0xd0(%rsp),%rdx
mov    0xc8(%rsp),%rsi
mov    0xc0(%rsp),%r13
mov    0xb8(%rsp),%rbx
mov    0xb0(%rsp),%r14
mov    0xa8(%rsp),%r15
mov    0xa0(%rsp),%rbp
mov    0x98(%rsp),%r12
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdi,0x378(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  -0x8(%r12,%rcx,1),%xmm5
movsd  %xmm5,0x310(%rsp,%rax,1)
movsd  (%r12,%rcx,1),%xmm1
movsd  %xmm1,0x2f0(%rsp,%rax,1)
movsd  0x0(%rbp,%rcx,1),%xmm2
movsd  %xmm2,0x2b0(%rsp,%rax,1)
movsd  -0x8(%rbp,%rcx,1),%xmm7
movsd  %xmm7,0x2d0(%rsp,%rax,1)
movsd  -0x8(%r15,%rcx,1),%xmm8
movsd  %xmm8,0x250(%rsp,%rax,1)
movsd  (%r15,%rcx,1),%xmm9
movsd  %xmm9,0x230(%rsp,%rax,1)
movsd  (%r14,%rcx,1),%xmm0
movsd  %xmm0,0x270(%rsp,%rax,1)
movsd  -0x8(%r14,%rcx,1),%xmm6
movsd  %xmm6,0x290(%rsp,%rax,1)
movapd %xmm5,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm10,%xmm3
movsd  %xmm3,0x4f0(%rsp,%rax,1)
addsd  %xmm2,%xmm1
addsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x4d0(%rsp,%rax,1)
addsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm10,%xmm4
movsd  %xmm4,0x4b0(%rsp,%rax,1)
addsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm8,%xmm5
mulsd  %xmm10,%xmm5
movsd  %xmm5,0x490(%rsp,%rax,1)
addsd  %xmm7,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm9,%xmm2
mulsd  %xmm10,%xmm2
movsd  %xmm2,0x470(%rsp,%rax,1)
addsd  %xmm6,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm10,%xmm0
movsd  %xmm0,0x450(%rsp,%rax,1)
addsd  %xmm3,%xmm0
mulsd  %xmm11,%xmm0
movsd  %xmm0,0x30(%rsp,%rax,1)
movsd  -0x8(%rbx,%rcx,1),%xmm5
movsd  %xmm5,0x210(%rsp,%rax,1)
movsd  (%rbx,%rcx,1),%xmm1
movsd  %xmm1,0x1f0(%rsp,%rax,1)
movsd  0x0(%r13,%rcx,1),%xmm2
movsd  %xmm2,0x1b0(%rsp,%rax,1)
movsd  -0x8(%r13,%rcx,1),%xmm7
movsd  %xmm7,0x1d0(%rsp,%rax,1)
movsd  -0x8(%rsi,%rcx,1),%xmm8
movsd  %xmm8,0x150(%rsp,%rax,1)
movsd  (%rsi,%rcx,1),%xmm9
movsd  %xmm9,0x130(%rsp,%rax,1)
movsd  (%rdx,%rcx,1),%xmm0
movsd  %xmm0,0x170(%rsp,%rax,1)
movsd  -0x8(%rdx,%rcx,1),%xmm6
movsd  %xmm6,0x190(%rsp,%rax,1)
movapd %xmm5,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm10,%xmm3
movsd  %xmm3,0x430(%rsp,%rax,1)
addsd  %xmm2,%xmm1
addsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x410(%rsp,%rax,1)
addsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm10,%xmm4
movsd  %xmm4,0x3f0(%rsp,%rax,1)
addsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm8,%xmm5
mulsd  %xmm10,%xmm5
movsd  %xmm5,0x3d0(%rsp,%rax,1)
addsd  %xmm7,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm9,%xmm2
mulsd  %xmm10,%xmm2
movsd  %xmm2,0x3b0(%rsp,%rax,1)
addsd  %xmm6,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm10,%xmm0
movsd  %xmm0,0x390(%rsp,%rax,1)
addsd  %xmm3,%xmm0
mulsd  %xmm11,%xmm0
movsd  %xmm0,0x10(%rsp,%rax,1)
add    %r9,%rcx
add    $0x8,%rax
cmp    $0x18,%rax
jne    13f0 <dJacx3D+0x2e0>
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x318(%rsp),%rax
mov    %rsi,0x388(%rsp)
mov    %rax,%rsi
lea    0x2f8(%rsp),%rax
mov    %rdx,0x390(%rsp)
mov    %rax,%rdx
lea    0x4f8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x218(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x440(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2f8(%rsp),%rsi
lea    0x2b8(%rsp),%rdx
lea    0x4f8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1f8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x440(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
xorpd  0x8e6(%rip),%xmm0
subsd  (%rsp),%xmm0
movapd %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2b8(%rsp),%rsi
lea    0x2d8(%rsp),%rdx
lea    0x4f8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1b8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x440(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
movapd (%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2d8(%rsp),%rsi
lea    0x318(%rsp),%rdx
lea    0x4f8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1d8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x440(%rsp),%rax
push   %rax
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
movapd (%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2f8(%rsp),%rsi
lea    0x2b8(%rsp),%rdx
lea    0x4d8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1f8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x420(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2b8(%rsp),%rsi
lea    0x238(%rsp),%rdx
lea    0x4d8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1b8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x420(%rsp),%rax
push   %rax
lea    0x148(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x238(%rsp),%rsi
lea    0x278(%rsp),%rdx
lea    0x4d8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x138(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x420(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x278(%rsp),%rsi
lea    0x2f8(%rsp),%rdx
lea    0x4d8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x178(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x420(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x318(%rsp),%rsi
lea    0x2f8(%rsp),%rdx
lea    0x4b8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x218(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x400(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2f8(%rsp),%rsi
lea    0x278(%rsp),%rdx
lea    0x4b8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1f8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x400(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x278(%rsp),%rsi
lea    0x298(%rsp),%rdx
lea    0x4b8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x178(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x400(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x298(%rsp),%rsi
lea    0x318(%rsp),%rdx
lea    0x4b8(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x198(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x400(%rsp),%rax
push   %rax
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2d8(%rsp),%rsi
lea    0x318(%rsp),%rdx
lea    0x498(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1d8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3e0(%rsp),%rax
push   %rax
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x318(%rsp),%rsi
lea    0x298(%rsp),%rdx
lea    0x498(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x218(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3e0(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x298(%rsp),%rsi
lea    0x258(%rsp),%rdx
lea    0x498(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x198(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3e0(%rsp),%rax
push   %rax
lea    0x168(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x258(%rsp),%rsi
lea    0x2d8(%rsp),%rdx
lea    0x498(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x158(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3e0(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2b8(%rsp),%rsi
lea    0x2d8(%rsp),%rdx
lea    0x478(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1b8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3c0(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x2d8(%rsp),%rsi
lea    0x258(%rsp),%rdx
lea    0x478(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x1d8(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3c0(%rsp),%rax
push   %rax
lea    0x168(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x258(%rsp),%rsi
lea    0x238(%rsp),%rdx
lea    0x478(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x158(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3c0(%rsp),%rax
push   %rax
lea    0x148(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x238(%rsp),%rsi
lea    0x2b8(%rsp),%rdx
lea    0x478(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x138(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3c0(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x298(%rsp),%rsi
lea    0x278(%rsp),%rdx
lea    0x458(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x198(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3a0(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x278(%rsp),%rsi
lea    0x238(%rsp),%rdx
lea    0x458(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x178(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3a0(%rsp),%rax
push   %rax
lea    0x148(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x238(%rsp),%rsi
lea    0x258(%rsp),%rdx
lea    0x458(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x138(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3a0(%rsp),%rax
push   %rax
lea    0x168(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
add    $0x20,%rsp
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
sub    $0x8,%rsp
lea    0xe8(%rsp),%rdi
lea    0x258(%rsp),%rsi
lea    0x298(%rsp),%rdx
lea    0x458(%rsp),%rcx
lea    0x38(%rsp),%r8
lea    0x158(%rsp),%r9
lea    0x18(%rsp),%rax
push   %rax
lea    0x3a0(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVxTetra3D@plt>
mov    0x3a0(%rsp),%rsi
mov    0x3a8(%rsp),%rdx
movsd  0xd9(%rip),%xmm11
movsd  0xc8(%rip),%xmm10
mov    0x388(%rsp),%r9
add    $0x20,%rsp
addsd  (%rsp),%xmm0
mov    0x378(%rsp),%rdi
mov    %rdi,%rax
imul   0x360(%rsp),%rax
add    0x50(%rsp),%rax
imul   0xd8(%rsp),%rax
add    0x48(%rsp),%rax
mov    0x370(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rdi
mov    0x358(%rsp),%rax
add    %rax,%r12
add    %rax,%rbp
add    %rax,%r15
add    %rax,%r14
add    %rax,%rbx
add    %rax,%r13
add    %rax,%rsi
add    %rax,%rdx
cmp    0x350(%rsp),%rdi
jne    13e0 <dJacx3D+0x2d0>
jmp    1320 <dJacx3D+0x210>
add    $0x508,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @dJacx3D(double* nocapture writeonly %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, i32 %4) {
%6 = alloca [3 x double]
%7 = alloca [3 x double]
%8 = alloca [3 x double]
%9 = alloca [3 x double]
%10 = alloca [3 x double]
%11 = alloca [3 x double]
%12 = alloca [3 x double]
%13 = alloca [3 x double]
%14 = alloca [3 x double]
%15 = alloca [3 x double]
%16 = alloca [3 x double]
%17 = alloca [3 x double]
%18 = alloca [3 x double]
%19 = alloca [3 x double]
%20 = alloca [3 x double]
%21 = alloca [3 x double]
%22 = alloca [3 x double]
%23 = alloca [3 x double]
%24 = alloca [3 x double]
%25 = alloca [3 x double]
%26 = alloca [3 x double]
%27 = alloca [3 x double]
%28 = alloca [3 x double]
%29 = alloca [3 x double]
%30 = alloca [3 x double]
%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 [9 x double]
%37 = load double, double* %3
%38 = fptosi double %37 to i32
%39 = getelementptr inbounds double, double* %3, i64 1
%40 = load double, double* %39
%41 = fptosi double %40 to i32
%42 = getelementptr inbounds double, double* %3, i64 2
%43 = load double, double* %42
%44 = fptosi double %43 to i32
%45 = bitcast [3 x double]* %6 to i8*
%46 = bitcast [3 x double]* %7 to i8*
%47 = bitcast [3 x double]* %8 to i8*
%48 = bitcast [3 x double]* %9 to i8*
%49 = bitcast [3 x double]* %10 to i8*
%50 = bitcast [3 x double]* %11 to i8*
%51 = bitcast [3 x double]* %12 to i8*
%52 = bitcast [3 x double]* %13 to i8*
%53 = bitcast [3 x double]* %14 to i8*
%54 = bitcast [3 x double]* %15 to i8*
%55 = bitcast [3 x double]* %16 to i8*
%56 = bitcast [3 x double]* %17 to i8*
%57 = bitcast [3 x double]* %18 to i8*
%58 = bitcast [3 x double]* %19 to i8*
%59 = bitcast [3 x double]* %20 to i8*
%60 = bitcast [3 x double]* %21 to i8*
%61 = bitcast [3 x double]* %22 to i8*
%62 = bitcast [3 x double]* %23 to i8*
%63 = bitcast [3 x double]* %24 to i8*
%64 = bitcast [3 x double]* %25 to i8*
%65 = bitcast [3 x double]* %26 to i8*
%66 = bitcast [3 x double]* %27 to i8*
%67 = bitcast [3 x double]* %28 to i8*
%68 = bitcast [3 x double]* %29 to i8*
%69 = bitcast [3 x double]* %30 to i8*
%70 = bitcast [3 x double]* %31 to i8*
%71 = bitcast [3 x double]* %32 to i8*
%72 = bitcast [3 x double]* %33 to i8*
%73 = bitcast [3 x double]* %34 to i8*
%74 = bitcast [3 x double]* %35 to i8*
%75 = bitcast [9 x double]* %36 to i8*
%76 = add nsw i32 %38, 1
%77 = add nsw i32 %41, 1
%78 = mul nsw i32 %77, %76
%79 = icmp sgt i32 %38, 0
br i1 %79, label %80, label %318
80: ; preds = %5
%81 = add nsw i32 %44, 1
%82 = mul i32 %78, %81
%83 = icmp sgt i32 %41, 0
%84 = icmp sgt i32 %44, 0
%85 = zext i32 %76 to i64
%86 = sext i32 %78 to i64
%87 = sub nsw i64 0, %85
%88 = getelementptr inbounds [9 x double], [9 x double]* %36, i64 0, i64 0
%89 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%90 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 0
%91 = getelementptr inbounds [3 x double], [3 x double]* %14, i64 0, i64 0
%92 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 0
%93 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
%94 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%95 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
%96 = getelementptr inbounds [3 x double], [3 x double]* %35, i64 0, i64 0
%97 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%98 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 0
%99 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%100 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
%101 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%102 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
%103 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 0
%104 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0, i64 0
%105 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%106 = getelementptr inbounds [3 x double], [3 x double]* %26, i64 0, i64 0
%107 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%108 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 0, i64 0
%109 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 0
%110 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
%111 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 0
%112 = getelementptr inbounds [3 x double], [3 x double]* %32, i64 0, i64 0
%113 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%114 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
%115 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 0
%116 = getelementptr inbounds [3 x double], [3 x double]* %33, i64 0, i64 0
%117 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 0
%118 = getelementptr inbounds [3 x double], [3 x double]* %34, i64 0, i64 0
%119 = sext i32 %82 to i64
%120 = sext i32 %41 to i64
%121 = zext i32 %38 to i64
%122 = zext i32 %38 to i64
%123 = zext i32 %41 to i64
%124 = zext i32 %44 to i64
br label %125
125: ; preds = %80, %315
%126 = phi i64 [ 0, %80 ], [ %316, %315 ]
br i1 %83, label %127, label %315
127: ; preds = %125, %312
%128 = phi i64 [ %313, %312 ], [ 0, %125 ]
br i1 %84, label %129, label %312
129: ; preds = %127
%130 = mul nsw i64 %128, %85
%131 = add nuw nsw i64 %130, %126
br label %132
132: ; preds = %129, %256
%133 = phi i64 [ 0, %129 ], [ %310, %256 ]
%134 = mul nsw i64 %133, %86
%135 = add nsw i64 %131, %134
%136 = getelementptr inbounds double, double* %1, i64 %135
%137 = getelementptr inbounds double, double* %2, i64 %135
br label %138
138: ; preds = %132, %138
%139 = phi i64 [ 0, %132 ], [ %253, %138 ]
%140 = phi i64 [ 0, %132 ], [ %254, %138 ]
%141 = getelementptr inbounds double, double* %136, i64 %139
%142 = load double, double* %141
%143 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 %140
store double %142, double* %143
%144 = getelementptr inbounds double, double* %141, i64 1
%145 = load double, double* %144
%146 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %140
store double %145, double* %146
%147 = getelementptr inbounds double, double* %144, i64 %85
%148 = load double, double* %147
%149 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 %140
store double %148, double* %149
%150 = getelementptr inbounds double, double* %147, i64 -1
%151 = load double, double* %150
%152 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 %140
store double %151, double* %152
%153 = getelementptr inbounds double, double* %150, i64 %86
%154 = load double, double* %153
%155 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 %140
store double %154, double* %155
%156 = getelementptr inbounds double, double* %153, i64 1
%157 = load double, double* %156
%158 = getelementptr inbounds [3 x double], [3 x double]* %13, i64 0, i64 %140
store double %157, double* %158
%159 = getelementptr inbounds double, double* %156, i64 %87
%160 = load double, double* %159
%161 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 %140
store double %160, double* %161
%162 = getelementptr inbounds double, double* %159, i64 -1
%163 = load double, double* %162
%164 = getelementptr inbounds [3 x double], [3 x double]* %10, i64 0, i64 %140
store double %163, double* %164
%165 = fadd double %142, %145
%166 = fadd double %165, %148
%167 = fadd double %166, %151
%168 = fmul double %167, 2.500000e-01
%169 = getelementptr inbounds [3 x double], [3 x double]* %14, i64 0, i64 %140
store double %168, double* %169
%170 = fadd double %145, %148
%171 = fadd double %170, %157
%172 = fadd double %171, %160
%173 = fmul double %172, 2.500000e-01
%174 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 %140
store double %173, double* %174
%175 = fadd double %165, %160
%176 = fadd double %175, %163
%177 = fmul double %176, 2.500000e-01
%178 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 %140
store double %177, double* %178
%179 = fadd double %142, %151
%180 = fadd double %179, %163
%181 = fadd double %154, %180
%182 = fmul double %181, 2.500000e-01
%183 = getelementptr inbounds [3 x double], [3 x double]* %17, i64 0, i64 %140
store double %182, double* %183
%184 = fadd double %148, %151
%185 = fadd double %184, %154
%186 = fadd double %185, %157
%187 = fmul double %186, 2.500000e-01
%188 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 %140
store double %187, double* %188
%189 = fadd double %160, %163
%190 = fadd double %157, %189
%191 = fadd double %154, %190
%192 = fmul double %191, 2.500000e-01
%193 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 %140
store double %192, double* %193
%194 = fadd double %168, %192
%195 = fmul double %194, 5.000000e-01
%196 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 %140
store double %195, double* %196
%197 = getelementptr inbounds double, double* %137, i64 %139
%198 = load double, double* %197
%199 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %140
store double %198, double* %199
%200 = getelementptr inbounds double, double* %197, i64 1
%201 = load double, double* %200
%202 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %140
store double %201, double* %202
%203 = getelementptr inbounds double, double* %200, i64 %85
%204 = load double, double* %203
%205 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 %140
store double %204, double* %205
%206 = getelementptr inbounds double, double* %203, i64 -1
%207 = load double, double* %206
%208 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 %140
store double %207, double* %208
%209 = getelementptr inbounds double, double* %206, i64 %86
%210 = load double, double* %209
%211 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 %140
store double %210, double* %211
%212 = getelementptr inbounds double, double* %209, i64 1
%213 = load double, double* %212
%214 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0, i64 %140
store double %213, double* %214
%215 = getelementptr inbounds double, double* %212, i64 %87
%216 = load double, double* %215
%217 = getelementptr inbounds [3 x double], [3 x double]* %26, i64 0, i64 %140
store double %216, double* %217
%218 = getelementptr inbounds double, double* %215, i64 -1
%219 = load double, double* %218
%220 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 %140
store double %219, double* %220
%221 = fadd double %198, %201
%222 = fadd double %221, %204
%223 = fadd double %222, %207
%224 = fmul double %223, 2.500000e-01
%225 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 %140
store double %224, double* %225
%226 = fadd double %201, %204
%227 = fadd double %226, %213
%228 = fadd double %227, %216
%229 = fmul double %228, 2.500000e-01
%230 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 %140
store double %229, double* %230
%231 = fadd double %221, %216
%232 = fadd double %231, %219
%233 = fmul double %232, 2.500000e-01
%234 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 0, i64 %140
store double %233, double* %234
%235 = fadd double %198, %207
%236 = fadd double %235, %219
%237 = fadd double %210, %236
%238 = fmul double %237, 2.500000e-01
%239 = getelementptr inbounds [3 x double], [3 x double]* %32, i64 0, i64 %140
store double %238, double* %239
%240 = fadd double %204, %207
%241 = fadd double %240, %210
%242 = fadd double %241, %213
%243 = fmul double %242, 2.500000e-01
%244 = getelementptr inbounds [3 x double], [3 x double]* %33, i64 0, i64 %140
store double %243, double* %244
%245 = fadd double %216, %219
%246 = fadd double %213, %245
%247 = fadd double %210, %246
%248 = fmul double %247, 2.500000e-01
%249 = getelementptr inbounds [3 x double], [3 x double]* %34, i64 0, i64 %140
store double %248, double* %249
%250 = fadd double %224, %248
%251 = fmul double %250, 5.000000e-01
%252 = getelementptr inbounds [3 x double], [3 x double]* %35, i64 0, i64 %140
store double %251, double* %252
%253 = add nsw i64 %139, %119
%254 = add nuw nsw i64 %140, 1
%255 = icmp eq i64 %254, 3
br i1 %255, label %256, label %138
256: ; preds = %138
%257 = call double @dVxTetra3D(double* %88, double* %89, double* %90, double* %91, double* %92, double* %93, double* %94, double* %95, double* %96)
%258 = call double @dVxTetra3D(double* %88, double* %90, double* %97, double* %91, double* %92, double* %94, double* %98, double* %95, double* %96)
%259 = fneg double %258
%260 = fsub double %259, %257
%261 = call double @dVxTetra3D(double* %88, double* %97, double* %99, double* %91, double* %92, double* %98, double* %100, double* %95, double* %96)
%262 = fsub double %260, %261
%263 = call double @dVxTetra3D(double* %88, double* %99, double* %89, double* %91, double* %92, double* %100, double* %93, double* %95, double* %96)
%264 = fsub double %262, %263
%265 = call double @dVxTetra3D(double* %88, double* %90, double* %97, double* %101, double* %92, double* %94, double* %98, double* %102, double* %96)
%266 = fadd double %264, %265
%267 = call double @dVxTetra3D(double* %88, double* %97, double* %103, double* %101, double* %92, double* %98, double* %104, double* %102, double* %96)
%268 = fadd double %266, %267
%269 = call double @dVxTetra3D(double* %88, double* %103, double* %105, double* %101, double* %92, double* %104, double* %106, double* %102, double* %96)
%270 = fadd double %268, %269
%271 = call double @dVxTetra3D(double* %88, double* %105, double* %90, double* %101, double* %92, double* %106, double* %94, double* %102, double* %96)
%272 = fadd double %270, %271
%273 = call double @dVxTetra3D(double* %88, double* %89, double* %90, double* %107, double* %92, double* %93, double* %94, double* %108, double* %96)
%274 = fadd double %272, %273
%275 = call double @dVxTetra3D(double* %88, double* %90, double* %105, double* %107, double* %92, double* %94, double* %106, double* %108, double* %96)
%276 = fadd double %274, %275
%277 = call double @dVxTetra3D(double* %88, double* %105, double* %109, double* %107, double* %92, double* %106, double* %110, double* %108, double* %96)
%278 = fadd double %276, %277
%279 = call double @dVxTetra3D(double* %88, double* %109, double* %89, double* %107, double* %92, double* %110, double* %93, double* %108, double* %96)
%280 = fadd double %278, %279
%281 = call double @dVxTetra3D(double* %88, double* %99, double* %89, double* %111, double* %92, double* %100, double* %93, double* %112, double* %96)
%282 = fadd double %280, %281
%283 = call double @dVxTetra3D(double* %88, double* %89, double* %109, double* %111, double* %92, double* %93, double* %110, double* %112, double* %96)
%284 = fadd double %282, %283
%285 = call double @dVxTetra3D(double* %88, double* %109, double* %113, double* %111, double* %92, double* %110, double* %114, double* %112, double* %96)
%286 = fadd double %284, %285
%287 = call double @dVxTetra3D(double* %88, double* %113, double* %99, double* %111, double* %92, double* %114, double* %100, double* %112, double* %96)
%288 = fadd double %286, %287
%289 = call double @dVxTetra3D(double* %88, double* %97, double* %99, double* %115, double* %92, double* %98, double* %100, double* %116, double* %96)
%290 = fadd double %288, %289
%291 = call double @dVxTetra3D(double* %88, double* %99, double* %113, double* %115, double* %92, double* %100, double* %114, double* %116, double* %96)
%292 = fadd double %290, %291
%293 = call double @dVxTetra3D(double* %88, double* %113, double* %103, double* %115, double* %92, double* %114, double* %104, double* %116, double* %96)
%294 = fadd double %292, %293
%295 = call double @dVxTetra3D(double* %88, double* %103, double* %97, double* %115, double* %92, double* %104, double* %98, double* %116, double* %96)
%296 = fadd double %294, %295
%297 = call double @dVxTetra3D(double* %88, double* %109, double* %105, double* %117, double* %92, double* %110, double* %106, double* %118, double* %96)
%298 = fadd double %296, %297
%299 = call double @dVxTetra3D(double* %88, double* %105, double* %103, double* %117, double* %92, double* %106, double* %104, double* %118, double* %96)
%300 = fadd double %298, %299
%301 = call double @dVxTetra3D(double* %88, double* %103, double* %113, double* %117, double* %92, double* %104, double* %114, double* %118, double* %96)
%302 = fadd double %300, %301
%303 = call double @dVxTetra3D(double* %88, double* %113, double* %109, double* %117, double* %92, double* %114, double* %110, double* %118, double* %96)
%304 = fadd double %302, %303
%305 = mul nsw i64 %133, %120
%306 = add nsw i64 %305, %128
%307 = mul nsw i64 %306, %121
%308 = add nsw i64 %307, %126
%309 = getelementptr inbounds double, double* %0, i64 %308
store double %304, double* %309
%310 = add nuw nsw i64 %133, 1
%311 = icmp eq i64 %310, %124
br i1 %311, label %312, label %132
312: ; preds = %256, %127
%313 = add nuw nsw i64 %128, 1
%314 = icmp eq i64 %313, %123
br i1 %314, label %315, label %127
315: ; preds = %312, %125
%316 = add nuw nsw i64 %126, 1
%317 = icmp eq i64 %316, %122
br i1 %317, label %318, label %125
318: ; preds = %315, %5
ret void
}