#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 */
typedef int /*<<< orphan*/ mat;

/* Variables and functions */
int /*<<< orphan*/ memcpy(double *, double const *, int);
void babl_matrix_invert(const double *in, double *out) {
  double mat[9];
  double det, invdet;
  memcpy(mat, in, sizeof(mat));
  det =
      mat[0 * 3 + 0] *
          (mat[1 * 3 + 1] * mat[2 * 3 + 2] - mat[2 * 3 + 1] * mat[1 * 3 + 2]) -
      mat[0 * 3 + 1] *
          (mat[1 * 3 + 0] * mat[2 * 3 + 2] - mat[1 * 3 + 2] * mat[2 * 3 + 0]) +
      mat[0 * 3 + 2] *
          (mat[1 * 3 + 0] * mat[2 * 3 + 1] - mat[1 * 3 + 1] * mat[2 * 3 + 0]);
  invdet = 1.0 / det;
  out[0 * 3 + 0] =
      (mat[1 * 3 + 1] * mat[2 * 3 + 2] - mat[2 * 3 + 1] * mat[1 * 3 + 2]) *
      invdet;
  out[0 * 3 + 1] =
      (mat[0 * 3 + 2] * mat[2 * 3 + 1] - mat[0 * 3 + 1] * mat[2 * 3 + 2]) *
      invdet;
  out[0 * 3 + 2] =
      (mat[0 * 3 + 1] * mat[1 * 3 + 2] - mat[0 * 3 + 2] * mat[1 * 3 + 1]) *
      invdet;
  out[1 * 3 + 0] =
      (mat[1 * 3 + 2] * mat[2 * 3 + 0] - mat[1 * 3 + 0] * mat[2 * 3 + 2]) *
      invdet;
  out[1 * 3 + 1] =
      (mat[0 * 3 + 0] * mat[2 * 3 + 2] - mat[0 * 3 + 2] * mat[2 * 3 + 0]) *
      invdet;
  out[1 * 3 + 2] =
      (mat[1 * 3 + 0] * mat[0 * 3 + 2] - mat[0 * 3 + 0] * mat[1 * 3 + 2]) *
      invdet;
  out[2 * 3 + 0] =
      (mat[1 * 3 + 0] * mat[2 * 3 + 1] - mat[2 * 3 + 0] * mat[1 * 3 + 1]) *
      invdet;
  out[2 * 3 + 1] =
      (mat[2 * 3 + 0] * mat[0 * 3 + 1] - mat[0 * 3 + 0] * mat[2 * 3 + 1]) *
      invdet;
  out[2 * 3 + 2] =
      (mat[0 * 3 + 0] * mat[1 * 3 + 1] - mat[1 * 3 + 0] * mat[0 * 3 + 1]) *
      invdet;
}


x86 assembly (clang, -O0):
<babl_matrix_invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    $0x48,%edx
call   1030 <memcpy@plt>
movsd  -0x60(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x20(%rbp),%xmm3
movsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm3
movsd  -0x20(%rbp),%xmm5
movsd  -0x38(%rbp),%xmm4
mulsd  -0x30(%rbp),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm3
mulsd  -0x30(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xdee(%rip),%xmm0
divsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x58(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x60(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x30(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x60(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<babl_matrix_invert>:
push   %rbx
sub    $0x70,%rsp
mov    %rsi,%rbx
mov    %rdi,%rsi
lea    0x20(%rsp),%rdi
mov    $0x48,%edx
call   1030 <memcpy@plt>
movsd  0x40(%rsp),%xmm10
movupd 0x58(%rsp),%xmm9
movapd %xmm9,0x10(%rsp)
movsd  0x20(%rsp),%xmm13
movsd  0x28(%rsp),%xmm0
movapd %xmm0,(%rsp)
movupd 0x48(%rsp),%xmm2
movapd %xmm2,%xmm5
unpckhpd %xmm2,%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm2,%xmm6
movapd %xmm9,%xmm4
unpckhpd %xmm9,%xmm4
movapd 0x30(%rsp),%xmm7
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
mulsd  %xmm1,%xmm4
subsd  %xmm6,%xmm4
movapd %xmm9,%xmm11
unpcklpd %xmm0,%xmm11
movapd %xmm9,%xmm12
movsd  %xmm2,%xmm12
mulpd  %xmm11,%xmm12
movapd %xmm13,%xmm8
mulsd  %xmm10,%xmm5
mulsd  %xmm9,%xmm1
subsd  %xmm5,%xmm1
movapd %xmm9,%xmm6
movsd  %xmm10,%xmm6
movapd %xmm2,%xmm14
shufpd $0x1,%xmm13,%xmm14
movapd %xmm7,%xmm15
shufpd $0x1,%xmm13,%xmm15
movapd %xmm10,%xmm5
mulsd  %xmm10,%xmm13
unpcklpd %xmm7,%xmm10
mulsd  %xmm7,%xmm1
mulpd  %xmm7,%xmm6
unpcklpd %xmm9,%xmm5
movsd  %xmm7,%xmm9
movapd %xmm7,%xmm3
unpckhpd %xmm2,%xmm7
mulpd  %xmm11,%xmm7
movapd 0xdf7(%rip),%xmm0
xorpd  %xmm0,%xmm11
pshufd $0xee,%xmm11,%xmm11
mulsd  %xmm4,%xmm11
movapd 0x10(%rsp),%xmm4
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm4,%xmm10
subpd  %xmm12,%xmm10
mulsd  %xmm10,%xmm8
addsd  %xmm11,%xmm8
addsd  %xmm8,%xmm1
movsd  0xdcb(%rip),%xmm4
divsd  %xmm1,%xmm4
xorpd  %xmm0,%xmm3
pshufd $0xee,%xmm3,%xmm1
movapd (%rsp),%xmm8
mulsd  %xmm8,%xmm1
addsd  %xmm1,%xmm13
mulsd  %xmm4,%xmm13
unpcklpd %xmm4,%xmm4
mulpd  %xmm4,%xmm10
movupd %xmm10,(%rbx)
movapd %xmm8,%xmm1
unpcklpd %xmm2,%xmm1
mulpd  %xmm2,%xmm1
subpd  %xmm6,%xmm1
mulpd  %xmm4,%xmm1
movupd %xmm1,0x10(%rbx)
xorpd  %xmm14,%xmm0
shufpd $0x1,%xmm3,%xmm0
mulpd  %xmm2,%xmm0
mulpd  %xmm15,%xmm9
addpd  %xmm0,%xmm9
mulpd  %xmm4,%xmm9
shufpd $0x1,%xmm9,%xmm9
movupd %xmm9,0x20(%rbx)
mulpd  %xmm14,%xmm5
subpd  %xmm5,%xmm7
mulpd  %xmm4,%xmm7
movupd %xmm7,0x30(%rbx)
movsd  %xmm13,0x40(%rbx)
add    $0x70,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @babl_matrix_invert(double* %0, double* %1) {
%3 = alloca double*
%4 = alloca double*
%5 = alloca [9 x double]
%6 = alloca double
%7 = alloca double
store double* %0, double** %3
store double* %1, double** %4
%8 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%9 = load double*, double** %3
%10 = call i32 @memcpy(double* %8, double* %9, i32 72)
%11 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%12 = load double, double* %11
%13 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%14 = load double, double* %13
%15 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%16 = load double, double* %15
%17 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%18 = load double, double* %17
%19 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%20 = load double, double* %19
%21 = fmul double %18, %20
%22 = fneg double %21
%23 = call double @llvm.fmuladd.f64(double %14, double %16, double %22)
%24 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 1
%25 = load double, double* %24
%26 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%27 = load double, double* %26
%28 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%29 = load double, double* %28
%30 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%31 = load double, double* %30
%32 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%33 = load double, double* %32
%34 = fmul double %31, %33
%35 = fneg double %34
%36 = call double @llvm.fmuladd.f64(double %27, double %29, double %35)
%37 = fmul double %25, %36
%38 = fneg double %37
%39 = call double @llvm.fmuladd.f64(double %12, double %23, double %38)
%40 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 2
%41 = load double, double* %40
%42 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%43 = load double, double* %42
%44 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%45 = load double, double* %44
%46 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%47 = load double, double* %46
%48 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%49 = load double, double* %48
%50 = fmul double %47, %49
%51 = fneg double %50
%52 = call double @llvm.fmuladd.f64(double %43, double %45, double %51)
%53 = call double @llvm.fmuladd.f64(double %41, double %52, double %39)
store double %53, double* %6
%54 = load double, double* %6
%55 = fdiv double 1.000000e+00, %54
store double %55, double* %7
%56 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%57 = load double, double* %56
%58 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%59 = load double, double* %58
%60 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%61 = load double, double* %60
%62 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%63 = load double, double* %62
%64 = fmul double %61, %63
%65 = fneg double %64
%66 = call double @llvm.fmuladd.f64(double %57, double %59, double %65)
%67 = load double, double* %7
%68 = fmul double %66, %67
%69 = load double*, double** %4
%70 = getelementptr inbounds double, double* %69, i64 0
store double %68, double* %70
%71 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 2
%72 = load double, double* %71
%73 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%74 = load double, double* %73
%75 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 1
%76 = load double, double* %75
%77 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%78 = load double, double* %77
%79 = fmul double %76, %78
%80 = fneg double %79
%81 = call double @llvm.fmuladd.f64(double %72, double %74, double %80)
%82 = load double, double* %7
%83 = fmul double %81, %82
%84 = load double*, double** %4
%85 = getelementptr inbounds double, double* %84, i64 1
store double %83, double* %85
%86 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 1
%87 = load double, double* %86
%88 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%89 = load double, double* %88
%90 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 2
%91 = load double, double* %90
%92 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%93 = load double, double* %92
%94 = fmul double %91, %93
%95 = fneg double %94
%96 = call double @llvm.fmuladd.f64(double %87, double %89, double %95)
%97 = load double, double* %7
%98 = fmul double %96, %97
%99 = load double*, double** %4
%100 = getelementptr inbounds double, double* %99, i64 2
store double %98, double* %100
%101 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%102 = load double, double* %101
%103 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%104 = load double, double* %103
%105 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%106 = load double, double* %105
%107 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%108 = load double, double* %107
%109 = fmul double %106, %108
%110 = fneg double %109
%111 = call double @llvm.fmuladd.f64(double %102, double %104, double %110)
%112 = load double, double* %7
%113 = fmul double %111, %112
%114 = load double*, double** %4
%115 = getelementptr inbounds double, double* %114, i64 3
store double %113, double* %115
%116 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%117 = load double, double* %116
%118 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 8
%119 = load double, double* %118
%120 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 2
%121 = load double, double* %120
%122 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%123 = load double, double* %122
%124 = fmul double %121, %123
%125 = fneg double %124
%126 = call double @llvm.fmuladd.f64(double %117, double %119, double %125)
%127 = load double, double* %7
%128 = fmul double %126, %127
%129 = load double*, double** %4
%130 = getelementptr inbounds double, double* %129, i64 4
store double %128, double* %130
%131 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%132 = load double, double* %131
%133 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 2
%134 = load double, double* %133
%135 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%136 = load double, double* %135
%137 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 5
%138 = load double, double* %137
%139 = fmul double %136, %138
%140 = fneg double %139
%141 = call double @llvm.fmuladd.f64(double %132, double %134, double %140)
%142 = load double, double* %7
%143 = fmul double %141, %142
%144 = load double*, double** %4
%145 = getelementptr inbounds double, double* %144, i64 5
store double %143, double* %145
%146 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%147 = load double, double* %146
%148 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%149 = load double, double* %148
%150 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%151 = load double, double* %150
%152 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%153 = load double, double* %152
%154 = fmul double %151, %153
%155 = fneg double %154
%156 = call double @llvm.fmuladd.f64(double %147, double %149, double %155)
%157 = load double, double* %7
%158 = fmul double %156, %157
%159 = load double*, double** %4
%160 = getelementptr inbounds double, double* %159, i64 6
store double %158, double* %160
%161 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 6
%162 = load double, double* %161
%163 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 1
%164 = load double, double* %163
%165 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%166 = load double, double* %165
%167 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 7
%168 = load double, double* %167
%169 = fmul double %166, %168
%170 = fneg double %169
%171 = call double @llvm.fmuladd.f64(double %162, double %164, double %170)
%172 = load double, double* %7
%173 = fmul double %171, %172
%174 = load double*, double** %4
%175 = getelementptr inbounds double, double* %174, i64 7
store double %173, double* %175
%176 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 0
%177 = load double, double* %176
%178 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 4
%179 = load double, double* %178
%180 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 3
%181 = load double, double* %180
%182 = getelementptr inbounds [9 x double], [9 x double]* %5, i64 0, i64 1
%183 = load double, double* %182
%184 = fmul double %181, %183
%185 = fneg double %184
%186 = call double @llvm.fmuladd.f64(double %177, double %179, double %185)
%187 = load double, double* %7
%188 = fmul double %186, %187
%189 = load double*, double** %4
%190 = getelementptr inbounds double, double* %189, i64 8
store double %188, double* %190
ret void
}

LLVM IR (-O2):
define void @babl_matrix_invert(double* %0, double* nocapture writeonly %1) {
%3 = alloca [9 x double]
%4 = bitcast [9 x double]* %3 to i8*
%5 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 0
%6 = call i32 @memcpy(double* %5, double* %0, i32 72)
%7 = load double, double* %5
%8 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 4
%9 = load double, double* %8
%10 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 7
%11 = bitcast double* %10 to <2 x double>*
%12 = load <2 x double>, <2 x double>* %11
%13 = shufflevector <2 x double> %12, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%14 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 5
%15 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 1
%16 = load double, double* %15
%17 = bitcast double* %14 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = extractelement <2 x double> %18, i64 0
%20 = fneg double %19
%21 = extractelement <2 x double> %18, i64 1
%22 = fmul double %21, %20
%23 = extractelement <2 x double> %12, i64 1
%24 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 2
%25 = bitcast double* %24 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = extractelement <2 x double> %26, i64 1
%28 = call double @llvm.fmuladd.f64(double %27, double %23, double %22)
%29 = extractelement <2 x double> %12, i64 0
%30 = insertelement <2 x double> %12, double %16, i64 1
%31 = fneg <2 x double> %30
%32 = extractelement <2 x double> %31, i64 1
%33 = fmul double %28, %32
%34 = shufflevector <2 x double> %18, <2 x double> %12, <2 x i32> <i32 0, i32 3>
%35 = fmul <2 x double> %34, %31
%36 = insertelement <2 x double> poison, double %9, i64 0
%37 = extractelement <2 x double> %26, i64 0
%38 = shufflevector <2 x double> %36, <2 x double> %26, <2 x i32> <i32 0, i32 2>
%39 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %13, <2 x double> %35)
%40 = extractelement <2 x double> %39, i64 0
%41 = call double @llvm.fmuladd.f64(double %7, double %40, double %33)
%42 = fneg double %9
%43 = fmul double %21, %42
%44 = call double @llvm.fmuladd.f64(double %27, double %29, double %43)
%45 = call double @llvm.fmuladd.f64(double %37, double %44, double %41)
%46 = fdiv double 1.000000e+00, %45
%47 = insertelement <2 x double> poison, double %46, i64 0
%48 = shufflevector <2 x double> %47, <2 x double> poison, <2 x i32> zeroinitializer
%49 = fmul <2 x double> %39, %48
%50 = bitcast double* %1 to <2 x double>*
store <2 x double> %49, <2 x double>* %50
%51 = getelementptr inbounds double, double* %1, i64 2
%52 = fneg <2 x double> %26
%53 = insertelement <2 x double> %12, double %9, i64 0
%54 = fmul <2 x double> %53, %52
%55 = insertelement <2 x double> poison, double %16, i64 0
%56 = shufflevector <2 x double> %55, <2 x double> %18, <2 x i32> <i32 0, i32 2>
%57 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %56, <2 x double> %18, <2 x double> %54)
%58 = fmul <2 x double> %57, %48
%59 = bitcast double* %51 to <2 x double>*
store <2 x double> %58, <2 x double>* %59
%60 = getelementptr inbounds double, double* %1, i64 4
%61 = insertelement <2 x double> poison, double %21, i64 0
%62 = insertelement <2 x double> %61, double %7, i64 1
%63 = fneg <2 x double> %62
%64 = shufflevector <2 x double> %63, <2 x double> %52, <2 x i32> <i32 1, i32 2>
%65 = fmul <2 x double> %18, %64
%66 = shufflevector <2 x double> %26, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%67 = insertelement <2 x double> %66, double %7, i64 1
%68 = shufflevector <2 x double> %26, <2 x double> %12, <2 x i32> <i32 0, i32 3>
%69 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %68, <2 x double> %65)
%70 = fmul <2 x double> %69, %48
%71 = shufflevector <2 x double> %70, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%72 = bitcast double* %60 to <2 x double>*
store <2 x double> %71, <2 x double>* %72
%73 = getelementptr inbounds double, double* %1, i64 6
%74 = shufflevector <2 x double> %36, <2 x double> %12, <2 x i32> <i32 0, i32 2>
%75 = fmul <2 x double> %74, %63
%76 = shufflevector <2 x double> %66, <2 x double> %18, <2 x i32> <i32 0, i32 3>
%77 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %76, <2 x double> %30, <2 x double> %75)
%78 = fmul <2 x double> %77, %48
%79 = bitcast double* %73 to <2 x double>*
store <2 x double> %78, <2 x double>* %79
%80 = extractelement <2 x double> %52, i64 1
%81 = fmul double %16, %80
%82 = call double @llvm.fmuladd.f64(double %7, double %9, double %81)
%83 = fmul double %82, %46
%84 = getelementptr inbounds double, double* %1, i64 8
store double %83, double* %84
ret void
}