int getLocalNormal_tria6(double *L, double X[6][3], double *localNormal) {
  double ax, ay, az, dx1, dx2, dy1, dy2, dz1, dz2, L1, L2, localNormalMod;
  L1 = L[0];
  L2 = L[1];
  ax = X[1][0] - X[3][0] + X[4][0] - X[5][0];
  ay = X[1][1] - X[3][1] + X[4][1] - X[5][1];
  az = X[1][2] - X[3][2] + X[4][2] - X[5][2];
  dx1 = 4.0 * (L1 * (X[0][0] + X[4][0] - 2.0 * X[5][0]) + L2 * ax + X[5][0]) -
        X[0][0] - 3.0 * X[4][0];
  dx2 = 4.0 * (L1 * ax + L2 * (X[2][0] + X[4][0] - 2.0 * X[3][0]) + X[3][0]) -
        X[2][0] - 3.0 * X[4][0];
  dy1 = 4.0 * (L1 * (X[0][1] + X[4][1] - 2.0 * X[5][1]) + L2 * ay + X[5][1]) -
        X[0][1] - 3.0 * X[4][1];
  dy2 = 4.0 * (L1 * ay + L2 * (X[2][1] + X[4][1] - 2.0 * X[3][1]) + X[3][1]) -
        X[2][1] - 3.0 * X[4][1];
  dz1 = 4.0 * (L1 * (X[0][2] + X[4][2] - 2.0 * X[5][2]) + L2 * az + X[5][2]) -
        X[0][2] - 3.0 * X[4][2];
  dz2 = 4.0 * (L1 * az + L2 * (X[2][2] + X[4][2] - 2.0 * X[3][2]) + X[3][2]) -
        X[2][2] - 3.0 * X[4][2];
  localNormal[0] = dy1 * dz2 - dy2 * dz1;
  localNormal[1] = dx2 * dz1 - dx1 * dz2;
  localNormal[2] = dx1 * dy2 - dx2 * dy1;
  localNormalMod = 1.0 / sqrt(localNormal[0] * localNormal[0] +
                              localNormal[1] * localNormal[1] +
                              localNormal[2] * localNormal[2]);
  localNormal[0] = localNormal[0] * localNormalMod;
  localNormal[1] = localNormal[1] * localNormalMod;
  localNormal[2] = localNormal[2] * localNormalMod;
  return 0;
}


x86 assembly (clang, -O0):
<getLocalNormal_tria6>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x60(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x68(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x80(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  0x70(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x88(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
addsd  0x60(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x78(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xde4(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  0xdc3(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm3
mov    -0x10(%rbp),%rax
addsd  0x60(%rax),%xmm3
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm4
addsd  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xd4f(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  0xd2e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
addsd  0x68(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x80(%rax),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x80(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xcb8(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  0xc97(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm3
mov    -0x10(%rbp),%rax
addsd  0x68(%rax),%xmm3
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm4
addsd  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x50(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xc23(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  0xc02(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
addsd  0x70(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x88(%rax),%xmm0
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x88(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xb8c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0xb6b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm3
mov    -0x10(%rbp),%rax
addsd  0x70(%rax),%xmm3
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm4
addsd  %xmm4,%xmm4
subsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
addsd  0x58(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xaf7(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  0xad6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9ba(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getLocalNormal_tria6>:
push   %rbx
mov    %rdx,%rbx
movsd  0x18(%rsi),%xmm14
movsd  0x48(%rsi),%xmm9
subsd  %xmm9,%xmm14
movupd 0x60(%rsi),%xmm7
movapd %xmm7,%xmm12
addsd  %xmm7,%xmm14
movsd  0x78(%rsi),%xmm10
subsd  %xmm10,%xmm14
movsd  0x20(%rsi),%xmm4
movsd  0x50(%rsi),%xmm1
subsd  %xmm1,%xmm4
movapd %xmm7,%xmm6
unpckhpd %xmm7,%xmm6
addsd  %xmm6,%xmm4
movsd  0x80(%rsi),%xmm0
subsd  %xmm0,%xmm4
movsd  (%rsi),%xmm8
movsd  0x8(%rsi),%xmm11
movapd %xmm7,%xmm13
addsd  %xmm8,%xmm13
movapd %xmm1,%xmm15
unpcklpd %xmm10,%xmm1
addsd  %xmm10,%xmm10
subsd  %xmm10,%xmm13
movsd  0x30(%rsi),%xmm3
addsd  %xmm3,%xmm7
movapd %xmm0,%xmm2
unpcklpd %xmm9,%xmm0
addsd  %xmm9,%xmm9
subsd  %xmm9,%xmm7
movapd %xmm6,%xmm5
addsd  %xmm11,%xmm5
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm5
movsd  (%rdi),%xmm10
movapd %xmm4,%xmm9
unpcklpd %xmm7,%xmm9
movsd  0x8(%rdi),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm9
unpcklpd %xmm10,%xmm10
unpcklpd %xmm14,%xmm5
mulpd  %xmm10,%xmm5
addpd  %xmm9,%xmm5
addpd  %xmm5,%xmm0
shufpd $0x1,%xmm12,%xmm12
unpcklpd %xmm3,%xmm11
movapd 0xdfc(%rip),%xmm9
mulpd  %xmm9,%xmm0
subpd  %xmm11,%xmm0
movsd  0x38(%rsi),%xmm11
addsd  %xmm11,%xmm6
addsd  %xmm15,%xmm15
subsd  %xmm15,%xmm6
movsd  0x28(%rsi),%xmm5
unpcklpd %xmm14,%xmm6
movsd  0x58(%rsi),%xmm14
subsd  %xmm14,%xmm5
unpcklpd %xmm13,%xmm4
movsd  0x70(%rsi),%xmm7
addsd  %xmm7,%xmm5
mulpd  %xmm2,%xmm6
mulpd  %xmm10,%xmm4
addpd  %xmm6,%xmm4
movsd  0x88(%rsi),%xmm13
subsd  %xmm13,%xmm5
mulpd  0xda6(%rip),%xmm12
addpd  %xmm12,%xmm0
addpd  %xmm4,%xmm1
unpcklpd %xmm8,%xmm11
mulpd  %xmm9,%xmm1
subpd  %xmm11,%xmm1
addpd  %xmm12,%xmm1
movsd  0x10(%rsi),%xmm8
movapd %xmm7,%xmm4
addsd  %xmm8,%xmm4
movapd %xmm14,%xmm11
unpcklpd %xmm13,%xmm14
addsd  %xmm13,%xmm13
subsd  %xmm13,%xmm4
movsd  0x40(%rsi),%xmm6
movapd %xmm7,%xmm3
addsd  %xmm6,%xmm3
addsd  %xmm11,%xmm11
subsd  %xmm11,%xmm3
unpcklpd %xmm5,%xmm3
mulpd  %xmm2,%xmm3
unpcklpd %xmm4,%xmm5
mulpd  %xmm10,%xmm5
addpd  %xmm3,%xmm5
addpd  %xmm5,%xmm14
unpcklpd %xmm8,%xmm6
mulpd  %xmm9,%xmm14
subpd  %xmm6,%xmm14
mulsd  0xd2e(%rip),%xmm7
unpcklpd %xmm7,%xmm7
addpd  %xmm14,%xmm7
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm7,%xmm3
shufpd $0x1,%xmm7,%xmm7
mulpd  %xmm1,%xmm7
subpd  %xmm7,%xmm3
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movupd %xmm3,(%rdx)
subsd  %xmm2,%xmm0
movapd %xmm3,%xmm1
mulpd  %xmm3,%xmm1
unpckhpd %xmm1,%xmm1
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm0,0x10(%rdx)
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1361 <getLocalNormal_tria6+0x251>
sqrtsd %xmm0,%xmm0
jmp    1366 <getLocalNormal_tria6+0x256>
call   1030 <sqrt@plt>
movsd  0xcba(%rip),%xmm1
divsd  %xmm0,%xmm1
movupd (%rbx),%xmm0
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,(%rbx)
mulsd  0x10(%rbx),%xmm1
movsd  %xmm1,0x10(%rbx)
xor    %eax,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
define i32 @getLocalNormal_tria6(double* nocapture %0, [3 x double]* nocapture %1, double* nocapture %2) {
%4 = load double, double* %0
%5 = getelementptr inbounds double, double* %0, i64 1
%6 = load double, double* %5
%7 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 0
%8 = load double, double* %7
%9 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 3, i64 0
%10 = load double, double* %9
%11 = fsub double %8, %10
%12 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 4, i64 0
%13 = bitcast double* %12 to <2 x double>*
%14 = load <2 x double>, <2 x double>* %13
%15 = shufflevector <2 x double> %14, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%16 = extractelement <2 x double> %14, i64 0
%17 = fadd double %11, %16
%18 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 5, i64 0
%19 = load double, double* %18
%20 = fsub double %17, %19
%21 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 1
%22 = load double, double* %21
%23 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 3, i64 1
%24 = load double, double* %23
%25 = fsub double %22, %24
%26 = extractelement <2 x double> %14, i64 1
%27 = fadd double %25, %26
%28 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 5, i64 1
%29 = load double, double* %28
%30 = fsub double %27, %29
%31 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 1, i64 2
%32 = load double, double* %31
%33 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 3, i64 2
%34 = load double, double* %33
%35 = fsub double %32, %34
%36 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 4, i64 2
%37 = load double, double* %36
%38 = fadd double %35, %37
%39 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 5, i64 2
%40 = load double, double* %39
%41 = fsub double %38, %40
%42 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 0
%43 = load double, double* %42
%44 = fadd double %16, %43
%45 = tail call double @llvm.fmuladd.f64(double %19, double -2.000000e+00, double %44)
%46 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 0
%47 = load double, double* %46
%48 = fadd double %16, %47
%49 = tail call double @llvm.fmuladd.f64(double %10, double -2.000000e+00, double %48)
%50 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 1
%51 = load double, double* %50
%52 = fadd double %26, %51
%53 = tail call double @llvm.fmuladd.f64(double %29, double -2.000000e+00, double %52)
%54 = insertelement <2 x double> poison, double %6, i64 0
%55 = shufflevector <2 x double> %54, <2 x double> poison, <2 x i32> zeroinitializer
%56 = insertelement <2 x double> poison, double %30, i64 0
%57 = insertelement <2 x double> %56, double %49, i64 1
%58 = fmul <2 x double> %55, %57
%59 = insertelement <2 x double> poison, double %4, i64 0
%60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
%61 = insertelement <2 x double> poison, double %53, i64 0
%62 = insertelement <2 x double> %61, double %20, i64 1
%63 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %62, <2 x double> %58)
%64 = insertelement <2 x double> poison, double %29, i64 0
%65 = insertelement <2 x double> %64, double %10, i64 1
%66 = fadd <2 x double> %65, %63
%67 = insertelement <2 x double> poison, double %51, i64 0
%68 = insertelement <2 x double> %67, double %47, i64 1
%69 = fneg <2 x double> %68
%70 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %69)
%71 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %15, <2 x double> <double -3.000000e+00, double -3.000000e+00>, <2 x double> %70)
%72 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 1
%73 = load double, double* %72
%74 = fadd double %26, %73
%75 = tail call double @llvm.fmuladd.f64(double %24, double -2.000000e+00, double %74)
%76 = insertelement <2 x double> poison, double %75, i64 0
%77 = insertelement <2 x double> %76, double %20, i64 1
%78 = fmul <2 x double> %55, %77
%79 = insertelement <2 x double> %56, double %45, i64 1
%80 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %79, <2 x double> %78)
%81 = insertelement <2 x double> poison, double %24, i64 0
%82 = insertelement <2 x double> %81, double %19, i64 1
%83 = fadd <2 x double> %82, %80
%84 = insertelement <2 x double> poison, double %73, i64 0
%85 = insertelement <2 x double> %84, double %43, i64 1
%86 = fneg <2 x double> %85
%87 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %86)
%88 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %15, <2 x double> <double -3.000000e+00, double -3.000000e+00>, <2 x double> %87)
%89 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 0, i64 2
%90 = load double, double* %89
%91 = fadd double %37, %90
%92 = tail call double @llvm.fmuladd.f64(double %40, double -2.000000e+00, double %91)
%93 = getelementptr inbounds [3 x double], [3 x double]* %1, i64 2, i64 2
%94 = load double, double* %93
%95 = fadd double %37, %94
%96 = tail call double @llvm.fmuladd.f64(double %34, double -2.000000e+00, double %95)
%97 = insertelement <2 x double> poison, double %96, i64 0
%98 = insertelement <2 x double> %97, double %41, i64 1
%99 = fmul <2 x double> %55, %98
%100 = insertelement <2 x double> poison, double %41, i64 0
%101 = insertelement <2 x double> %100, double %92, i64 1
%102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %101, <2 x double> %99)
%103 = insertelement <2 x double> poison, double %34, i64 0
%104 = insertelement <2 x double> %103, double %40, i64 1
%105 = fadd <2 x double> %104, %102
%106 = insertelement <2 x double> poison, double %94, i64 0
%107 = insertelement <2 x double> %106, double %90, i64 1
%108 = fneg <2 x double> %107
%109 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %105, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %108)
%110 = insertelement <2 x double> poison, double %37, i64 0
%111 = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> zeroinitializer
%112 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> <double -3.000000e+00, double -3.000000e+00>, <2 x double> %109)
%113 = fneg <2 x double> %88
%114 = shufflevector <2 x double> %112, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%115 = fmul <2 x double> %114, %113
%116 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %71, <2 x double> %112, <2 x double> %115)
%117 = bitcast double* %2 to <2 x double>*
store <2 x double> %116, <2 x double>* %117
%118 = extractelement <2 x double> %71, i64 1
%119 = fneg double %118
%120 = extractelement <2 x double> %71, i64 0
%121 = fmul double %120, %119
%122 = extractelement <2 x double> %88, i64 0
%123 = extractelement <2 x double> %88, i64 1
%124 = tail call double @llvm.fmuladd.f64(double %123, double %122, double %121)
%125 = getelementptr inbounds double, double* %2, i64 2
store double %124, double* %125
%126 = fmul <2 x double> %116, %116
%127 = extractelement <2 x double> %126, i64 1
%128 = extractelement <2 x double> %116, i64 0
%129 = tail call double @llvm.fmuladd.f64(double %128, double %128, double %127)
%130 = tail call double @llvm.fmuladd.f64(double %124, double %124, double %129)
%131 = tail call double @sqrt(double %130)
%132 = fdiv double 1.000000e+00, %131
%133 = bitcast double* %2 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = insertelement <2 x double> poison, double %132, i64 0
%136 = shufflevector <2 x double> %135, <2 x double> poison, <2 x i32> zeroinitializer
%137 = fmul <2 x double> %134, %136
%138 = bitcast double* %2 to <2 x double>*
store <2 x double> %137, <2 x double>* %138
%139 = load double, double* %125
%140 = fmul double %132, %139
store double %140, double* %125
ret i32 0
}