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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ dVTTetra3D(double *, double *, double *, double *, double,
                              double *, double *, double *, double *);
void dJacTx3D(double *prod, const double *yc, const double *x, const double *m,
              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 rA[3], rB[3], rC[3], rD[3], rE[3], rF[3], rG[3], rH[3], rABDC[3],
      rBDHF[3], rABFE[3], rCAEG[3], rDCGH[3], rEFHG[3], rM[3];
  double xp;
  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;
  double *wptr;
#pragma omp parallel for default(shared) private(                              \
    rptr, wptr, id, i1, i2, i3, r, comp, idn, xp, yA, yB, yC, yD, yE, yF, yG,  \
    yH, yABDC, yBDHF, yABFE, yCAEG, yDCGH, yEFHG, yM, rA, rB, rC, rD, rE, rF,  \
    rG, rH, rABDC, rBDHF, rABFE, rCAEG, rDCGH, rEFHG, rM)
  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;
        id = i1 + m1 * (i2 + i3 * m2);
        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]);
          comp += nn;
          rA[r] = 0.0;
          rB[r] = 0.0;
          rC[r] = 0.0;
          rD[r] = 0.0;
          rE[r] = 0.0;
          rF[r] = 0.0;
          rG[r] = 0.0;
          rH[r] = 0.0;
          rABDC[r] = 0.0;
          rBDHF[r] = 0.0;
          rABFE[r] = 0.0;
          rCAEG[r] = 0.0;
          rDCGH[r] = 0.0;
          rEFHG[r] = 0.0;
          rM[r] = 0.0;
        }
        xp = x[id];
        dVTTetra3D(yA, yB, yABDC, yM, -xp, rA, rB, rABDC, rM);
        dVTTetra3D(yB, yD, yABDC, yM, -xp, rB, rD, rABDC, rM);
        dVTTetra3D(yD, yC, yABDC, yM, -xp, rD, rC, rABDC, rM);
        dVTTetra3D(yC, yA, yABDC, yM, -xp, rC, rA, rABDC, rM);
        dVTTetra3D(yB, yD, yBDHF, yM, xp, rB, rD, rBDHF, rM);
        dVTTetra3D(yD, yH, yBDHF, yM, xp, rD, rH, rBDHF, rM);
        dVTTetra3D(yH, yF, yBDHF, yM, xp, rH, rF, rBDHF, rM);
        dVTTetra3D(yF, yB, yBDHF, yM, xp, rF, rB, rBDHF, rM);
        dVTTetra3D(yA, yB, yABFE, yM, xp, rA, rB, rABFE, rM);
        dVTTetra3D(yB, yF, yABFE, yM, xp, rB, rF, rABFE, rM);
        dVTTetra3D(yF, yE, yABFE, yM, xp, rF, rE, rABFE, rM);
        dVTTetra3D(yE, yA, yABFE, yM, xp, rE, rA, rABFE, rM);
        dVTTetra3D(yC, yA, yCAEG, yM, xp, rC, rA, rCAEG, rM);
        dVTTetra3D(yA, yE, yCAEG, yM, xp, rA, rE, rCAEG, rM);
        dVTTetra3D(yE, yG, yCAEG, yM, xp, rE, rG, rCAEG, rM);
        dVTTetra3D(yG, yC, yCAEG, yM, xp, rG, rC, rCAEG, rM);
        dVTTetra3D(yD, yC, yDCGH, yM, xp, rD, rC, rDCGH, rM);
        dVTTetra3D(yC, yG, yDCGH, yM, xp, rC, rG, rDCGH, rM);
        dVTTetra3D(yG, yH, yDCGH, yM, xp, rG, rH, rDCGH, rM);
        dVTTetra3D(yH, yD, yDCGH, yM, xp, rH, rD, rDCGH, rM);
        dVTTetra3D(yE, yF, yEFHG, yM, xp, rE, rF, rEFHG, rM);
        dVTTetra3D(yF, yH, yEFHG, yM, xp, rF, rH, rEFHG, rM);
        dVTTetra3D(yH, yG, yEFHG, yM, xp, rH, rG, rEFHG, rM);
        dVTTetra3D(yG, yE, yEFHG, yM, xp, rG, rE, rEFHG, rM);
        comp = 0;
        for (r = 0; r < 3; r++) {
          rABDC[r] *= 0.25;
          rBDHF[r] *= 0.25;
          rABFE[r] *= 0.25;
          rCAEG[r] *= 0.25;
          rDCGH[r] *= 0.25;
          rEFHG[r] *= 0.25;
          rM[r] *= 0.125;
          wptr = prod + idn + comp;
#pragma omp atomic
          *wptr += rA[r] + rABDC[r] + rABFE[r] + rCAEG[r] + rM[r];
          wptr += inc_x;
#pragma omp atomic
          *wptr += rB[r] + rABDC[r] + rBDHF[r] + rABFE[r] + rM[r];
          wptr += inc_y;
#pragma omp atomic
          *wptr += rD[r] + rABDC[r] + rBDHF[r] + rDCGH[r] + rM[r];
          wptr -= inc_x;
#pragma omp atomic
          *wptr += rC[r] + rABDC[r] + rCAEG[r] + rDCGH[r] + rM[r];
          wptr += inc_z;
#pragma omp atomic
          *wptr += rG[r] + rCAEG[r] + rDCGH[r] + rEFHG[r] + rM[r];
          wptr += inc_x;
#pragma omp atomic
          *wptr += rH[r] + rBDHF[r] + rDCGH[r] + rEFHG[r] + rM[r];
          wptr -= inc_y;
#pragma omp atomic
          *wptr += rF[r] + rBDHF[r] + rABFE[r] + rEFHG[r] + rM[r];
          wptr -= inc_x;
#pragma omp atomic
          *wptr += rE[r] + rABFE[r] + rCAEG[r] + rEFHG[r] + rM[r];
          comp += nn;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<dJacTx3D>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%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,-0x418(%rbp)
movl   $0x1,-0x41c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x420(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x424(%rbp)
movl   $0x0,-0x400(%rbp)
mov    -0x400(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    246b <dJacTx3D+0x135b>
movl   $0x0,-0x404(%rbp)
mov    -0x404(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    2452 <dJacTx3D+0x1342>
movl   $0x0,-0x408(%rbp)
mov    -0x408(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2439 <dJacTx3D+0x1329>
mov    -0x400(%rbp),%eax
mov    -0x404(%rbp),%ecx
imul   -0x420(%rbp),%ecx
add    %ecx,%eax
mov    -0x408(%rbp),%ecx
imul   -0x424(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x414(%rbp)
mov    -0x400(%rbp),%eax
mov    -0x28(%rbp),%ecx
mov    -0x404(%rbp),%edx
mov    -0x408(%rbp),%esi
imul   -0x2c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x3fc(%rbp)
movl   $0x0,-0x410(%rbp)
movl   $0x0,-0x40c(%rbp)
cmpl   $0x3,-0x40c(%rbp)
jge    178c <dJacTx3D+0x67c>
mov    -0x10(%rbp),%rax
movslq -0x414(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x410(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x430(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x420(%rbp),%ecx
mov    -0x430(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x430(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x424(%rbp),%ecx
mov    -0x430(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
mov    -0x430(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x420(%rbp),%ecx
mov    -0x430(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x430(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1bcf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b76(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b20(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x190(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x50(%rbp,%rax,8),%xmm1
movslq -0x40c(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1ac7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a6b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a0f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x1f0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x19db(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x40c(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
mov    -0x418(%rbp),%eax
add    -0x410(%rbp),%eax
mov    %eax,-0x410(%rbp)
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x270(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2f0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x310(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x330(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x350(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x390(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3b0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3d0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
mov    -0x40c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40c(%rbp)
jmp    124a <dJacTx3D+0x13a>
mov    -0x18(%rbp),%rax
movslq -0x3fc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3f8(%rbp)
ff
lea    -0x50(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%r8
xor    %r8,%rax
movq   %rax,%xmm0
lea    -0x230(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x70(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%r8
xor    %r8,%rax
movq   %rax,%xmm0
lea    -0x250(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%r8
xor    %r8,%rax
movq   %rax,%xmm0
lea    -0x290(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x90(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%r8
xor    %r8,%rax
movq   %rax,%xmm0
lea    -0x270(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x330(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x70(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x250(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x290(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x130(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x310(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2d0(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x350(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x50(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x230(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x70(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x250(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xf0(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2d0(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xd0(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2b0(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x370(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x90(%rbp),%rdi
lea    -0x50(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x270(%rbp),%r8
lea    -0x230(%rbp),%r9
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x50(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x230(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xd0(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2b0(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x110(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2f0(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x390(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x290(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x90(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x270(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x110(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2f0(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x130(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x310(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x3b0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xd0(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2b0(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2d0(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x130(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x310(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
lea    -0x110(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x210(%rbp),%rcx
movsd  -0x3f8(%rbp),%xmm0
ff
lea    -0x2f0(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x3d0(%rbp),%r10
lea    -0x3f0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1030 <dVTTetra3D@plt>
movl   $0x0,-0x410(%rbp)
movl   $0x0,-0x40c(%rbp)
cmpl   $0x3,-0x40c(%rbp)
jge    2420 <dJacTx3D+0x1310>
movslq -0x40c(%rbp),%rax
movsd  0x10ac(%rip),%xmm0
mulsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x330(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0x108b(%rip),%xmm0
mulsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x350(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0x106a(%rip),%xmm0
mulsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x370(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0x1049(%rip),%xmm0
mulsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x390(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0x1028(%rip),%xmm0
mulsd  -0x3b0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3b0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0x1007(%rip),%xmm0
mulsd  -0x3d0(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x3d0(%rbp,%rax,8)
ff ff
movslq -0x40c(%rbp),%rax
movsd  0xfde(%rip),%xmm0
mulsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
mov    -0x8(%rbp),%rax
movslq -0x414(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x410(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x230(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x438(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x420(%rbp),%ecx
mov    -0x438(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x438(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x270(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x424(%rbp),%ecx
mov    -0x438(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x2f0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x438(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x310(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x420(%rbp),%ecx
mov    -0x438(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x350(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x438(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x438(%rbp)
movslq -0x40c(%rbp),%rax
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x370(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x390(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3d0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x40c(%rbp),%rax
addsd  -0x3f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x438(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x418(%rbp),%eax
add    -0x410(%rbp),%eax
mov    %eax,-0x410(%rbp)
mov    -0x40c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40c(%rbp)
jmp    1f40 <dJacTx3D+0xe30>
jmp    2425 <dJacTx3D+0x1315>
mov    -0x408(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x408(%rbp)
jmp    11d7 <dJacTx3D+0xc7>
jmp    243e <dJacTx3D+0x132e>
mov    -0x404(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x404(%rbp)
jmp    11be <dJacTx3D+0xae>
jmp    2457 <dJacTx3D+0x1347>
mov    -0x400(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x400(%rbp)
jmp    11a5 <dJacTx3D+0x95>
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dJacTx3D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4c8,%rsp
mov    %rdx,0x3e8(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rdi,0x50(%rsp)
cvttsd2si (%rcx),%eax
test   %eax,%eax
jle    1fcc <dJacTx3D+0xebc>
cvttsd2si 0x8(%rcx),%edi
cvttsd2si 0x10(%rcx),%ebp
lea    0x1(%rax),%ecx
lea    0x1(%rdi),%edx
imul   %ecx,%edx
lea    0x1(%rbp),%esi
imul   %edx,%esi
mov    %ecx,%ecx
movslq %edx,%rdx
movslq %esi,%rbx
mov    %rdi,0x3a8(%rsp)
movslq %edi,%rsi
mov    %eax,%eax
mov    %rax,0x178(%rsp)
mov    %rsi,0x3e0(%rsp)
mov    %esi,%eax
mov    %rax,0x3b8(%rsp)
mov    %rbp,0x3c0(%rsp)
mov    %ebp,%eax
mov    %rax,0x3d8(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x3b0(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x3d0(%rsp)
mov    0x58(%rsp),%rsi
lea    (%rsi,%rcx,8),%rax
mov    %rax,0x130(%rsp)
lea    (%rdx,%rcx,1),%rax
lea    (%rsi,%rax,8),%rdi
mov    %rdi,0x128(%rsp)
lea    (%rsi,%rdx,8),%rsi
mov    %rsi,0x120(%rsp)
mov    0x50(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x118(%rsp)
lea    0x8(%rsi,%rax,8),%rax
mov    %rax,0x110(%rsp)
lea    0x8(%rsi,%rdx,8),%rax
mov    %rax,0x108(%rsp)
movsd  0xde6(%rip),%xmm10
movsd  0xde5(%rip),%xmm11
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    %rbx,0x3c8(%rsp)
jmp    12a1 <dJacTx3D+0x191>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
addq   $0x8,0x58(%rsp)
addq   $0x8,0x130(%rsp)
addq   $0x8,0x128(%rsp)
addq   $0x8,0x120(%rsp)
addq   $0x8,0x50(%rsp)
addq   $0x8,0x118(%rsp)
addq   $0x8,0x110(%rsp)
addq   $0x8,0x108(%rsp)
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
cmp    0x178(%rsp),%rcx
je     1fcc <dJacTx3D+0xebc>
cmpl   $0x0,0x3a8(%rsp)
jle    1240 <dJacTx3D+0x130>
mov    0x108(%rsp),%rax
mov    %rax,0x170(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x168(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x160(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0x120(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0x128(%rsp),%rax
mov    %rax,0x148(%rsp)
mov    0x130(%rsp),%rax
mov    %rax,0x140(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x138(%rsp)
xor    %eax,%eax
mov    %rax,0x68(%rsp)
jmp    1397 <dJacTx3D+0x287>
xchg   %ax,%ax
mov    0x68(%rsp),%rcx
add    $0x1,%rcx
mov    0x3b0(%rsp),%rax
add    %rax,0x138(%rsp)
add    %rax,0x140(%rsp)
add    %rax,0x148(%rsp)
add    %rax,0x150(%rsp)
add    %rax,0x158(%rsp)
add    %rax,0x160(%rsp)
add    %rax,0x168(%rsp)
add    %rax,0x170(%rsp)
mov    %rcx,%rax
mov    %rcx,0x68(%rsp)
cmp    0x3b8(%rsp),%rcx
je     1240 <dJacTx3D+0x130>
cmpl   $0x0,0x3c0(%rsp)
jle    1330 <dJacTx3D+0x220>
mov    0x170(%rsp),%rbp
mov    0x168(%rsp),%r13
mov    0x160(%rsp),%rdx
mov    0x158(%rsp),%rsi
mov    0x150(%rsp),%rdi
mov    0x148(%rsp),%r14
mov    0x140(%rsp),%r15
mov    0x138(%rsp),%r12
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,0x400(%rsp)
mov    %rdx,0x408(%rsp)
mov    %rcx,0x3f0(%rsp)
mov    %rcx,%rax
imul   0x3e0(%rsp),%rax
add    0x68(%rsp),%rax
imul   0x178(%rsp),%rax
xorps  %xmm0,%xmm0
movaps %xmm0,0xf0(%rsp)
movq   $0x0,0x100(%rsp)
movaps %xmm0,0xd0(%rsp)
movq   $0x0,0xe0(%rsp)
movaps %xmm0,0x280(%rsp)
movq   $0x0,0x290(%rsp)
movaps %xmm0,0xb0(%rsp)
movq   $0x0,0xc0(%rsp)
movaps %xmm0,0x260(%rsp)
movq   $0x0,0x270(%rsp)
movaps %xmm0,0x90(%rsp)
movq   $0x0,0xa0(%rsp)
movaps %xmm0,0x240(%rsp)
movq   $0x0,0x250(%rsp)
movaps %xmm0,0x70(%rsp)
movq   $0x0,0x80(%rsp)
movaps %xmm0,0x220(%rsp)
movq   $0x0,0x230(%rsp)
movaps %xmm0,0x200(%rsp)
movq   $0x0,0x210(%rsp)
movaps %xmm0,0x1e0(%rsp)
movq   $0x0,0x1f0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movq   $0x0,0x1d0(%rsp)
movaps %xmm0,0x1a0(%rsp)
movq   $0x0,0x1b0(%rsp)
movaps %xmm0,0x180(%rsp)
movq   $0x0,0x190(%rsp)
movaps %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
mov    $0x1,%ecx
xor    %edx,%edx
nop
movsd  -0x8(%r12,%rcx,8),%xmm5
movsd  %xmm5,0x2e0(%rsp,%rdx,1)
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x2c0(%rsp,%rdx,1)
movsd  (%r15,%rcx,8),%xmm2
movsd  %xmm2,0x2a0(%rsp,%rdx,1)
movsd  -0x8(%r15,%rcx,8),%xmm7
movsd  %xmm7,0x390(%rsp,%rdx,1)
movsd  -0x8(%r14,%rcx,8),%xmm8
movsd  %xmm8,0x330(%rsp,%rdx,1)
movsd  (%r14,%rcx,8),%xmm9
movsd  %xmm9,0x310(%rsp,%rdx,1)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,0x350(%rsp,%rdx,1)
movsd  -0x8(%rdi,%rcx,8),%xmm6
movsd  %xmm6,0x370(%rsp,%rdx,1)
movapd %xmm5,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm10,%xmm3
movsd  %xmm3,0x4b0(%rsp,%rdx,1)
addsd  %xmm2,%xmm1
addsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x490(%rsp,%rdx,1)
addsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm10,%xmm4
movsd  %xmm4,0x470(%rsp,%rdx,1)
addsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm8,%xmm5
mulsd  %xmm10,%xmm5
movsd  %xmm5,0x450(%rsp,%rdx,1)
addsd  %xmm7,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm9,%xmm2
mulsd  %xmm10,%xmm2
movsd  %xmm2,0x430(%rsp,%rdx,1)
addsd  %xmm6,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm10,%xmm0
movsd  %xmm0,0x410(%rsp,%rdx,1)
addsd  %xmm3,%xmm0
mulsd  %xmm11,%xmm0
movsd  %xmm0,0x30(%rsp,%rdx,1)
add    %rbx,%rcx
add    $0x8,%rdx
cmp    $0x18,%rdx
jne    1550 <dJacTx3D+0x440>
mov    %rdi,0x3f8(%rsp)
add    0x60(%rsp),%rax
mov    0x3e8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movaps %xmm0,(%rsp)
xorps  0x969(%rip),%xmm0
movaps %xmm0,0x300(%rsp)
lea    0x2e0(%rsp),%rdi
lea    0x2c0(%rsp),%rsi
lea    0x4b0(%rsp),%rdx
lea    0x30(%rsp),%rcx
lea    0xf0(%rsp),%r8
lea    0xd0(%rsp),%r9
lea    0x10(%rsp),%rbx
push   %rbx
lea    0x228(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2c0(%rsp),%rdi
lea    0x2a0(%rsp),%rsi
lea    0x4b0(%rsp),%rbx
mov    %rbx,%rdx
lea    0x30(%rsp),%rcx
movaps 0x300(%rsp),%xmm0
lea    0xd0(%rsp),%r8
lea    0xb0(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2a0(%rsp),%rdi
lea    0x390(%rsp),%rsi
mov    %rbx,%rdx
lea    0x30(%rsp),%rcx
movaps 0x300(%rsp),%xmm0
lea    0xb0(%rsp),%r8
lea    0x280(%rsp),%rbx
mov    %rbx,%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x390(%rsp),%rdi
lea    0x2e0(%rsp),%rsi
lea    0x4b0(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps 0x300(%rsp),%xmm0
mov    %rbx,%r8
lea    0xf0(%rsp),%r9
lea    0x10(%rsp),%rbx
push   %rbx
lea    0x228(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2c0(%rsp),%rdi
lea    0x2a0(%rsp),%rsi
lea    0x490(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0xd0(%rsp),%r8
lea    0xb0(%rsp),%r9
push   %rbx
lea    0x208(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2a0(%rsp),%rdi
lea    0x310(%rsp),%rsi
lea    0x490(%rsp),%rdx
lea    0x30(%rsp),%rbx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0xb0(%rsp),%r8
lea    0x70(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x310(%rsp),%rdi
lea    0x350(%rsp),%rsi
lea    0x490(%rsp),%rdx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x70(%rsp),%r8
lea    0x90(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x350(%rsp),%rdi
lea    0x2c0(%rsp),%rsi
lea    0x490(%rsp),%rdx
lea    0x30(%rsp),%rbx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x90(%rsp),%r8
lea    0xd0(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x208(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2e0(%rsp),%rdi
lea    0x2c0(%rsp),%rsi
lea    0x470(%rsp),%rdx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0xf0(%rsp),%r8
lea    0xd0(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2c0(%rsp),%rdi
lea    0x350(%rsp),%rbx
mov    %rbx,%rsi
lea    0x470(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0xd0(%rsp),%r8
lea    0x90(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
mov    %rbx,%rdi
lea    0x370(%rsp),%rbx
mov    %rbx,%rsi
lea    0x470(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x90(%rsp),%r8
lea    0x260(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
mov    %rbx,%rdi
lea    0x2e0(%rsp),%rsi
lea    0x470(%rsp),%rdx
lea    0x30(%rsp),%rbx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x260(%rsp),%r8
lea    0xf0(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1e8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x390(%rsp),%rdi
lea    0x2e0(%rsp),%rsi
lea    0x450(%rsp),%rdx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x280(%rsp),%r8
lea    0xf0(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2e0(%rsp),%rdi
lea    0x370(%rsp),%rsi
lea    0x450(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0xf0(%rsp),%r8
lea    0x260(%rsp),%rbx
mov    %rbx,%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x370(%rsp),%rdi
lea    0x330(%rsp),%rsi
lea    0x450(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
mov    %rbx,%r8
lea    0x240(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x330(%rsp),%rdi
lea    0x390(%rsp),%rbx
mov    %rbx,%rsi
lea    0x450(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x240(%rsp),%r8
lea    0x280(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1c8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x2a0(%rsp),%rdi
mov    %rbx,%rsi
lea    0x430(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0xb0(%rsp),%r8
lea    0x280(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x390(%rsp),%rdi
lea    0x330(%rsp),%rbx
mov    %rbx,%rsi
lea    0x430(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x280(%rsp),%r8
lea    0x240(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
mov    %rbx,%rdi
lea    0x310(%rsp),%rbx
mov    %rbx,%rsi
lea    0x430(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x240(%rsp),%r8
lea    0x70(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
mov    %rbx,%rdi
lea    0x2a0(%rsp),%rsi
lea    0x430(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x70(%rsp),%r8
lea    0xb0(%rsp),%r9
lea    0x10(%rsp),%rbx
push   %rbx
lea    0x1a8(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x370(%rsp),%rdi
lea    0x350(%rsp),%rsi
lea    0x410(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
lea    0x260(%rsp),%r8
lea    0x90(%rsp),%r9
push   %rbx
lea    0x188(%rsp),%rbx
push   %rbx
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x350(%rsp),%rdi
lea    0x310(%rsp),%rsi
lea    0x410(%rsp),%rdx
lea    0x30(%rsp),%rbx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x90(%rsp),%r8
lea    0x70(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x310(%rsp),%rdi
lea    0x330(%rsp),%rsi
lea    0x410(%rsp),%rdx
mov    %rbx,%rcx
movaps (%rsp),%xmm0
lea    0x70(%rsp),%r8
lea    0x240(%rsp),%rbx
mov    %rbx,%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
add    $0x10,%rsp
lea    0x330(%rsp),%rdi
lea    0x370(%rsp),%rsi
lea    0x410(%rsp),%rdx
lea    0x30(%rsp),%rcx
movaps (%rsp),%xmm0
mov    %rbx,%r8
lea    0x260(%rsp),%r9
lea    0x10(%rsp),%rax
push   %rax
lea    0x188(%rsp),%rax
push   %rax
call   1030 <dVTTetra3D@plt>
movsd  0x286(%rip),%xmm10
mov    0x3d8(%rsp),%rbx
add    $0x10,%rsp
xor    %eax,%eax
xor    %ecx,%ecx
movapd 0x29d(%rip),%xmm11
movsd  0x274(%rip),%xmm12
mov    0x408(%rsp),%rdx
mov    0x400(%rsp),%rsi
nopl   0x0(%rax)
movsd  0x220(%rsp,%rax,1),%xmm6
mulsd  %xmm10,%xmm6
movsd  %xmm6,0x220(%rsp,%rax,1)
movsd  0x1c0(%rsp,%rax,1),%xmm3
movhpd 0x200(%rsp,%rax,1),%xmm3
mulpd  %xmm11,%xmm3
movapd %xmm3,%xmm2
movhpd %xmm3,0x200(%rsp,%rax,1)
movsd  0x1e0(%rsp,%rax,1),%xmm1
mulsd  %xmm10,%xmm1
movsd  %xmm1,0x1e0(%rsp,%rax,1)
movlpd %xmm3,0x1c0(%rsp,%rax,1)
movsd  0x1a0(%rsp,%rax,1),%xmm9
mulsd  %xmm10,%xmm9
movsd  %xmm9,0x1a0(%rsp,%rax,1)
movsd  0x180(%rsp,%rax,1),%xmm8
mulsd  %xmm10,%xmm8
movsd  %xmm8,0x180(%rsp,%rax,1)
movsd  0x10(%rsp,%rax,1),%xmm4
mulsd  %xmm12,%xmm4
movsd  %xmm4,0x10(%rsp,%rax,1)
unpcklpd %xmm6,%xmm6
movsd  0xf0(%rsp,%rax,1),%xmm7
movhpd 0xd0(%rsp,%rax,1),%xmm7
addpd  %xmm6,%xmm7
movapd %xmm3,%xmm0
movsd  %xmm1,%xmm0
addpd  %xmm7,%xmm0
movapd %xmm3,%xmm7
unpcklpd %xmm1,%xmm7
addpd  %xmm0,%xmm7
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
addpd  %xmm0,%xmm7
movupd (%rsi,%rcx,8),%xmm5
addpd  %xmm7,%xmm5
movupd %xmm5,(%rsi,%rcx,8)
movsd  0x280(%rsp,%rax,1),%xmm5
movhpd 0xb0(%rsp,%rax,1),%xmm5
unpckhpd %xmm3,%xmm2
addpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm9,%xmm6
unpcklpd %xmm9,%xmm6
addpd  %xmm5,%xmm6
addpd  %xmm0,%xmm6
movupd (%rdx,%rcx,8),%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,(%rdx,%rcx,8)
movsd  0x240(%rsp,%rax,1),%xmm0
addsd  %xmm3,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
addsd  %xmm4,%xmm0
addsd  -0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rcx,8)
movsd  0x70(%rsp,%rax,1),%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
addsd  %xmm4,%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
addsd  0x90(%rsp,%rax,1),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm4,%xmm2
addsd  0x0(%rbp,%rcx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
addsd  0x260(%rsp,%rax,1),%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm8,%xmm1
addsd  %xmm4,%xmm1
addsd  -0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rcx,8)
add    %rbx,%rcx
add    $0x8,%rax
cmp    $0x18,%rax
jne    1db0 <dJacTx3D+0xca0>
mov    0x3f0(%rsp),%rcx
add    $0x1,%rcx
mov    0x3d0(%rsp),%rax
add    %rax,%r12
add    %rax,%r15
add    %rax,%r14
mov    0x3f8(%rsp),%rdi
add    %rax,%rdi
add    %rax,%rsi
add    %rax,%rdx
add    %rax,%r13
add    %rax,%rbp
cmp    0x3d8(%rsp),%rcx
movsd  0x47(%rip),%xmm11
jne    13f0 <dJacTx3D+0x2e0>
jmp    1330 <dJacTx3D+0x220>
add    $0x4c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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