#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*/ d2SdiagTetra(double *, double *, double *, double *,
                                double const, double const, double *, double *,
                                double *, double *, double *, double *,
                                double *, double *, double, double const,
                                double const);
void d2S3Ddiag(double *prod, const double *yc, const double *ARef,
               const double *VRef, const double *alpha, const double *h,
               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];
  int id, i1, i2, i3, r, comp, idn;
  const double hd = h[0] * h[1] * h[2];
  const double alphaLength = alpha[0] * hd;
  const double alphaArea = alpha[1] * hd;
  const double alphaVolume = alpha[2] * hd;
  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, yA, yB, yC, yD, yE, yF, yG, yH,  \
    yABDC, yBDHF, yABFE, yCAEG, yDCGH, yEFHG, yM, rA, rB, rC, rD, rE, rF, rG,  \
    rH)
  for (i1 = 0; i1 < m1; i1++) {
    for (i2 = 0; i2 < m2; i2++) {
      for (i3 = 0; i3 < m3; i3++) {
        idn = i1 + i2 * inc_y + i3 * inc_z;
        comp = 0;
        for (r = 0; r < 3; r++) {
          rptr = yc + idn + comp;
          yA[r] = *rptr;
          rptr += inc_x;
          yB[r] = *rptr;
          rptr += inc_y;
          yD[r] = *rptr;
          rptr -= inc_x;
          yC[r] = *rptr;
          rptr += inc_z;
          yG[r] = *rptr;
          rptr += inc_x;
          yH[r] = *rptr;
          rptr -= inc_y;
          yF[r] = *rptr;
          rptr -= inc_x;
          yE[r] = *rptr;
          yABDC[r] = 0.25 * (yA[r] + yB[r] + yD[r] + yC[r]);
          yBDHF[r] = 0.25 * (yB[r] + yD[r] + yH[r] + yF[r]);
          yABFE[r] = 0.25 * (yA[r] + yB[r] + yF[r] + yE[r]);
          yCAEG[r] = 0.25 * (yC[r] + yA[r] + yE[r] + yG[r]);
          yDCGH[r] = 0.25 * (yD[r] + yC[r] + yG[r] + yH[r]);
          yEFHG[r] = 0.25 * (yE[r] + yF[r] + yH[r] + yG[r]);
          yM[r] = 0.5 * (yABDC[r] + yEFHG[r]);
          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;
        }
        if ((alphaArea > 0) || (alphaVolume > 0)) {
          d2SdiagTetra(yA, yB, yABDC, yM, ARef[0], VRef[0], rA, rB, rD, rC, rE,
                       rF, rH, rG, -1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yB, yD, yABDC, yM, ARef[1], VRef[1], rB, rD, rC, rA, rF,
                       rH, rG, rE, -1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yD, yC, yABDC, yM, ARef[2], VRef[2], rD, rC, rA, rB, rH,
                       rG, rE, rF, -1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yC, yA, yABDC, yM, ARef[3], VRef[3], rC, rA, rB, rD, rG,
                       rE, rF, rH, -1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yB, yD, yBDHF, yM, ARef[4], VRef[4], rB, rD, rH, rF, rA,
                       rC, rG, rE, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yD, yH, yBDHF, yM, ARef[5], VRef[5], rD, rH, rF, rB, rC,
                       rG, rE, rA, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yH, yF, yBDHF, yM, ARef[6], VRef[6], rH, rF, rB, rD, rG,
                       rE, rA, rC, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yF, yB, yBDHF, yM, ARef[7], VRef[7], rF, rB, rD, rH, rE,
                       rA, rC, rG, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yA, yB, yABFE, yM, ARef[8], VRef[8], rA, rB, rF, rE, rC,
                       rD, rH, rG, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yB, yF, yABFE, yM, ARef[9], VRef[9], rB, rF, rE, rA, rD,
                       rH, rG, rC, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yF, yE, yABFE, yM, ARef[10], VRef[10], rF, rE, rA, rB,
                       rH, rG, rC, rD, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yE, yA, yABFE, yM, ARef[11], VRef[11], rE, rA, rB, rF,
                       rG, rC, rD, rH, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yC, yA, yCAEG, yM, ARef[12], VRef[12], rC, rA, rE, rG,
                       rD, rB, rF, rH, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yA, yE, yCAEG, yM, ARef[13], VRef[13], rA, rE, rG, rC,
                       rB, rF, rH, rD, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yE, yG, yCAEG, yM, ARef[14], VRef[14], rE, rG, rC, rA,
                       rF, rH, rD, rB, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yG, yC, yCAEG, yM, ARef[15], VRef[15], rG, rC, rA, rE,
                       rH, rD, rB, rF, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yD, yC, yDCGH, yM, ARef[16], VRef[16], rD, rC, rG, rH,
                       rB, rA, rE, rF, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yC, yG, yDCGH, yM, ARef[17], VRef[17], rC, rG, rH, rD,
                       rA, rE, rF, rB, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yG, yH, yDCGH, yM, ARef[18], VRef[18], rG, rH, rD, rC,
                       rE, rF, rB, rA, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yH, yD, yDCGH, yM, ARef[19], VRef[19], rH, rD, rC, rG,
                       rF, rB, rA, rE, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yE, yF, yEFHG, yM, ARef[20], VRef[20], rE, rF, rH, rG,
                       rA, rB, rD, rC, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yF, yH, yEFHG, yM, ARef[21], VRef[21], rF, rH, rG, rE,
                       rB, rD, rC, rA, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yH, yG, yEFHG, yM, ARef[22], VRef[22], rH, rG, rE, rF,
                       rD, rC, rA, rB, 1.0, alphaArea, alphaVolume);
          d2SdiagTetra(yG, yE, yEFHG, yM, ARef[23], VRef[23], rG, rE, rF, rH,
                       rC, rA, rB, rD, 1.0, alphaArea, alphaVolume);
        }
        comp = 0;
        for (r = 0; r < 3; r++) {
          wptr = prod + idn + comp;
#pragma omp atomic
          *wptr += rA[r];
          wptr += inc_x;
#pragma omp atomic
          *wptr += rB[r];
          wptr += inc_y;
#pragma omp atomic
          *wptr += rD[r];
          wptr -= inc_x;
#pragma omp atomic
          *wptr += rC[r];
          wptr += inc_z;
#pragma omp atomic
          *wptr += rG[r];
          wptr += inc_x;
#pragma omp atomic
          *wptr += rH[r];
          wptr -= inc_y;
#pragma omp atomic
          *wptr += rF[r];
          wptr -= inc_x;
#pragma omp atomic
          *wptr += rE[r];
          comp += nn;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<d2S3Ddiag>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x3a8,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    0x10(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
cvttsd2si 0x8(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    0x10(%rbp),%rax
cvttsd2si 0x10(%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x358(%rbp),%xmm0
ff
movsd  %xmm0,-0x360(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x358(%rbp),%xmm0
ff
movsd  %xmm0,-0x368(%rbp)
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x358(%rbp),%xmm0
ff
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x374(%rbp)
movl   $0x1,-0x378(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x37c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x380(%rbp)
movl   $0x0,-0x338(%rbp)
mov    -0x338(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    2907 <d2S3Ddiag+0x17f7>
movl   $0x0,-0x33c(%rbp)
mov    -0x33c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    28ee <d2S3Ddiag+0x17de>
movl   $0x0,-0x340(%rbp)
mov    -0x340(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    28d5 <d2S3Ddiag+0x17c5>
mov    -0x338(%rbp),%eax
mov    -0x33c(%rbp),%ecx
imul   -0x37c(%rbp),%ecx
add    %ecx,%eax
mov    -0x340(%rbp),%ecx
imul   -0x380(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34c(%rbp)
movl   $0x0,-0x348(%rbp)
movl   $0x0,-0x344(%rbp)
cmpl   $0x3,-0x344(%rbp)
jge    1769 <d2S3Ddiag+0x659>
mov    -0x28(%rbp),%rax
movslq -0x34c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x348(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x388(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x37c(%rbp),%ecx
mov    -0x388(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0xd0(%rbp,%rax,8)
ff ff
mov    -0x388(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x380(%rbp),%ecx
mov    -0x388(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x388(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x37c(%rbp),%ecx
mov    -0x388(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x110(%rbp,%rax,8)
ff ff
mov    -0x388(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
movsd  (%rax),%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x344(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b83(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1b27(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x190(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x344(%rbp),%rax
addsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1ace(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x70(%rbp,%rax,8),%xmm1
movslq -0x344(%rbp),%rax
addsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a75(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a19(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movsd  0x19bd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
movsd  -0x170(%rbp,%rax,8),%xmm1
ff ff
movslq -0x344(%rbp),%rax
addsd  -0x210(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1979(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0x344(%rbp),%rax
movsd  %xmm0,-0x230(%rbp,%rax,8)
ff ff
mov    -0x374(%rbp),%eax
add    -0x348(%rbp),%eax
mov    %eax,-0x348(%rbp)
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x270(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2f0(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x310(%rbp,%rax,8)
ff ff
movslq -0x344(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x330(%rbp,%rax,8)
ff ff
mov    -0x344(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x344(%rbp)
jmp    12a0 <d2S3Ddiag+0x190>
movsd  -0x368(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     1793 <d2S3Ddiag+0x683>
movsd  -0x370(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    26af <d2S3Ddiag+0x159f>
lea    -0x70(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
lea    -0x250(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x2b0(%rbp),%r15
lea    -0x290(%rbp),%r14
lea    -0x2d0(%rbp),%rbx
lea    -0x2f0(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x310(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x17fc(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x90(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm1
lea    -0x270(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x290(%rbp),%r15
lea    -0x250(%rbp),%r14
lea    -0x2f0(%rbp),%rbx
lea    -0x330(%rbp),%r11
lea    -0x310(%rbp),%r10
lea    -0x2d0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x175c(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xd0(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm1
lea    -0x2b0(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x250(%rbp),%r15
lea    -0x270(%rbp),%r14
lea    -0x330(%rbp),%rbx
lea    -0x310(%rbp),%r11
lea    -0x2d0(%rbp),%r10
lea    -0x2f0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x16bc(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm1
lea    -0x290(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x270(%rbp),%r15
lea    -0x2b0(%rbp),%r14
lea    -0x310(%rbp),%rbx
lea    -0x2d0(%rbp),%r11
lea    -0x2f0(%rbp),%r10
lea    -0x330(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x161f(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x90(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x20(%rax),%xmm1
lea    -0x270(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x330(%rbp),%r15
lea    -0x2f0(%rbp),%r14
lea    -0x250(%rbp),%rbx
lea    -0x290(%rbp),%r11
lea    -0x310(%rbp),%r10
lea    -0x2d0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x1577(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xd0(%rbp),%rdi
lea    -0x150(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x28(%rax),%xmm1
lea    -0x2b0(%rbp),%r8
lea    -0x330(%rbp),%r9
lea    -0x2f0(%rbp),%r15
lea    -0x270(%rbp),%r14
lea    -0x290(%rbp),%rbx
lea    -0x310(%rbp),%r11
lea    -0x2d0(%rbp),%r10
lea    -0x250(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x14d7(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x150(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x30(%rax),%xmm1
lea    -0x330(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x270(%rbp),%r15
lea    -0x2b0(%rbp),%r14
lea    -0x310(%rbp),%rbx
lea    -0x2d0(%rbp),%r11
lea    -0x250(%rbp),%r10
lea    -0x290(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x1437(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x110(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x190(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x38(%rax),%xmm1
lea    -0x2f0(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x2b0(%rbp),%r15
lea    -0x330(%rbp),%r14
lea    -0x2d0(%rbp),%rbx
lea    -0x250(%rbp),%r11
lea    -0x290(%rbp),%r10
lea    -0x310(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x1397(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x70(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x40(%rax),%xmm1
lea    -0x250(%rbp),%r8
lea    -0x270(%rbp),%r9
lea    -0x2f0(%rbp),%r15
lea    -0x2d0(%rbp),%r14
lea    -0x290(%rbp),%rbx
lea    -0x2b0(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x310(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x12fa(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x90(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x48(%rax),%xmm1
lea    -0x270(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x2d0(%rbp),%r15
lea    -0x250(%rbp),%r14
lea    -0x2b0(%rbp),%rbx
lea    -0x330(%rbp),%r11
lea    -0x310(%rbp),%r10
lea    -0x290(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x125a(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x110(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x50(%rax),%xmm1
lea    -0x2f0(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x250(%rbp),%r15
lea    -0x270(%rbp),%r14
lea    -0x330(%rbp),%rbx
lea    -0x310(%rbp),%r11
lea    -0x290(%rbp),%r10
lea    -0x2b0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x11ba(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x1b0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x58(%rax),%xmm1
lea    -0x2d0(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x270(%rbp),%r15
lea    -0x2f0(%rbp),%r14
lea    -0x310(%rbp),%rbx
lea    -0x290(%rbp),%r11
lea    -0x2b0(%rbp),%r10
lea    -0x330(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x111d(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x60(%rax),%xmm1
lea    -0x290(%rbp),%r8
lea    -0x250(%rbp),%r9
lea    -0x2d0(%rbp),%r15
lea    -0x310(%rbp),%r14
lea    -0x2b0(%rbp),%rbx
lea    -0x270(%rbp),%r11
lea    -0x2f0(%rbp),%r10
lea    -0x330(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x1080(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x70(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x68(%rax),%xmm1
lea    -0x250(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x310(%rbp),%r15
lea    -0x290(%rbp),%r14
lea    -0x270(%rbp),%rbx
lea    -0x2f0(%rbp),%r11
lea    -0x330(%rbp),%r10
lea    -0x2b0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xfe3(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x70(%rax),%xmm1
lea    -0x2d0(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x290(%rbp),%r15
lea    -0x250(%rbp),%r14
lea    -0x2f0(%rbp),%rbx
lea    -0x330(%rbp),%r11
lea    -0x2b0(%rbp),%r10
lea    -0x270(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xf43(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x130(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x1d0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x78(%rax),%xmm1
lea    -0x310(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x250(%rbp),%r15
lea    -0x2d0(%rbp),%r14
lea    -0x330(%rbp),%rbx
lea    -0x2b0(%rbp),%r11
lea    -0x270(%rbp),%r10
lea    -0x2f0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xea3(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xd0(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x80(%rax),%xmm1
lea    -0x2b0(%rbp),%r8
lea    -0x290(%rbp),%r9
lea    -0x310(%rbp),%r15
lea    -0x330(%rbp),%r14
lea    -0x270(%rbp),%rbx
lea    -0x250(%rbp),%r11
lea    -0x2d0(%rbp),%r10
lea    -0x2f0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xdfd(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xb0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x88(%rax),%xmm1
lea    -0x290(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x330(%rbp),%r15
lea    -0x2b0(%rbp),%r14
lea    -0x250(%rbp),%rbx
lea    -0x2d0(%rbp),%r11
lea    -0x2f0(%rbp),%r10
lea    -0x270(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xd57(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x130(%rbp),%rdi
lea    -0x150(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x90(%rax),%xmm1
lea    -0x310(%rbp),%r8
lea    -0x330(%rbp),%r9
lea    -0x2b0(%rbp),%r15
lea    -0x290(%rbp),%r14
lea    -0x2d0(%rbp),%rbx
lea    -0x2f0(%rbp),%r11
lea    -0x270(%rbp),%r10
lea    -0x250(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xcb1(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x150(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x1f0(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0x98(%rax),%xmm1
lea    -0x330(%rbp),%r8
lea    -0x2b0(%rbp),%r9
lea    -0x290(%rbp),%r15
lea    -0x310(%rbp),%r14
lea    -0x2f0(%rbp),%rbx
lea    -0x270(%rbp),%r11
lea    -0x250(%rbp),%r10
lea    -0x2d0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xc0b(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0xf0(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x210(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0xa0(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0xa0(%rax),%xmm1
lea    -0x2d0(%rbp),%r8
lea    -0x2f0(%rbp),%r9
lea    -0x330(%rbp),%r15
lea    -0x310(%rbp),%r14
lea    -0x250(%rbp),%rbx
lea    -0x270(%rbp),%r11
lea    -0x2b0(%rbp),%r10
lea    -0x290(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xb65(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x110(%rbp),%rdi
lea    -0x150(%rbp),%rsi
lea    -0x210(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0xa8(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0xa8(%rax),%xmm1
lea    -0x2f0(%rbp),%r8
lea    -0x330(%rbp),%r9
lea    -0x310(%rbp),%r15
lea    -0x2d0(%rbp),%r14
lea    -0x270(%rbp),%rbx
lea    -0x2b0(%rbp),%r11
lea    -0x290(%rbp),%r10
lea    -0x250(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xabf(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x150(%rbp),%rdi
lea    -0x130(%rbp),%rsi
lea    -0x210(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0xb0(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0xb0(%rax),%xmm1
lea    -0x330(%rbp),%r8
lea    -0x310(%rbp),%r9
lea    -0x2d0(%rbp),%r15
lea    -0x2f0(%rbp),%r14
lea    -0x2b0(%rbp),%rbx
lea    -0x290(%rbp),%r11
lea    -0x250(%rbp),%r10
lea    -0x270(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0xa19(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
lea    -0x130(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
lea    -0x210(%rbp),%rdx
lea    -0x230(%rbp),%rcx
mov    -0x30(%rbp),%rax
movsd  0xb8(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  0xb8(%rax),%xmm1
lea    -0x310(%rbp),%r8
lea    -0x2d0(%rbp),%r9
lea    -0x2f0(%rbp),%r15
lea    -0x330(%rbp),%r14
lea    -0x290(%rbp),%rbx
lea    -0x250(%rbp),%r11
lea    -0x270(%rbp),%r10
lea    -0x2b0(%rbp),%rax
movsd  -0x368(%rbp),%xmm3
ff
movsd  -0x370(%rbp),%xmm4
ff
movsd  0x973(%rip),%xmm2
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <d2SdiagTetra@plt>
movl   $0x0,-0x348(%rbp)
movl   $0x0,-0x344(%rbp)
cmpl   $0x3,-0x344(%rbp)
jge    28bc <d2S3Ddiag+0x17ac>
mov    -0x20(%rbp),%rax
movslq -0x34c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x348(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x390(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x270(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x37c(%rbp),%ecx
mov    -0x390(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x390(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x380(%rbp),%ecx
mov    -0x390(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x310(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x390(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x330(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x37c(%rbp),%ecx
mov    -0x390(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x2f0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x390(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x390(%rbp)
movslq -0x344(%rbp),%rax
movsd  -0x2d0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x390(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x374(%rbp),%eax
add    -0x348(%rbp),%eax
mov    %eax,-0x348(%rbp)
mov    -0x344(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x344(%rbp)
jmp    26c3 <d2S3Ddiag+0x15b3>
jmp    28c1 <d2S3Ddiag+0x17b1>
mov    -0x340(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x340(%rbp)
jmp    1253 <d2S3Ddiag+0x143>
jmp    28da <d2S3Ddiag+0x17ca>
mov    -0x33c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33c(%rbp)
jmp    123a <d2S3Ddiag+0x12a>
jmp    28f3 <d2S3Ddiag+0x17e3>
mov    -0x338(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x338(%rbp)
jmp    1221 <d2S3Ddiag+0x111>
add    $0x3a8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<d2S3Ddiag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3c8,%rsp
mov    %rcx,0x138(%rsp)
mov    %rdx,0x140(%rsp)
mov    %rsi,0x148(%rsp)
mov    0x400(%rsp),%rcx
cvttsd2si (%rcx),%eax
test   %eax,%eax
jle    25ba <d2S3Ddiag+0x14aa>
cvttsd2si 0x8(%rcx),%ebp
cvttsd2si 0x10(%rcx),%r11d
movsd  (%r9),%xmm1
mulsd  0x8(%r9),%xmm1
mulsd  0x10(%r9),%xmm1
movsd  0x8(%r8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x10(%r8),%xmm1
lea    0x1(%rax),%ecx
lea    0x1(%rbp),%edx
imul   %ecx,%edx
lea    0x1(%r11),%esi
imul   %edx,%esi
mov    %ecx,%r8d
mov    %r8,%r9
neg    %r9
xorpd  %xmm0,%xmm0
movsd  %xmm2,0x8(%rsp)
ucomisd %xmm0,%xmm2
seta   %cl
movsd  %xmm1,0x10(%rsp)
ucomisd %xmm0,%xmm1
movslq %edx,%rdx
seta   %r10b
or     %cl,%r10b
movslq %esi,%rbx
mov    %eax,%eax
mov    %rax,0x298(%rsp)
mov    %rbp,0x2a0(%rsp)
mov    %ebp,%eax
mov    %rax,0x2b0(%rsp)
mov    %r11,0x2b8(%rsp)
mov    %r11d,%esi
lea    (%rbx,%rbx,1),%r11
lea    0x0(,%r8,8),%rax
mov    %rax,0x2a8(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x2f8(%rsp)
mov    0x148(%rsp),%rcx
lea    (%rcx,%r8,8),%rax
mov    %rax,0x170(%rsp)
lea    (%rdx,%r8,1),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x168(%rsp)
xorps  %xmm13,%xmm13
movsd  0x1dca(%rip),%xmm14
movsd  0x1dc9(%rip),%xmm15
lea    (%rcx,%rdx,8),%rax
mov    %rax,0x160(%rsp)
xor    %eax,%eax
mov    %rax,0x150(%rsp)
mov    %rdi,0x2f0(%rsp)
mov    %r8,0x2e8(%rsp)
mov    %r9,0x2e0(%rsp)
mov    %rdx,0x2d8(%rsp)
mov    %r10b,0x1f(%rsp)
mov    %rsi,0x2d0(%rsp)
mov    %r11,0x2c8(%rsp)
mov    %rbx,0x2c0(%rsp)
jmp    12e9 <d2S3Ddiag+0x1d9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x150(%rsp),%rcx
add    $0x1,%rcx
addq   $0x8,0x148(%rsp)
addq   $0x8,0x170(%rsp)
addq   $0x8,0x168(%rsp)
addq   $0x8,0x160(%rsp)
mov    %rcx,%rax
mov    %rcx,0x150(%rsp)
cmp    0x298(%rsp),%rcx
je     25ba <d2S3Ddiag+0x14aa>
cmpl   $0x0,0x2a0(%rsp)
jle    12a0 <d2S3Ddiag+0x190>
mov    0x160(%rsp),%rax
mov    %rax,0x190(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x188(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x180(%rsp)
mov    0x148(%rsp),%rax
mov    %rax,0x178(%rsp)
xor    %eax,%eax
mov    %rax,0x158(%rsp)
jmp    138d <d2S3Ddiag+0x27d>
nop
mov    0x158(%rsp),%rcx
add    $0x1,%rcx
mov    0x2a8(%rsp),%rax
add    %rax,0x178(%rsp)
add    %rax,0x180(%rsp)
add    %rax,0x188(%rsp)
add    %rax,0x190(%rsp)
mov    %rcx,%rax
mov    %rcx,0x158(%rsp)
cmp    0x2b0(%rsp),%rcx
je     12a0 <d2S3Ddiag+0x190>
cmpl   $0x0,0x2b8(%rsp)
jle    1340 <d2S3Ddiag+0x230>
mov    0x158(%rsp),%rax
imul   %r8,%rax
add    0x150(%rsp),%rax
mov    %rax,0x300(%rsp)
mov    0x190(%rsp),%r15
mov    0x188(%rsp),%r14
mov    0x180(%rsp),%r13
mov    0x178(%rsp),%rbp
xor    %eax,%eax
jmp    2375 <d2S3Ddiag+0x1265>
nopw   0x0(%rax,%rax,1)
mov    0x140(%rsp),%r12
movsd  (%r12),%xmm0
mov    %r12,%rbx
mov    0x138(%rsp),%rax
movsd  (%rax),%xmm1
lea    0x280(%rsp),%rdi
lea    0x260(%rsp),%rsi
lea    0x3b0(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x100(%rsp),%r8
lea    0xe0(%rsp),%r9
movsd  0x1bdb(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x40(%rsp),%rax
push   %rax
lea    0x28(%rsp),%rax
push   %rax
lea    0x70(%rsp),%rax
push   %rax
lea    0x98(%rsp),%rax
push   %rax
lea    0xe0(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x8(%r12),%xmm0
mov    0x138(%rsp),%r12
movsd  0x8(%r12),%xmm1
lea    0x260(%rsp),%rdi
lea    0x220(%rsp),%rsi
lea    0x3b0(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xe0(%rsp),%r8
lea    0xa0(%rsp),%r9
movsd  0x1b4b(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x80(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
lea    0x30(%rsp),%rax
push   %rax
lea    0x78(%rsp),%rax
push   %rax
lea    0x120(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x10(%rbx),%xmm0
movsd  0x10(%r12),%xmm1
lea    0x220(%rsp),%rdi
lea    0x240(%rsp),%rsi
lea    0x3b0(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xa0(%rsp),%r8
lea    0xc0(%rsp),%r9
movsd  0x1ac5(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x60(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
lea    0x50(%rsp),%rax
push   %rax
lea    0x38(%rsp),%rax
push   %rax
lea    0x100(%rsp),%rax
push   %rax
lea    0x128(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x18(%rbx),%xmm0
movsd  0x18(%r12),%xmm1
lea    0x240(%rsp),%rdi
lea    0x280(%rsp),%rsi
lea    0x3b0(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xc0(%rsp),%r8
lea    0x100(%rsp),%r9
movsd  0x1a3f(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x20(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
lea    0x90(%rsp),%rax
push   %rax
lea    0x58(%rsp),%rax
push   %rax
lea    0xc0(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x20(%rbx),%xmm0
movsd  0x20(%r12),%xmm1
lea    0x260(%rsp),%rdi
lea    0x220(%rsp),%rsi
lea    0x390(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xe0(%rsp),%r8
lea    0xa0(%rsp),%r9
movsd  0x19c1(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x80(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
lea    0xd0(%rsp),%rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
lea    0x80(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x28(%rbx),%xmm0
movsd  0x28(%r12),%xmm1
lea    0x220(%rsp),%rdi
lea    0x1a0(%rsp),%rsi
lea    0x390(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xa0(%rsp),%r8
lea    0x20(%rsp),%r9
movsd  0x193b(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x100(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
lea    0x50(%rsp),%rax
push   %rax
lea    0xd8(%rsp),%rax
push   %rax
lea    0x100(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x30(%rbx),%xmm0
movsd  0x30(%r12),%xmm1
mov    %r12,%rbx
lea    0x1a0(%rsp),%rdi
lea    0x1e0(%rsp),%rsi
lea    0x390(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x20(%rsp),%r8
lea    0x60(%rsp),%r9
movsd  0x18b2(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xc0(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
lea    0x90(%rsp),%rax
push   %rax
lea    0x58(%rsp),%rax
push   %rax
lea    0xc0(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
mov    0x140(%rsp),%r12
movsd  0x38(%r12),%xmm0
movsd  0x38(%rbx),%xmm1
lea    0x1e0(%rsp),%rdi
lea    0x260(%rsp),%rsi
lea    0x390(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x60(%rsp),%r8
lea    0xe0(%rsp),%r9
movsd  0x1821(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x40(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
lea    0x110(%rsp),%rax
push   %rax
lea    0x98(%rsp),%rax
push   %rax
lea    0x40(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x40(%r12),%xmm0
mov    %r12,%rbx
mov    0x138(%rsp),%r12
movsd  0x40(%r12),%xmm1
lea    0x280(%rsp),%rdi
lea    0x260(%rsp),%rsi
lea    0x370(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x100(%rsp),%r8
lea    0xe0(%rsp),%r9
movsd  0x178b(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x40(%rsp),%rax
push   %rax
lea    0x28(%rsp),%rax
push   %rax
lea    0xb0(%rsp),%rax
push   %rax
lea    0xd8(%rsp),%rax
push   %rax
lea    0xa0(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x48(%rbx),%xmm0
movsd  0x48(%r12),%xmm1
mov    %r12,%rbx
lea    0x260(%rsp),%rdi
lea    0x1e0(%rsp),%rsi
lea    0x370(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xe0(%rsp),%r8
lea    0x60(%rsp),%r9
movsd  0x1702(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xc0(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
lea    0x30(%rsp),%rax
push   %rax
lea    0xb8(%rsp),%rax
push   %rax
lea    0x120(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
mov    0x140(%rsp),%r12
movsd  0x50(%r12),%xmm0
movsd  0x50(%rbx),%xmm1
lea    0x1e0(%rsp),%rdi
lea    0x200(%rsp),%rsi
lea    0x370(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x60(%rsp),%r8
lea    0x80(%rsp),%r9
movsd  0x1674(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xa0(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
lea    0x50(%rsp),%rax
push   %rax
lea    0x38(%rsp),%rax
push   %rax
lea    0x100(%rsp),%rax
push   %rax
lea    0x128(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x58(%r12),%xmm0
movsd  0x58(%rbx),%xmm1
lea    0x200(%rsp),%rdi
lea    0x280(%rsp),%rsi
lea    0x370(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x80(%rsp),%r8
lea    0x100(%rsp),%r9
movsd  0x15eb(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x20(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
lea    0xd0(%rsp),%rax
push   %rax
lea    0x58(%rsp),%rax
push   %rax
lea    0x80(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x60(%r12),%xmm0
movsd  0x60(%rbx),%xmm1
lea    0x240(%rsp),%rdi
lea    0x280(%rsp),%rsi
lea    0x350(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xc0(%rsp),%r8
lea    0x100(%rsp),%r9
movsd  0x1562(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x20(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
lea    0xf0(%rsp),%rax
push   %rax
lea    0xb8(%rsp),%rax
push   %rax
lea    0x60(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x68(%r12),%xmm0
mov    %r12,%rbx
mov    0x138(%rsp),%r12
movsd  0x68(%r12),%xmm1
lea    0x280(%rsp),%rdi
lea    0x200(%rsp),%rsi
lea    0x350(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x100(%rsp),%r8
lea    0x80(%rsp),%r9
movsd  0x14cf(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xa0(%rsp),%rax
push   %rax
lea    0x28(%rsp),%rax
push   %rax
lea    0x70(%rsp),%rax
push   %rax
lea    0xf8(%rsp),%rax
push   %rax
lea    0xe0(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x70(%rbx),%xmm0
movsd  0x70(%r12),%xmm1
lea    0x200(%rsp),%rdi
lea    0x1c0(%rsp),%rsi
lea    0x350(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x80(%rsp),%r8
lea    0x40(%rsp),%r9
movsd  0x144c(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xe0(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
lea    0x30(%rsp),%rax
push   %rax
lea    0x78(%rsp),%rax
push   %rax
lea    0x120(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x78(%rbx),%xmm0
movsd  0x78(%r12),%xmm1
lea    0x1c0(%rsp),%rdi
lea    0x240(%rsp),%rsi
lea    0x350(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x40(%rsp),%r8
lea    0xc0(%rsp),%r9
movsd  0x13c6(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x60(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
lea    0xb0(%rsp),%rax
push   %rax
lea    0x38(%rsp),%rax
push   %rax
lea    0xa0(%rsp),%rax
push   %rax
lea    0x128(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
mov    %rbx,%r12
movsd  0x80(%rbx),%xmm0
mov    0x138(%rsp),%rbx
movsd  0x80(%rbx),%xmm1
lea    0x220(%rsp),%rdi
lea    0x240(%rsp),%rsi
lea    0x330(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xa0(%rsp),%r8
lea    0xc0(%rsp),%r9
movsd  0x132e(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x60(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
lea    0x110(%rsp),%rax
push   %rax
lea    0xf8(%rsp),%rax
push   %rax
lea    0x40(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0x88(%r12),%xmm0
movsd  0x88(%rbx),%xmm1
lea    0x240(%rsp),%rdi
lea    0x1c0(%rsp),%rsi
lea    0x330(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0xc0(%rsp),%r8
lea    0x40(%rsp),%r9
movsd  0x12a5(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xe0(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
lea    0x90(%rsp),%rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
lea    0xc0(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
mov    0x140(%rsp),%rax
movsd  0x90(%rax),%xmm0
movsd  0x90(%rbx),%xmm1
lea    0x1c0(%rsp),%rdi
lea    0x1a0(%rsp),%rsi
lea    0x330(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x40(%rsp),%r8
lea    0x20(%rsp),%r9
movsd  0x1216(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x100(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
lea    0x70(%rsp),%rax
push   %rax
lea    0x98(%rsp),%rax
push   %rax
lea    0xe0(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
mov    0x140(%rsp),%r12
movsd  0x98(%r12),%xmm0
movsd  0x98(%rbx),%xmm1
lea    0x1a0(%rsp),%rdi
lea    0x220(%rsp),%rsi
lea    0x330(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x20(%rsp),%r8
lea    0xa0(%rsp),%r9
movsd  0x117f(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x80(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
lea    0xf0(%rsp),%rax
push   %rax
lea    0x78(%rsp),%rax
push   %rax
lea    0x60(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0xa0(%r12),%xmm0
mov    %r12,%rbx
mov    0x138(%rsp),%r12
movsd  0xa0(%r12),%xmm1
lea    0x200(%rsp),%rdi
lea    0x1e0(%rsp),%rsi
lea    0x310(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x80(%rsp),%r8
lea    0x60(%rsp),%r9
movsd  0x10e6(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xc0(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
lea    0xf0(%rsp),%rax
push   %rax
lea    0x118(%rsp),%rax
push   %rax
lea    0x60(%rsp),%rax
push   %rax
lea    0x48(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0xa8(%rbx),%xmm0
movsd  0xa8(%r12),%xmm1
lea    0x1e0(%rsp),%rdi
lea    0x1a0(%rsp),%rsi
lea    0x310(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x60(%rsp),%r8
lea    0x20(%rsp),%r9
movsd  0x105d(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0x100(%rsp),%rax
push   %rax
lea    0xc8(%rsp),%rax
push   %rax
lea    0xb0(%rsp),%rax
push   %rax
lea    0xf8(%rsp),%rax
push   %rax
lea    0xa0(%rsp),%rax
push   %rax
lea    0x68(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0xb0(%rbx),%xmm0
movsd  0xb0(%r12),%xmm1
lea    0x1a0(%rsp),%rdi
lea    0x1c0(%rsp),%rsi
lea    0x310(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x20(%rsp),%r8
lea    0x40(%rsp),%r9
movsd  0xfd1(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xe0(%rsp),%rax
push   %rax
lea    0x108(%rsp),%rax
push   %rax
lea    0xd0(%rsp),%rax
push   %rax
lea    0xb8(%rsp),%rax
push   %rax
lea    0x80(%rsp),%rax
push   %rax
lea    0xa8(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
add    $0x30,%rsp
movsd  0xb8(%rbx),%xmm0
movsd  0xb8(%r12),%xmm1
mov    0x2c0(%rsp),%rbx
lea    0x1c0(%rsp),%rdi
lea    0x200(%rsp),%rsi
lea    0x310(%rsp),%rdx
lea    0x120(%rsp),%rcx
lea    0x40(%rsp),%r8
lea    0x80(%rsp),%r9
movsd  0xf37(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
movsd  0x10(%rsp),%xmm4
lea    0xa0(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
lea    0x110(%rsp),%rax
push   %rax
lea    0xd8(%rsp),%rax
push   %rax
lea    0x40(%rsp),%rax
push   %rax
lea    0x88(%rsp),%rax
push   %rax
call   1030 <d2SdiagTetra@plt>
movsd  0xeda(%rip),%xmm15
movsd  0xec9(%rip),%xmm14
xorps  %xmm13,%xmm13
mov    0x2f8(%rsp),%r11
mov    0x300(%rsp),%rsi
mov    0x4f(%rsp),%r10b
mov    0x308(%rsp),%rdx
mov    0x310(%rsp),%r9
mov    0x318(%rsp),%r8
mov    0x320(%rsp),%rdi
add    $0x30,%rsp
movapd 0x100(%rsp),%xmm1
movapd 0xc0(%rsp),%xmm7
movapd 0x40(%rsp),%xmm5
movsd  0x60(%rsp),%xmm0
movsd  0x68(%rsp),%xmm12
movsd  0x80(%rsp),%xmm6
movsd  0x88(%rsp),%xmm11
movupd 0x108(%rsp),%xmm10
movupd 0xc8(%rsp),%xmm9
movsd  0x48(%rsp),%xmm4
movsd  0x28(%rsp),%xmm3
movsd  0x110(%rsp),%xmm8
movhpd 0xf0(%rsp),%xmm8
movhpd 0xa8(%rsp),%xmm9
movhpd 0xe8(%rsp),%xmm10
movhpd 0x20(%rsp),%xmm5
movhpd 0xa0(%rsp),%xmm7
movhpd 0xe0(%rsp),%xmm1
mov    0x198(%rsp),%rcx
lea    (%rdi,%rcx,8),%rax
movupd (%rdi,%rcx,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rcx,8)
lea    (%rax,%r8,8),%rcx
movupd (%rax,%r8,8),%xmm1
addpd  %xmm7,%xmm1
movupd %xmm1,(%rax,%r8,8)
movupd (%rcx,%rdx,8),%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,(%rcx,%rdx,8)
lea    (%rcx,%rdx,8),%rcx
addsd  0x8(%rcx,%r9,8),%xmm0
movsd  %xmm0,0x8(%rcx,%r9,8)
addsd  (%rcx,%r9,8),%xmm6
movsd  %xmm6,(%rcx,%r9,8)
lea    (%rax,%rbx,8),%rcx
movupd (%rax,%rbx,8),%xmm0
addpd  %xmm10,%xmm0
movupd %xmm0,(%rax,%rbx,8)
movupd (%rcx,%r8,8),%xmm0
addpd  %xmm9,%xmm0
movupd %xmm0,(%rcx,%r8,8)
lea    (%rcx,%r8,8),%rcx
addsd  (%rcx,%rdx,8),%xmm4
movsd  %xmm4,(%rcx,%rdx,8)
addsd  0x8(%rcx,%rdx,8),%xmm3
movsd  %xmm3,0x8(%rcx,%rdx,8)
lea    (%rcx,%rdx,8),%rcx
addsd  0x8(%rcx,%r9,8),%xmm12
movsd  %xmm12,0x8(%rcx,%r9,8)
addsd  (%rcx,%r9,8),%xmm11
movsd  %xmm11,(%rcx,%r9,8)
movupd (%rax,%r11,8),%xmm0
addpd  %xmm8,%xmm0
movupd %xmm0,(%rax,%r11,8)
lea    (%rax,%r11,8),%rax
movsd  0xd0(%rsp),%xmm0
movhpd 0xb0(%rsp),%xmm0
movupd (%rax,%r8,8),%xmm1
addpd  %xmm1,%xmm0
movupd %xmm0,(%rax,%r8,8)
lea    (%rax,%r8,8),%rax
movsd  0x50(%rsp),%xmm0
addsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x30(%rsp),%xmm0
addsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
lea    (%rax,%rdx,8),%rax
movsd  0x70(%rsp),%xmm0
addsd  0x8(%rax,%r9,8),%xmm0
movsd  %xmm0,0x8(%rax,%r9,8)
movsd  0x90(%rsp),%xmm0
addsd  (%rax,%r9,8),%xmm0
movsd  %xmm0,(%rax,%r9,8)
mov    0x308(%rsp),%rax
add    $0x1,%rax
mov    0x2f8(%rsp),%rcx
add    %rcx,%rbp
add    %rcx,%r13
add    %rcx,%r14
add    %rcx,%r15
cmp    %rsi,%rax
je     1340 <d2S3Ddiag+0x230>
mov    %rax,0x308(%rsp)
imul   %rdx,%rax
add    0x300(%rsp),%rax
mov    %rax,0x198(%rsp)
movaps %xmm13,0x100(%rsp)
movq   $0x0,0x110(%rsp)
movaps %xmm13,0xe0(%rsp)
movq   $0x0,0xf0(%rsp)
movaps %xmm13,0xc0(%rsp)
movq   $0x0,0xd0(%rsp)
movaps %xmm13,0xa0(%rsp)
movq   $0x0,0xb0(%rsp)
movaps %xmm13,0x80(%rsp)
movq   $0x0,0x90(%rsp)
movaps %xmm13,0x60(%rsp)
movq   $0x0,0x70(%rsp)
movaps %xmm13,0x40(%rsp)
movq   $0x0,0x50(%rsp)
movaps %xmm13,0x20(%rsp)
movq   $0x0,0x30(%rsp)
mov    $0x1,%eax
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  -0x8(%rbp,%rax,8),%xmm5
movsd  %xmm5,0x280(%rsp,%rcx,1)
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x260(%rsp,%rcx,1)
movsd  0x0(%r13,%rax,8),%xmm2
movsd  %xmm2,0x220(%rsp,%rcx,1)
movsd  -0x8(%r13,%rax,8),%xmm7
movsd  %xmm7,0x240(%rsp,%rcx,1)
movsd  -0x8(%r14,%rax,8),%xmm8
movsd  %xmm8,0x1c0(%rsp,%rcx,1)
movsd  (%r14,%rax,8),%xmm9
movsd  %xmm9,0x1a0(%rsp,%rcx,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x1e0(%rsp,%rcx,1)
movsd  -0x8(%r15,%rax,8),%xmm6
movsd  %xmm6,0x200(%rsp,%rcx,1)
movapd %xmm5,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm14,%xmm3
movsd  %xmm3,0x3b0(%rsp,%rcx,1)
addsd  %xmm2,%xmm1
addsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm14,%xmm1
movsd  %xmm1,0x390(%rsp,%rcx,1)
addsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm14,%xmm4
movsd  %xmm4,0x370(%rsp,%rcx,1)
addsd  %xmm7,%xmm5
addsd  %xmm6,%xmm5
addsd  %xmm8,%xmm5
mulsd  %xmm14,%xmm5
movsd  %xmm5,0x350(%rsp,%rcx,1)
addsd  %xmm7,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm9,%xmm2
mulsd  %xmm14,%xmm2
movsd  %xmm2,0x330(%rsp,%rcx,1)
addsd  %xmm6,%xmm0
addsd  %xmm9,%xmm0
addsd  %xmm8,%xmm0
mulsd  %xmm14,%xmm0
movsd  %xmm0,0x310(%rsp,%rcx,1)
addsd  %xmm3,%xmm0
mulsd  %xmm15,%xmm0
movsd  %xmm0,0x120(%rsp,%rcx,1)
add    %rbx,%rax
add    $0x8,%rcx
cmp    $0x18,%rcx
jne    2430 <d2S3Ddiag+0x1320>
test   %r10b,%r10b
jne    13e0 <d2S3Ddiag+0x2d0>
xorpd  %xmm8,%xmm8
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
xorpd  %xmm3,%xmm3
xorpd  %xmm4,%xmm4
xorpd  %xmm6,%xmm6
xorpd  %xmm0,%xmm0
xorpd  %xmm9,%xmm9
xorpd  %xmm10,%xmm10
xorpd  %xmm5,%xmm5
xorpd  %xmm7,%xmm7
xorpd  %xmm1,%xmm1
jmp    220c <d2S3Ddiag+0x10fc>
add    $0x3c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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