#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*/ cofactor3D(double *, double *, double *, double *, double *,
                              double);
double const d2phiarea(double);
double d2phicaley(double);
double const det3D(double *, double *, double *, double *);
int /*<<< orphan*/ vecminus(double *, double *, double *, int);
void d2SdiagTetra(double *y1, double *y2, double *yF, double *yM,
                  const double ARef, const double VRef, double *r1, double *r2,
                  double *r3, double *r4, double *r5, double *r6, double *r7,
                  double *r8, const double inv, double alphaArea,
                  double alphaVolume) {
  double dVx, vol, vol2, d2S, cof[9], x, A;
  double vy[3], wy[3];
  int i, j, k;
  vol = inv * det3D(y1, y2, yF, yM);
  cofactor3D(cof, y1, y2, yF, yM, 1.0);
  if (alphaArea > 0) {
    double vy[3], wy[3], cprod[3], dvA[3], dwA[3];
    vecminus(vy, y1, yF, 3);
    vecminus(wy, y2, yF, 3);
    cprod[0] = vy[1] * wy[2] - vy[2] * wy[1];
    cprod[1] = vy[0] * wy[2] - vy[2] * wy[0];
    cprod[2] = vy[0] * wy[1] - vy[1] * wy[0];
    A = cprod[0] * cprod[0] + cprod[1] * cprod[1] + cprod[2] * cprod[2];
    dvA[0] = 2.0 * (cprod[1] * wy[2] + cprod[2] * wy[1]);
    dvA[1] = 2.0 * (cprod[0] * wy[2] - cprod[2] * wy[0]);
    dvA[2] = 2.0 * (-cprod[0] * wy[1] - cprod[1] * wy[0]);
    dwA[0] = -2.0 * (cprod[1] * vy[2] + cprod[2] * vy[1]);
    dwA[1] = 2.0 * (-cprod[0] * vy[2] + cprod[2] * vy[0]);
    dwA[2] = 2.0 * (cprod[0] * vy[1] + cprod[1] * vy[0]);
    double dAx, d2A = d2phiarea(A / ARef) / (ARef * ARef);
    dAx = (dvA[0] * 0.75 + dwA[0] * (-0.25));
    r1[0] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[1] * 0.75 + dwA[1] * (-0.25));
    r1[1] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[2] * 0.75 + dwA[2] * (-0.25));
    r1[2] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[0] * (-0.25) + dwA[0] * 0.75);
    r2[0] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[1] * (-0.25) + dwA[1] * 0.75);
    r2[1] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[2] * (-0.25) + dwA[2] * 0.75);
    r2[2] += alphaArea * dAx * d2A * dAx;
    dAx = (dvA[0] * (-0.25) + dwA[0] * (-0.25));
    dAx = alphaArea * dAx * d2A * dAx;
    r3[0] += dAx;
    r4[0] += dAx;
    dAx = (dvA[1] * (-0.25) + dwA[1] * (-0.25));
    dAx = alphaArea * dAx * d2A * dAx;
    r3[1] += dAx;
    r4[1] += dAx;
    dAx = (dvA[2] * (-0.25) + dwA[2] * (-0.25));
    dAx = alphaArea * dAx * d2A * dAx;
    r3[2] += dAx;
    r4[2] += dAx;
  }
  if (alphaVolume > 0) {
    d2S = alphaVolume * d2phicaley(vol / VRef) / (VRef * VRef);
    dVx = cof[0] * (1 - 0.125) + cof[1] * (-0.125) + cof[2] * (0.25 - 0.125);
    r1[0] += dVx * d2S * dVx;
    dVx = cof[3] * (1.0 - 0.125) + cof[4] * (-0.125) + cof[5] * (0.25 - 0.125);
    r1[1] += dVx * d2S * dVx;
    dVx = cof[6] * (1.0 - 0.125) + cof[7] * (-0.125) + cof[8] * (0.25 - 0.125);
    r1[2] += dVx * d2S * dVx;
    dVx = cof[0] * (-0.125) + cof[1] * (1.0 - 0.125) + cof[2] * (0.25 - 0.125);
    r2[0] += dVx * d2S * dVx;
    dVx = cof[3] * (-0.125) + cof[4] * (1.0 - 0.125) + cof[5] * (0.25 - 0.125);
    r2[1] += dVx * d2S * dVx;
    dVx = cof[6] * (-0.125) + cof[7] * (1.0 - 0.125) + cof[8] * (0.25 - 0.125);
    r2[2] += dVx * d2S * dVx;
    dVx = cof[0] * (-0.125) + cof[1] * (-0.125) + cof[2] * (0.25 - 0.125);
    dVx = dVx * d2S * dVx;
    r3[0] += dVx;
    r4[0] += dVx;
    dVx = cof[3] * (-0.125) + cof[4] * (-0.125) + cof[5] * (0.25 - 0.125);
    dVx = dVx * d2S * dVx;
    r3[1] += dVx;
    r4[1] += dVx;
    dVx = cof[6] * (-0.125) + cof[7] * (-0.125) + cof[8] * (0.25 - 0.125);
    dVx = dVx * d2S * dVx;
    r3[2] += dVx;
    r4[2] += dVx;
    dVx = cof[0] * (-0.125) + cof[1] * (-0.125) + cof[2] * (-0.125);
    dVx = dVx * d2S * dVx;
    r5[0] += dVx;
    r6[0] += dVx;
    r7[0] += dVx;
    r8[0] += dVx;
    dVx = cof[3] * (-0.125) + cof[4] * (-0.125) + cof[5] * (-0.125);
    dVx = dVx * d2S * dVx;
    r5[1] += dVx;
    r6[1] += dVx;
    r7[1] += dVx;
    r8[1] += dVx;
    dVx = cof[6] * (-0.125) + cof[7] * (-0.125) + cof[8] * (-0.125);
    dVx = dVx * d2S * dVx;
    r5[2] += dVx;
    r6[2] += dVx;
    r7[2] += dVx;
    r8[2] += dVx;
  }
}


x86 assembly (clang, -O0):
<d2SdiagTetra>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1060 <det3D@plt>
movaps %xmm0,%xmm1
movsd  -0x1d8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
lea    -0xc0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%r8
movsd  0xe07(%rip),%xmm0
call   1070 <cofactor3D@plt>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1918 <d2SdiagTetra+0x7c8>
lea    -0x140(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    $0x3,%ecx
call   1040 <vecminus@plt>
lea    -0x160(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    $0x3,%ecx
call   1040 <vecminus@plt>
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  -0x158(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  -0x160(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0x160(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x178(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x170(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc89(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x170(%rbp),%xmm0
ff
mulsd  -0x160(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc36(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x158(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x160(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xbcc(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x170(%rbp),%xmm0
ff
mulsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb98(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x170(%rbp),%xmm0
ff
mulsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb3d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb01(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0x28(%rbp),%xmm0
call   1050 <d2phiarea@plt>
movsd  -0x28(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0xaad(%rip),%xmm1
mulsd  -0x1c0(%rbp),%xmm1
ff
movsd  0xaa5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x198(%rbp),%xmm0
ff
movsd  0xa4c(%rip),%xmm1
mulsd  -0x1b8(%rbp),%xmm1
ff
movsd  0xa44(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
movsd  0x9e9(%rip),%xmm1
mulsd  -0x1b0(%rbp),%xmm1
ff
movsd  0x9e1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x98e(%rip),%xmm1
mulsd  -0x1c0(%rbp),%xmm1
ff
movsd  0x976(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x198(%rbp),%xmm0
ff
movsd  0x92d(%rip),%xmm1
mulsd  -0x1b8(%rbp),%xmm1
ff
movsd  0x915(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
movsd  0x8ca(%rip),%xmm1
mulsd  -0x1b0(%rbp),%xmm1
ff
movsd  0x8b2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x85f(%rip),%xmm1
mulsd  -0x1c0(%rbp),%xmm1
ff
movsd  0x84f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
mulsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x198(%rbp),%xmm0
ff
movsd  0x7e2(%rip),%xmm1
mulsd  -0x1b8(%rbp),%xmm1
ff
movsd  0x7d2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
mulsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x190(%rbp),%xmm0
ff
movsd  0x761(%rip),%xmm1
mulsd  -0x1b0(%rbp),%xmm1
ff
movsd  0x751(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x1c8(%rbp),%xmm0
ff
mulsd  -0x1d0(%rbp),%xmm0
ff
mulsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f34 <d2SdiagTetra+0xde4>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
call   1030 <d2phicaley@plt>
movaps %xmm0,%xmm1
movsd  -0x1e0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x6b0(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  0x6b0(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0x690(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x648(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x648(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x628(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x5de(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  0x5de(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  0x5c1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x587(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  0x567(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0x557(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x51f(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x4ff(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x4ef(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x4b5(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  0x495(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  0x488(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x43e(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  0x42e(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0x41e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x3c3(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x3b3(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x3a3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x344(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  0x334(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  0x327(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x2c8(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  0x2b8(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0x2a0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x30(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x38(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x22b(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  0x21b(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x203(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x30(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x38(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  0x186(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  0x176(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  0x161(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x30(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x38(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<d2SdiagTetra>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movsd  %xmm4,0x20(%rsp)
movapd %xmm3,0x10(%rsp)
movsd  %xmm2,0x38(%rsp)
mov    %r9,%r14
mov    %r8,%r15
movsd  %xmm1,0x8(%rsp)
movsd  %xmm0,(%rsp)
mov    %rcx,%rbp
mov    %rdx,%r13
mov    %rsi,%r12
mov    %rdi,%rbx
call   1060 <det3D@plt>
movsd  %xmm0,0x30(%rsp)
lea    0x40(%rsp),%rdi
movsd  0xe58(%rip),%xmm0
mov    %rbx,%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
call   1070 <cofactor3D@plt>
xorpd  %xmm0,%xmm0
movapd 0x10(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    153b <d2SdiagTetra+0x3eb>
lea    0xf0(%rsp),%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    $0x3,%ecx
call   1040 <vecminus@plt>
lea    0xd0(%rsp),%rdi
mov    %r12,%rsi
mov    %r13,%rdx
mov    $0x3,%ecx
call   1040 <vecminus@plt>
movapd 0xf0(%rsp),%xmm10
movapd 0xd0(%rsp),%xmm12
movsd  0x100(%rsp),%xmm8
unpcklpd %xmm8,%xmm8
movapd %xmm12,%xmm0
mulpd  %xmm8,%xmm0
movsd  0xe0(%rsp),%xmm4
unpcklpd %xmm4,%xmm4
movapd %xmm10,%xmm2
mulpd  %xmm4,%xmm2
subpd  %xmm0,%xmm2
movapd %xmm10,%xmm9
unpckhpd %xmm10,%xmm9
movapd %xmm12,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm12,%xmm1
unpckhpd %xmm12,%xmm1
movapd %xmm10,%xmm6
mulsd  %xmm1,%xmm6
subsd  %xmm0,%xmm6
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm2,%xmm11
unpckhpd %xmm2,%xmm11
movapd %xmm11,%xmm7
mulsd  %xmm11,%xmm7
addsd  %xmm0,%xmm7
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm7,%xmm0
movapd 0xd8d(%rip),%xmm5
movapd %xmm6,%xmm7
xorpd  %xmm5,%xmm7
movapd %xmm6,%xmm3
unpcklpd %xmm7,%xmm3
movapd %xmm12,%xmm7
shufpd $0x1,%xmm12,%xmm7
mulpd  %xmm3,%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
addpd  %xmm4,%xmm4
movapd %xmm4,0xb0(%rsp)
xorpd  %xmm11,%xmm5
mulsd  %xmm2,%xmm12
mulsd  %xmm5,%xmm1
subsd  %xmm12,%xmm1
addsd  %xmm1,%xmm1
movapd %xmm1,0xc0(%rsp)
unpcklpd %xmm6,%xmm6
mulpd  %xmm10,%xmm6
unpcklpd %xmm2,%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm6,%xmm5
mulpd  0xd2b(%rip),%xmm5
movapd %xmm5,0x90(%rsp)
mulsd  %xmm10,%xmm2
mulsd  %xmm9,%xmm11
addsd  %xmm2,%xmm11
addsd  %xmm11,%xmm11
movapd %xmm11,0xa0(%rsp)
divsd  (%rsp),%xmm0
call   1050 <d2phiarea@plt>
movsd  (%rsp),%xmm1
mulsd  %xmm1,%xmm1
divsd  %xmm1,%xmm0
movapd 0xcf4(%rip),%xmm12
movapd 0x90(%rsp),%xmm15
movapd %xmm15,%xmm4
mulpd  %xmm12,%xmm4
movapd %xmm4,%xmm2
shufpd $0x1,%xmm4,%xmm2
movapd 0xb0(%rsp),%xmm13
movapd %xmm13,%xmm5
mulpd  0xcd0(%rip),%xmm5
addpd  %xmm2,%xmm5
movapd 0x10(%rsp),%xmm3
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm5,%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
mulpd  %xmm11,%xmm2
movupd (%r15),%xmm7
mulpd  %xmm5,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm2,(%r15)
movsd  0xc34(%rip),%xmm9
movapd 0xa0(%rsp),%xmm8
movapd %xmm8,%xmm10
mulsd  %xmm9,%xmm10
movsd  0xc20(%rip),%xmm5
movapd 0xc0(%rsp),%xmm14
movapd %xmm14,%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm10,%xmm2
movapd %xmm2,%xmm7
mulsd  %xmm3,%xmm7
mulsd  %xmm0,%xmm7
mulpd  %xmm13,%xmm12
mulsd  %xmm5,%xmm8
mulsd  %xmm9,%xmm14
addsd  %xmm14,%xmm8
movapd %xmm13,%xmm5
mulsd  %xmm9,%xmm5
unpckhpd %xmm13,%xmm13
mulsd  %xmm9,%xmm13
movapd %xmm8,%xmm6
mulsd  %xmm3,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm4,%xmm13
unpckhpd %xmm4,%xmm4
addsd  %xmm4,%xmm5
movapd %xmm5,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm2,%xmm7
movapd %xmm13,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
addsd  0x10(%r15),%xmm7
movsd  %xmm7,0x10(%r15)
movapd %xmm15,%xmm7
mulpd  0xbd4(%rip),%xmm7
shufpd $0x1,%xmm7,%xmm7
addpd  %xmm7,%xmm12
mulpd  %xmm12,%xmm1
mulpd  %xmm11,%xmm1
movupd (%r14),%xmm7
mulpd  %xmm12,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm1,(%r14)
mulsd  %xmm8,%xmm6
addsd  0x10(%r14),%xmm6
movsd  %xmm6,0x10(%r14)
mulsd  %xmm5,%xmm4
mov    0x140(%rsp),%rcx
movsd  (%rcx),%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,(%rcx)
mov    0x148(%rsp),%rax
addsd  (%rax),%xmm4
movapd %xmm14,%xmm1
addsd  %xmm10,%xmm1
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm4,(%rax)
mulsd  %xmm13,%xmm2
movsd  0x8(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rcx)
addsd  0x8(%rax),%xmm2
movsd  %xmm2,0x8(%rax)
mulsd  %xmm1,%xmm3
movsd  0x10(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rcx)
xorpd  %xmm0,%xmm0
addsd  0x10(%rax),%xmm3
movsd  %xmm3,0x10(%rax)
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    18a4 <d2SdiagTetra+0x754>
mov    0x168(%rsp),%r12
mov    0x160(%rsp),%r13
mov    0x158(%rsp),%rbx
mov    0x150(%rsp),%rbp
movsd  0x30(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
call   1030 <d2phicaley@plt>
movapd %xmm0,%xmm5
mulsd  0x20(%rsp),%xmm5
movsd  0x8(%rsp),%xmm0
mulsd  %xmm0,%xmm0
divsd  %xmm0,%xmm5
movsd  0x40(%rsp),%xmm12
movupd 0x48(%rsp),%xmm7
movsd  0x50(%rsp),%xmm9
movsd  0x58(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
movhpd 0x60(%rsp),%xmm7
movapd %xmm7,%xmm6
mulpd  0xaa4(%rip),%xmm6
movapd %xmm12,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm2,%xmm3
mulpd  0xa9f(%rip),%xmm3
addpd  %xmm6,%xmm3
movsd  0x68(%rsp),%xmm15
movapd %xmm9,%xmm8
unpcklpd %xmm15,%xmm8
mulpd  0xa91(%rip),%xmm8
addpd  %xmm8,%xmm3
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
movupd (%r15),%xmm1
mulpd  %xmm3,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,(%r15)
movsd  0x70(%rsp),%xmm10
movsd  0x78(%rsp),%xmm3
movapd %xmm3,%xmm4
mulsd  0x9d9(%rip),%xmm4
movsd  %xmm4,0x10(%rsp)
movapd %xmm10,%xmm13
mulsd  0x9cd(%rip),%xmm13
addsd  %xmm4,%xmm13
movsd  0x80(%rsp),%xmm14
movsd  0x9be(%rip),%xmm4
movapd %xmm14,%xmm11
mulsd  %xmm4,%xmm11
addsd  %xmm11,%xmm13
movapd %xmm5,%xmm1
mulsd  %xmm13,%xmm1
mulsd  %xmm13,%xmm1
addsd  0x10(%r15),%xmm1
movsd  %xmm1,0x10(%r15)
mulpd  0x9e5(%rip),%xmm7
mulpd  0x9cd(%rip),%xmm2
addpd  %xmm7,%xmm2
addpd  %xmm8,%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm0
movupd (%r14),%xmm1
addpd  %xmm1,%xmm0
movupd %xmm0,(%r14)
mulsd  0x956(%rip),%xmm3
movsd  0x946(%rip),%xmm1
mulsd  %xmm1,%xmm10
addsd  %xmm10,%xmm3
addsd  %xmm11,%xmm3
movapd %xmm5,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  0x10(%r14),%xmm0
movsd  %xmm0,0x10(%r14)
mulsd  %xmm1,%xmm12
movapd %xmm1,%xmm3
addsd  %xmm6,%xmm12
movapd %xmm9,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm12,%xmm0
movapd %xmm5,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mov    0x140(%rsp),%rcx
movsd  (%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx)
mov    0x148(%rsp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
unpckhpd %xmm6,%xmm6
movapd 0x20(%rsp),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm6,%xmm2
mulsd  %xmm15,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm5,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movsd  0x8(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rcx)
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
addsd  0x10(%rsp),%xmm10
addsd  %xmm10,%xmm11
movapd %xmm5,%xmm0
mulsd  %xmm11,%xmm0
mulsd  %xmm11,%xmm0
movsd  0x10(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rcx)
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
mulsd  %xmm3,%xmm9
addsd  %xmm12,%xmm9
movapd %xmm5,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm9,%xmm0
movsd  0x0(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  (%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movsd  0x0(%r13),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
addsd  (%r12),%xmm0
movsd  %xmm0,(%r12)
mulsd  %xmm3,%xmm15
addsd  %xmm2,%xmm15
movapd %xmm5,%xmm0
mulsd  %xmm15,%xmm0
mulsd  %xmm15,%xmm0
movsd  0x8(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp)
movsd  0x8(%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx)
movsd  0x8(%r13),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13)
addsd  0x8(%r12),%xmm0
movsd  %xmm0,0x8(%r12)
mulsd  %xmm3,%xmm14
addsd  %xmm10,%xmm14
mulsd  %xmm14,%xmm5
mulsd  %xmm14,%xmm5
movsd  0x10(%rbp),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x10(%rbx),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%r13),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,0x10(%r13)
addsd  0x10(%r12),%xmm5
movsd  %xmm5,0x10(%r12)
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @d2SdiagTetra(double* %0, double* %1, double* %2, double* %3, double %4, double %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double %14, double %15, double %16) {
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double
%23 = alloca double
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca [9 x double]
%40 = alloca double
%41 = alloca double
%42 = alloca [3 x double]
%43 = alloca [3 x double]
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca [3 x double]
%48 = alloca [3 x double]
%49 = alloca [3 x double]
%50 = alloca [3 x double]
%51 = alloca [3 x double]
%52 = alloca double
%53 = alloca double
store double* %0, double** %18
store double* %1, double** %19
store double* %2, double** %20
store double* %3, double** %21
store double %4, double* %22
store double %5, double* %23
store double* %6, double** %24
store double* %7, double** %25
store double* %8, double** %26
store double* %9, double** %27
store double* %10, double** %28
store double* %11, double** %29
store double* %12, double** %30
store double* %13, double** %31
store double %14, double* %32
store double %15, double* %33
store double %16, double* %34
%54 = load double, double* %32
%55 = load double*, double** %18
%56 = load double*, double** %19
%57 = load double*, double** %20
%58 = load double*, double** %21
%59 = call double @det3D(double* %55, double* %56, double* %57, double* %58)
%60 = fmul double %54, %59
store double %60, double* %36
%61 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 0
%62 = load double*, double** %18
%63 = load double*, double** %19
%64 = load double*, double** %20
%65 = load double*, double** %21
%66 = call i32 @cofactor3D(double* %61, double* %62, double* %63, double* %64, double* %65, double 1.000000e+00)
%67 = load double, double* %33
%68 = fcmp ogt double %67, 0.000000e+00
br i1 %68, label %69, label %378
69: ; preds = %17
%70 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 0
%71 = load double*, double** %18
%72 = load double*, double** %20
%73 = call i32 @vecminus(double* %70, double* %71, double* %72, i32 3)
%74 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 0
%75 = load double*, double** %19
%76 = load double*, double** %20
%77 = call i32 @vecminus(double* %74, double* %75, double* %76, i32 3)
%78 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%79 = load double, double* %78
%80 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%81 = load double, double* %80
%82 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 2
%83 = load double, double* %82
%84 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 1
%85 = load double, double* %84
%86 = fmul double %83, %85
%87 = fneg double %86
%88 = call double @llvm.fmuladd.f64(double %79, double %81, double %87)
%89 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
store double %88, double* %89
%90 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 0
%91 = load double, double* %90
%92 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%93 = load double, double* %92
%94 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 2
%95 = load double, double* %94
%96 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 0
%97 = load double, double* %96
%98 = fmul double %95, %97
%99 = fneg double %98
%100 = call double @llvm.fmuladd.f64(double %91, double %93, double %99)
%101 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
store double %100, double* %101
%102 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 0
%103 = load double, double* %102
%104 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 1
%105 = load double, double* %104
%106 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%107 = load double, double* %106
%108 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 0
%109 = load double, double* %108
%110 = fmul double %107, %109
%111 = fneg double %110
%112 = call double @llvm.fmuladd.f64(double %103, double %105, double %111)
%113 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
store double %112, double* %113
%114 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%115 = load double, double* %114
%116 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%117 = load double, double* %116
%118 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%119 = load double, double* %118
%120 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%121 = load double, double* %120
%122 = fmul double %119, %121
%123 = call double @llvm.fmuladd.f64(double %115, double %117, double %122)
%124 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%125 = load double, double* %124
%126 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%127 = load double, double* %126
%128 = call double @llvm.fmuladd.f64(double %125, double %127, double %123)
store double %128, double* %41
%129 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%130 = load double, double* %129
%131 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%132 = load double, double* %131
%133 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%134 = load double, double* %133
%135 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 1
%136 = load double, double* %135
%137 = fmul double %134, %136
%138 = call double @llvm.fmuladd.f64(double %130, double %132, double %137)
%139 = fmul double 2.000000e+00, %138
%140 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
store double %139, double* %140
%141 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%142 = load double, double* %141
%143 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%144 = load double, double* %143
%145 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%146 = load double, double* %145
%147 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 0
%148 = load double, double* %147
%149 = fmul double %146, %148
%150 = fneg double %149
%151 = call double @llvm.fmuladd.f64(double %142, double %144, double %150)
%152 = fmul double 2.000000e+00, %151
%153 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
store double %152, double* %153
%154 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%155 = load double, double* %154
%156 = fneg double %155
%157 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 1
%158 = load double, double* %157
%159 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%160 = load double, double* %159
%161 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 0
%162 = load double, double* %161
%163 = fmul double %160, %162
%164 = fneg double %163
%165 = call double @llvm.fmuladd.f64(double %156, double %158, double %164)
%166 = fmul double 2.000000e+00, %165
%167 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
store double %166, double* %167
%168 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%169 = load double, double* %168
%170 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 2
%171 = load double, double* %170
%172 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%173 = load double, double* %172
%174 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%175 = load double, double* %174
%176 = fmul double %173, %175
%177 = call double @llvm.fmuladd.f64(double %169, double %171, double %176)
%178 = fmul double -2.000000e+00, %177
%179 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 0
store double %178, double* %179
%180 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%181 = load double, double* %180
%182 = fneg double %181
%183 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 2
%184 = load double, double* %183
%185 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%186 = load double, double* %185
%187 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 0
%188 = load double, double* %187
%189 = fmul double %186, %188
%190 = call double @llvm.fmuladd.f64(double %182, double %184, double %189)
%191 = fmul double 2.000000e+00, %190
%192 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 1
store double %191, double* %192
%193 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%194 = load double, double* %193
%195 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%196 = load double, double* %195
%197 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%198 = load double, double* %197
%199 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 0
%200 = load double, double* %199
%201 = fmul double %198, %200
%202 = call double @llvm.fmuladd.f64(double %194, double %196, double %201)
%203 = fmul double 2.000000e+00, %202
%204 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 2
store double %203, double* %204
%205 = load double, double* %41
%206 = load double, double* %22
%207 = fdiv double %205, %206
%208 = call double @d2phiarea(double %207)
%209 = load double, double* %22
%210 = load double, double* %22
%211 = fmul double %209, %210
%212 = fdiv double %208, %211
store double %212, double* %53
%213 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%214 = load double, double* %213
%215 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 0
%216 = load double, double* %215
%217 = fmul double %216, -2.500000e-01
%218 = call double @llvm.fmuladd.f64(double %214, double 7.500000e-01, double %217)
store double %218, double* %52
%219 = load double, double* %33
%220 = load double, double* %52
%221 = fmul double %219, %220
%222 = load double, double* %53
%223 = fmul double %221, %222
%224 = load double, double* %52
%225 = load double*, double** %24
%226 = getelementptr inbounds double, double* %225, i64 0
%227 = load double, double* %226
%228 = call double @llvm.fmuladd.f64(double %223, double %224, double %227)
store double %228, double* %226
%229 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%230 = load double, double* %229
%231 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 1
%232 = load double, double* %231
%233 = fmul double %232, -2.500000e-01
%234 = call double @llvm.fmuladd.f64(double %230, double 7.500000e-01, double %233)
store double %234, double* %52
%235 = load double, double* %33
%236 = load double, double* %52
%237 = fmul double %235, %236
%238 = load double, double* %53
%239 = fmul double %237, %238
%240 = load double, double* %52
%241 = load double*, double** %24
%242 = getelementptr inbounds double, double* %241, i64 1
%243 = load double, double* %242
%244 = call double @llvm.fmuladd.f64(double %239, double %240, double %243)
store double %244, double* %242
%245 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%246 = load double, double* %245
%247 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 2
%248 = load double, double* %247
%249 = fmul double %248, -2.500000e-01
%250 = call double @llvm.fmuladd.f64(double %246, double 7.500000e-01, double %249)
store double %250, double* %52
%251 = load double, double* %33
%252 = load double, double* %52
%253 = fmul double %251, %252
%254 = load double, double* %53
%255 = fmul double %253, %254
%256 = load double, double* %52
%257 = load double*, double** %24
%258 = getelementptr inbounds double, double* %257, i64 2
%259 = load double, double* %258
%260 = call double @llvm.fmuladd.f64(double %255, double %256, double %259)
store double %260, double* %258
%261 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%262 = load double, double* %261
%263 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 0
%264 = load double, double* %263
%265 = fmul double %264, 7.500000e-01
%266 = call double @llvm.fmuladd.f64(double %262, double -2.500000e-01, double %265)
store double %266, double* %52
%267 = load double, double* %33
%268 = load double, double* %52
%269 = fmul double %267, %268
%270 = load double, double* %53
%271 = fmul double %269, %270
%272 = load double, double* %52
%273 = load double*, double** %25
%274 = getelementptr inbounds double, double* %273, i64 0
%275 = load double, double* %274
%276 = call double @llvm.fmuladd.f64(double %271, double %272, double %275)
store double %276, double* %274
%277 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%278 = load double, double* %277
%279 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 1
%280 = load double, double* %279
%281 = fmul double %280, 7.500000e-01
%282 = call double @llvm.fmuladd.f64(double %278, double -2.500000e-01, double %281)
store double %282, double* %52
%283 = load double, double* %33
%284 = load double, double* %52
%285 = fmul double %283, %284
%286 = load double, double* %53
%287 = fmul double %285, %286
%288 = load double, double* %52
%289 = load double*, double** %25
%290 = getelementptr inbounds double, double* %289, i64 1
%291 = load double, double* %290
%292 = call double @llvm.fmuladd.f64(double %287, double %288, double %291)
store double %292, double* %290
%293 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%294 = load double, double* %293
%295 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 2
%296 = load double, double* %295
%297 = fmul double %296, 7.500000e-01
%298 = call double @llvm.fmuladd.f64(double %294, double -2.500000e-01, double %297)
store double %298, double* %52
%299 = load double, double* %33
%300 = load double, double* %52
%301 = fmul double %299, %300
%302 = load double, double* %53
%303 = fmul double %301, %302
%304 = load double, double* %52
%305 = load double*, double** %25
%306 = getelementptr inbounds double, double* %305, i64 2
%307 = load double, double* %306
%308 = call double @llvm.fmuladd.f64(double %303, double %304, double %307)
store double %308, double* %306
%309 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%310 = load double, double* %309
%311 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 0
%312 = load double, double* %311
%313 = fmul double %312, -2.500000e-01
%314 = call double @llvm.fmuladd.f64(double %310, double -2.500000e-01, double %313)
store double %314, double* %52
%315 = load double, double* %33
%316 = load double, double* %52
%317 = fmul double %315, %316
%318 = load double, double* %53
%319 = fmul double %317, %318
%320 = load double, double* %52
%321 = fmul double %319, %320
store double %321, double* %52
%322 = load double, double* %52
%323 = load double*, double** %26
%324 = getelementptr inbounds double, double* %323, i64 0
%325 = load double, double* %324
%326 = fadd double %325, %322
store double %326, double* %324
%327 = load double, double* %52
%328 = load double*, double** %27
%329 = getelementptr inbounds double, double* %328, i64 0
%330 = load double, double* %329
%331 = fadd double %330, %327
store double %331, double* %329
%332 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%333 = load double, double* %332
%334 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 1
%335 = load double, double* %334
%336 = fmul double %335, -2.500000e-01
%337 = call double @llvm.fmuladd.f64(double %333, double -2.500000e-01, double %336)
store double %337, double* %52
%338 = load double, double* %33
%339 = load double, double* %52
%340 = fmul double %338, %339
%341 = load double, double* %53
%342 = fmul double %340, %341
%343 = load double, double* %52
%344 = fmul double %342, %343
store double %344, double* %52
%345 = load double, double* %52
%346 = load double*, double** %26
%347 = getelementptr inbounds double, double* %346, i64 1
%348 = load double, double* %347
%349 = fadd double %348, %345
store double %349, double* %347
%350 = load double, double* %52
%351 = load double*, double** %27
%352 = getelementptr inbounds double, double* %351, i64 1
%353 = load double, double* %352
%354 = fadd double %353, %350
store double %354, double* %352
%355 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%356 = load double, double* %355
%357 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 2
%358 = load double, double* %357
%359 = fmul double %358, -2.500000e-01
%360 = call double @llvm.fmuladd.f64(double %356, double -2.500000e-01, double %359)
store double %360, double* %52
%361 = load double, double* %33
%362 = load double, double* %52
%363 = fmul double %361, %362
%364 = load double, double* %53
%365 = fmul double %363, %364
%366 = load double, double* %52
%367 = fmul double %365, %366
store double %367, double* %52
%368 = load double, double* %52
%369 = load double*, double** %26
%370 = getelementptr inbounds double, double* %369, i64 2
%371 = load double, double* %370
%372 = fadd double %371, %368
store double %372, double* %370
%373 = load double, double* %52
%374 = load double*, double** %27
%375 = getelementptr inbounds double, double* %374, i64 2
%376 = load double, double* %375
%377 = fadd double %376, %373
store double %377, double* %375
br label %378
378: ; preds = %69, %17
%379 = load double, double* %34
%380 = fcmp ogt double %379, 0.000000e+00
br i1 %380, label %381, label %668
381: ; preds = %378
%382 = load double, double* %34
%383 = load double, double* %36
%384 = load double, double* %23
%385 = fdiv double %383, %384
%386 = call double @d2phicaley(double %385)
%387 = fmul double %382, %386
%388 = load double, double* %23
%389 = load double, double* %23
%390 = fmul double %388, %389
%391 = fdiv double %387, %390
store double %391, double* %38
%392 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 0
%393 = load double, double* %392
%394 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 1
%395 = load double, double* %394
%396 = fmul double %395, -1.250000e-01
%397 = call double @llvm.fmuladd.f64(double %393, double 8.750000e-01, double %396)
%398 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 2
%399 = load double, double* %398
%400 = call double @llvm.fmuladd.f64(double %399, double 1.250000e-01, double %397)
store double %400, double* %35
%401 = load double, double* %35
%402 = load double, double* %38
%403 = fmul double %401, %402
%404 = load double, double* %35
%405 = load double*, double** %24
%406 = getelementptr inbounds double, double* %405, i64 0
%407 = load double, double* %406
%408 = call double @llvm.fmuladd.f64(double %403, double %404, double %407)
store double %408, double* %406
%409 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 3
%410 = load double, double* %409
%411 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 4
%412 = load double, double* %411
%413 = fmul double %412, -1.250000e-01
%414 = call double @llvm.fmuladd.f64(double %410, double 8.750000e-01, double %413)
%415 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 5
%416 = load double, double* %415
%417 = call double @llvm.fmuladd.f64(double %416, double 1.250000e-01, double %414)
store double %417, double* %35
%418 = load double, double* %35
%419 = load double, double* %38
%420 = fmul double %418, %419
%421 = load double, double* %35
%422 = load double*, double** %24
%423 = getelementptr inbounds double, double* %422, i64 1
%424 = load double, double* %423
%425 = call double @llvm.fmuladd.f64(double %420, double %421, double %424)
store double %425, double* %423
%426 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 6
%427 = load double, double* %426
%428 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 7
%429 = load double, double* %428
%430 = fmul double %429, -1.250000e-01
%431 = call double @llvm.fmuladd.f64(double %427, double 8.750000e-01, double %430)
%432 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 8
%433 = load double, double* %432
%434 = call double @llvm.fmuladd.f64(double %433, double 1.250000e-01, double %431)
store double %434, double* %35
%435 = load double, double* %35
%436 = load double, double* %38
%437 = fmul double %435, %436
%438 = load double, double* %35
%439 = load double*, double** %24
%440 = getelementptr inbounds double, double* %439, i64 2
%441 = load double, double* %440
%442 = call double @llvm.fmuladd.f64(double %437, double %438, double %441)
store double %442, double* %440
%443 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 0
%444 = load double, double* %443
%445 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 1
%446 = load double, double* %445
%447 = fmul double %446, 8.750000e-01
%448 = call double @llvm.fmuladd.f64(double %444, double -1.250000e-01, double %447)
%449 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 2
%450 = load double, double* %449
%451 = call double @llvm.fmuladd.f64(double %450, double 1.250000e-01, double %448)
store double %451, double* %35
%452 = load double, double* %35
%453 = load double, double* %38
%454 = fmul double %452, %453
%455 = load double, double* %35
%456 = load double*, double** %25
%457 = getelementptr inbounds double, double* %456, i64 0
%458 = load double, double* %457
%459 = call double @llvm.fmuladd.f64(double %454, double %455, double %458)
store double %459, double* %457
%460 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 3
%461 = load double, double* %460
%462 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 4
%463 = load double, double* %462
%464 = fmul double %463, 8.750000e-01
%465 = call double @llvm.fmuladd.f64(double %461, double -1.250000e-01, double %464)
%466 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 5
%467 = load double, double* %466
%468 = call double @llvm.fmuladd.f64(double %467, double 1.250000e-01, double %465)
store double %468, double* %35
%469 = load double, double* %35
%470 = load double, double* %38
%471 = fmul double %469, %470
%472 = load double, double* %35
%473 = load double*, double** %25
%474 = getelementptr inbounds double, double* %473, i64 1
%475 = load double, double* %474
%476 = call double @llvm.fmuladd.f64(double %471, double %472, double %475)
store double %476, double* %474
%477 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 6
%478 = load double, double* %477
%479 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 7
%480 = load double, double* %479
%481 = fmul double %480, 8.750000e-01
%482 = call double @llvm.fmuladd.f64(double %478, double -1.250000e-01, double %481)
%483 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 8
%484 = load double, double* %483
%485 = call double @llvm.fmuladd.f64(double %484, double 1.250000e-01, double %482)
store double %485, double* %35
%486 = load double, double* %35
%487 = load double, double* %38
%488 = fmul double %486, %487
%489 = load double, double* %35
%490 = load double*, double** %25
%491 = getelementptr inbounds double, double* %490, i64 2
%492 = load double, double* %491
%493 = call double @llvm.fmuladd.f64(double %488, double %489, double %492)
store double %493, double* %491
%494 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 0
%495 = load double, double* %494
%496 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 1
%497 = load double, double* %496
%498 = fmul double %497, -1.250000e-01
%499 = call double @llvm.fmuladd.f64(double %495, double -1.250000e-01, double %498)
%500 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 2
%501 = load double, double* %500
%502 = call double @llvm.fmuladd.f64(double %501, double 1.250000e-01, double %499)
store double %502, double* %35
%503 = load double, double* %35
%504 = load double, double* %38
%505 = fmul double %503, %504
%506 = load double, double* %35
%507 = fmul double %505, %506
store double %507, double* %35
%508 = load double, double* %35
%509 = load double*, double** %26
%510 = getelementptr inbounds double, double* %509, i64 0
%511 = load double, double* %510
%512 = fadd double %511, %508
store double %512, double* %510
%513 = load double, double* %35
%514 = load double*, double** %27
%515 = getelementptr inbounds double, double* %514, i64 0
%516 = load double, double* %515
%517 = fadd double %516, %513
store double %517, double* %515
%518 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 3
%519 = load double, double* %518
%520 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 4
%521 = load double, double* %520
%522 = fmul double %521, -1.250000e-01
%523 = call double @llvm.fmuladd.f64(double %519, double -1.250000e-01, double %522)
%524 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 5
%525 = load double, double* %524
%526 = call double @llvm.fmuladd.f64(double %525, double 1.250000e-01, double %523)
store double %526, double* %35
%527 = load double, double* %35
%528 = load double, double* %38
%529 = fmul double %527, %528
%530 = load double, double* %35
%531 = fmul double %529, %530
store double %531, double* %35
%532 = load double, double* %35
%533 = load double*, double** %26
%534 = getelementptr inbounds double, double* %533, i64 1
%535 = load double, double* %534
%536 = fadd double %535, %532
store double %536, double* %534
%537 = load double, double* %35
%538 = load double*, double** %27
%539 = getelementptr inbounds double, double* %538, i64 1
%540 = load double, double* %539
%541 = fadd double %540, %537
store double %541, double* %539
%542 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 6
%543 = load double, double* %542
%544 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 7
%545 = load double, double* %544
%546 = fmul double %545, -1.250000e-01
%547 = call double @llvm.fmuladd.f64(double %543, double -1.250000e-01, double %546)
%548 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 8
%549 = load double, double* %548
%550 = call double @llvm.fmuladd.f64(double %549, double 1.250000e-01, double %547)
store double %550, double* %35
%551 = load double, double* %35
%552 = load double, double* %38
%553 = fmul double %551, %552
%554 = load double, double* %35
%555 = fmul double %553, %554
store double %555, double* %35
%556 = load double, double* %35
%557 = load double*, double** %26
%558 = getelementptr inbounds double, double* %557, i64 2
%559 = load double, double* %558
%560 = fadd double %559, %556
store double %560, double* %558
%561 = load double, double* %35
%562 = load double*, double** %27
%563 = getelementptr inbounds double, double* %562, i64 2
%564 = load double, double* %563
%565 = fadd double %564, %561
store double %565, double* %563
%566 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 0
%567 = load double, double* %566
%568 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 1
%569 = load double, double* %568
%570 = fmul double %569, -1.250000e-01
%571 = call double @llvm.fmuladd.f64(double %567, double -1.250000e-01, double %570)
%572 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 2
%573 = load double, double* %572
%574 = call double @llvm.fmuladd.f64(double %573, double -1.250000e-01, double %571)
store double %574, double* %35
%575 = load double, double* %35
%576 = load double, double* %38
%577 = fmul double %575, %576
%578 = load double, double* %35
%579 = fmul double %577, %578
store double %579, double* %35
%580 = load double, double* %35
%581 = load double*, double** %28
%582 = getelementptr inbounds double, double* %581, i64 0
%583 = load double, double* %582
%584 = fadd double %583, %580
store double %584, double* %582
%585 = load double, double* %35
%586 = load double*, double** %29
%587 = getelementptr inbounds double, double* %586, i64 0
%588 = load double, double* %587
%589 = fadd double %588, %585
store double %589, double* %587
%590 = load double, double* %35
%591 = load double*, double** %30
%592 = getelementptr inbounds double, double* %591, i64 0
%593 = load double, double* %592
%594 = fadd double %593, %590
store double %594, double* %592
%595 = load double, double* %35
%596 = load double*, double** %31
%597 = getelementptr inbounds double, double* %596, i64 0
%598 = load double, double* %597
%599 = fadd double %598, %595
store double %599, double* %597
%600 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 3
%601 = load double, double* %600
%602 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 4
%603 = load double, double* %602
%604 = fmul double %603, -1.250000e-01
%605 = call double @llvm.fmuladd.f64(double %601, double -1.250000e-01, double %604)
%606 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 5
%607 = load double, double* %606
%608 = call double @llvm.fmuladd.f64(double %607, double -1.250000e-01, double %605)
store double %608, double* %35
%609 = load double, double* %35
%610 = load double, double* %38
%611 = fmul double %609, %610
%612 = load double, double* %35
%613 = fmul double %611, %612
store double %613, double* %35
%614 = load double, double* %35
%615 = load double*, double** %28
%616 = getelementptr inbounds double, double* %615, i64 1
%617 = load double, double* %616
%618 = fadd double %617, %614
store double %618, double* %616
%619 = load double, double* %35
%620 = load double*, double** %29
%621 = getelementptr inbounds double, double* %620, i64 1
%622 = load double, double* %621
%623 = fadd double %622, %619
store double %623, double* %621
%624 = load double, double* %35
%625 = load double*, double** %30
%626 = getelementptr inbounds double, double* %625, i64 1
%627 = load double, double* %626
%628 = fadd double %627, %624
store double %628, double* %626
%629 = load double, double* %35
%630 = load double*, double** %31
%631 = getelementptr inbounds double, double* %630, i64 1
%632 = load double, double* %631
%633 = fadd double %632, %629
store double %633, double* %631
%634 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 6
%635 = load double, double* %634
%636 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 7
%637 = load double, double* %636
%638 = fmul double %637, -1.250000e-01
%639 = call double @llvm.fmuladd.f64(double %635, double -1.250000e-01, double %638)
%640 = getelementptr inbounds [9 x double], [9 x double]* %39, i64 0, i64 8
%641 = load double, double* %640
%642 = call double @llvm.fmuladd.f64(double %641, double -1.250000e-01, double %639)
store double %642, double* %35
%643 = load double, double* %35
%644 = load double, double* %38
%645 = fmul double %643, %644
%646 = load double, double* %35
%647 = fmul double %645, %646
store double %647, double* %35
%648 = load double, double* %35
%649 = load double*, double** %28
%650 = getelementptr inbounds double, double* %649, i64 2
%651 = load double, double* %650
%652 = fadd double %651, %648
store double %652, double* %650
%653 = load double, double* %35
%654 = load double*, double** %29
%655 = getelementptr inbounds double, double* %654, i64 2
%656 = load double, double* %655
%657 = fadd double %656, %653
store double %657, double* %655
%658 = load double, double* %35
%659 = load double*, double** %30
%660 = getelementptr inbounds double, double* %659, i64 2
%661 = load double, double* %660
%662 = fadd double %661, %658
store double %662, double* %660
%663 = load double, double* %35
%664 = load double*, double** %31
%665 = getelementptr inbounds double, double* %664, i64 2
%666 = load double, double* %665
%667 = fadd double %666, %663
store double %667, double* %665
br label %668
668: ; preds = %381, %378
ret void
}

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