#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 */
float cos(float);
float sin(float);
void floats_xytcov_inv(const float xyta[3], const float Ca[9], float xytr[3],
                       float Cr[9]) {
  float x = xyta[0], y = xyta[1], theta = xyta[2];
  float s = sin(theta), c = cos(theta);
  float J11 = -c, J12 = -s, J13 = -c * y + s * x;
  float J21 = s, J22 = -c, J23 = s * y + c * x;
  float P11 = Ca[0], P12 = Ca[1], P13 = Ca[2];
  float P22 = Ca[4], P23 = Ca[5];
  float P33 = Ca[8];
  Cr[0] = P11 * J11 * J11 + 2 * P12 * J11 * J12 + 2 * P13 * J11 * J13 +
          P22 * J12 * J12 + 2 * P23 * J12 * J13 + P33 * J13 * J13;
  Cr[1] = J21 * (J11 * P11 + J12 * P12 + J13 * P13) +
          J22 * (J11 * P12 + J12 * P22 + J13 * P23) +
          J23 * (J11 * P13 + J12 * P23 + J13 * P33);
  Cr[2] = -J11 * P13 - J12 * P23 - J13 * P33;
  Cr[3] = Cr[1];
  Cr[4] = P11 * J21 * J21 + 2 * P12 * J21 * J22 + 2 * P13 * J21 * J23 +
          P22 * J22 * J22 + 2 * P23 * J22 * J23 + P33 * J23 * J23;
  Cr[5] = -J21 * P13 - J22 * P23 - J23 * P33;
  Cr[6] = Cr[2];
  Cr[7] = Cr[5];
  Cr[8] = P33;
  xytr[0] = -s * y - c * x;
  xytr[1] = -c * y + s * x;
  xytr[2] = -xyta[2];
}


x86 assembly (clang, -O0):
<floats_xytcov_inv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
call   1040 <cos@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  0xd79(%rip),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xd5a(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xd24(%rip),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm3
movss  -0x3c(%rbp),%xmm2
mulss  -0x54(%rbp),%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  -0x48(%rbp),%xmm0
movss  -0x38(%rbp),%xmm4
movss  -0x54(%rbp),%xmm5
movss  -0x3c(%rbp),%xmm3
mulss  -0x5c(%rbp),%xmm3
mulss  %xmm5,%xmm4
addss  %xmm3,%xmm4
movss  -0x40(%rbp),%xmm3
movss  -0x60(%rbp),%xmm5
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm3
movss  -0x58(%rbp),%xmm4
movss  -0x3c(%rbp),%xmm2
mulss  -0x60(%rbp),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x38(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  0xbb1(%rip),%xmm1
mulss  -0x54(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xb92(%rip),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0xb5c(%rip),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<floats_xytcov_inv>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r12
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
movss  (%rdi),%xmm0
movaps %xmm0,0x10(%rsp)
movss  0x4(%rdi),%xmm0
movaps %xmm0,0x30(%rsp)
movss  0x8(%rdi),%xmm0
movss  %xmm0,0x20(%rsp)
call   1030 <sin@plt>
movaps %xmm0,0x40(%rsp)
movss  0x20(%rsp),%xmm0
call   1040 <cos@plt>
movaps 0xe8f(%rip),%xmm1
movaps %xmm0,%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x50(%rsp)
movaps 0x40(%rsp),%xmm13
movaps %xmm13,%xmm14
xorps  %xmm1,%xmm14
movaps 0x10(%rsp),%xmm11
mulss  %xmm13,%xmm11
movaps %xmm0,%xmm1
mulss  0x30(%rsp),%xmm1
subss  %xmm1,%xmm11
movss  (%rbx),%xmm6
movss  %xmm6,0xc(%rsp)
movss  0x4(%rbx),%xmm8
movss  0x8(%rbx),%xmm7
mulss  %xmm2,%xmm6
movaps %xmm8,%xmm2
addss  %xmm8,%xmm2
movaps %xmm2,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm13,%xmm1
movaps %xmm6,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm1
movaps %xmm7,%xmm9
addss  %xmm7,%xmm9
movaps %xmm9,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm1
movss  0x10(%rbx),%xmm10
movaps %xmm10,%xmm3
mulss  %xmm14,%xmm3
movaps %xmm3,%xmm4
mulss  %xmm13,%xmm4
subss  %xmm4,%xmm1
movss  0x14(%rbx),%xmm5
movaps %xmm5,%xmm15
addss  %xmm5,%xmm15
movaps %xmm15,%xmm4
mulss  %xmm13,%xmm4
mulss  %xmm11,%xmm4
subss  %xmm4,%xmm1
movss  0x20(%rbx),%xmm4
movaps %xmm11,%xmm12
mulss  %xmm4,%xmm12
mulss  %xmm11,%xmm12
addss  %xmm1,%xmm12
movss  %xmm12,(%r12)
movaps %xmm0,%xmm1
mulss  %xmm8,%xmm1
mulss  %xmm13,%xmm8
subss  %xmm8,%xmm6
movaps %xmm11,%xmm8
mulss  %xmm7,%xmm8
addss  %xmm6,%xmm8
subss  %xmm1,%xmm3
movaps %xmm11,%xmm1
movaps %xmm5,%xmm12
movaps %xmm5,0x20(%rsp)
mulss  %xmm5,%xmm1
addss  %xmm3,%xmm1
mulss  %xmm14,%xmm12
movaps %xmm0,%xmm3
mulss  %xmm7,%xmm3
movaps %xmm12,%xmm6
subss  %xmm3,%xmm6
movaps %xmm11,%xmm3
unpcklps %xmm13,%xmm3
movaps %xmm4,%xmm5
unpcklps 0x30(%rsp),%xmm4
mulps  %xmm3,%xmm4
movaps 0x10(%rsp),%xmm3
mulss  %xmm0,%xmm3
movaps %xmm3,0x10(%rsp)
unpcklps %xmm3,%xmm6
addps  %xmm4,%xmm6
movaps 0x50(%rsp),%xmm4
mulss  %xmm4,%xmm1
xorps  0xd2c(%rip),%xmm12
unpcklps %xmm1,%xmm12
movaps %xmm13,%xmm3
movss  0xc(%rsp),%xmm13
mulss  %xmm3,%xmm13
mulss  %xmm3,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm3,%xmm13
subss  %xmm2,%xmm13
mulss  %xmm3,%xmm9
movaps %xmm5,%xmm2
movaps %xmm5,%xmm1
unpcklps %xmm6,%xmm1
shufps $0xd4,%xmm6,%xmm5
shufps $0x55,%xmm6,%xmm6
mulss  %xmm6,%xmm9
addss  %xmm13,%xmm9
mulss  %xmm0,%xmm10
mulss  %xmm0,%xmm10
addss  %xmm9,%xmm10
mulss  %xmm4,%xmm15
movaps 0x20(%rsp),%xmm4
mulss  %xmm0,%xmm4
unpcklps %xmm4,%xmm10
movlhps %xmm10,%xmm12
unpcklps %xmm3,%xmm0
unpcklps %xmm14,%xmm15
movlhps %xmm15,%xmm0
movaps %xmm6,%xmm3
unpcklps %xmm7,%xmm3
unpcklps %xmm8,%xmm7
movlhps %xmm3,%xmm7
mulps  %xmm0,%xmm7
movaps %xmm11,%xmm0
movaps 0xc9b(%rip),%xmm4
xorps  %xmm4,%xmm0
addps  %xmm12,%xmm7
movaps %xmm6,%xmm3
mulss  %xmm2,%xmm3
unpcklps %xmm6,%xmm0
xorps  %xmm4,%xmm6
unpcklps %xmm6,%xmm3
movlhps %xmm3,%xmm0
shufps $0x24,%xmm5,%xmm1
mulps  %xmm0,%xmm1
addps  %xmm7,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movss  %xmm0,0x4(%r12)
movups %xmm1,0x8(%r12)
movss  %xmm1,0x18(%r12)
shufps $0xff,%xmm1,%xmm1
movss  %xmm1,0x1c(%r12)
movss  %xmm2,0x20(%r12)
mulss  0x30(%rsp),%xmm14
subss  0x10(%rsp),%xmm14
movss  %xmm14,(%r14)
movss  %xmm11,0x4(%r14)
movss  0x8(%r15),%xmm0
xorps  %xmm4,%xmm0
movss  %xmm0,0x8(%r14)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @floats_xytcov_inv(float* %0, float* %1, float* %2, float* %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
%26 = load float*, float** %5
%27 = getelementptr inbounds float, float* %26, i64 0
%28 = load float, float* %27
store float %28, float* %9
%29 = load float*, float** %5
%30 = getelementptr inbounds float, float* %29, i64 1
%31 = load float, float* %30
store float %31, float* %10
%32 = load float*, float** %5
%33 = getelementptr inbounds float, float* %32, i64 2
%34 = load float, float* %33
store float %34, float* %11
%35 = load float, float* %11
%36 = call float @sin(float %35)
store float %36, float* %12
%37 = load float, float* %11
%38 = call float @cos(float %37)
store float %38, float* %13
%39 = load float, float* %13
%40 = fneg float %39
store float %40, float* %14
%41 = load float, float* %12
%42 = fneg float %41
store float %42, float* %15
%43 = load float, float* %13
%44 = fneg float %43
%45 = load float, float* %10
%46 = load float, float* %12
%47 = load float, float* %9
%48 = fmul float %46, %47
%49 = call float @llvm.fmuladd.f32(float %44, float %45, float %48)
store float %49, float* %16
%50 = load float, float* %12
store float %50, float* %17
%51 = load float, float* %13
%52 = fneg float %51
store float %52, float* %18
%53 = load float, float* %12
%54 = load float, float* %10
%55 = load float, float* %13
%56 = load float, float* %9
%57 = fmul float %55, %56
%58 = call float @llvm.fmuladd.f32(float %53, float %54, float %57)
store float %58, float* %19
%59 = load float*, float** %6
%60 = getelementptr inbounds float, float* %59, i64 0
%61 = load float, float* %60
store float %61, float* %20
%62 = load float*, float** %6
%63 = getelementptr inbounds float, float* %62, i64 1
%64 = load float, float* %63
store float %64, float* %21
%65 = load float*, float** %6
%66 = getelementptr inbounds float, float* %65, i64 2
%67 = load float, float* %66
store float %67, float* %22
%68 = load float*, float** %6
%69 = getelementptr inbounds float, float* %68, i64 4
%70 = load float, float* %69
store float %70, float* %23
%71 = load float*, float** %6
%72 = getelementptr inbounds float, float* %71, i64 5
%73 = load float, float* %72
store float %73, float* %24
%74 = load float*, float** %6
%75 = getelementptr inbounds float, float* %74, i64 8
%76 = load float, float* %75
store float %76, float* %25
%77 = load float, float* %20
%78 = load float, float* %14
%79 = fmul float %77, %78
%80 = load float, float* %14
%81 = load float, float* %21
%82 = fmul float 2.000000e+00, %81
%83 = load float, float* %14
%84 = fmul float %82, %83
%85 = load float, float* %15
%86 = fmul float %84, %85
%87 = call float @llvm.fmuladd.f32(float %79, float %80, float %86)
%88 = load float, float* %22
%89 = fmul float 2.000000e+00, %88
%90 = load float, float* %14
%91 = fmul float %89, %90
%92 = load float, float* %16
%93 = call float @llvm.fmuladd.f32(float %91, float %92, float %87)
%94 = load float, float* %23
%95 = load float, float* %15
%96 = fmul float %94, %95
%97 = load float, float* %15
%98 = call float @llvm.fmuladd.f32(float %96, float %97, float %93)
%99 = load float, float* %24
%100 = fmul float 2.000000e+00, %99
%101 = load float, float* %15
%102 = fmul float %100, %101
%103 = load float, float* %16
%104 = call float @llvm.fmuladd.f32(float %102, float %103, float %98)
%105 = load float, float* %25
%106 = load float, float* %16
%107 = fmul float %105, %106
%108 = load float, float* %16
%109 = call float @llvm.fmuladd.f32(float %107, float %108, float %104)
%110 = load float*, float** %8
%111 = getelementptr inbounds float, float* %110, i64 0
store float %109, float* %111
%112 = load float, float* %17
%113 = load float, float* %14
%114 = load float, float* %20
%115 = load float, float* %15
%116 = load float, float* %21
%117 = fmul float %115, %116
%118 = call float @llvm.fmuladd.f32(float %113, float %114, float %117)
%119 = load float, float* %16
%120 = load float, float* %22
%121 = call float @llvm.fmuladd.f32(float %119, float %120, float %118)
%122 = load float, float* %18
%123 = load float, float* %14
%124 = load float, float* %21
%125 = load float, float* %15
%126 = load float, float* %23
%127 = fmul float %125, %126
%128 = call float @llvm.fmuladd.f32(float %123, float %124, float %127)
%129 = load float, float* %16
%130 = load float, float* %24
%131 = call float @llvm.fmuladd.f32(float %129, float %130, float %128)
%132 = fmul float %122, %131
%133 = call float @llvm.fmuladd.f32(float %112, float %121, float %132)
%134 = load float, float* %19
%135 = load float, float* %14
%136 = load float, float* %22
%137 = load float, float* %15
%138 = load float, float* %24
%139 = fmul float %137, %138
%140 = call float @llvm.fmuladd.f32(float %135, float %136, float %139)
%141 = load float, float* %16
%142 = load float, float* %25
%143 = call float @llvm.fmuladd.f32(float %141, float %142, float %140)
%144 = call float @llvm.fmuladd.f32(float %134, float %143, float %133)
%145 = load float*, float** %8
%146 = getelementptr inbounds float, float* %145, i64 1
store float %144, float* %146
%147 = load float, float* %14
%148 = fneg float %147
%149 = load float, float* %22
%150 = load float, float* %15
%151 = load float, float* %24
%152 = fmul float %150, %151
%153 = fneg float %152
%154 = call float @llvm.fmuladd.f32(float %148, float %149, float %153)
%155 = load float, float* %16
%156 = load float, float* %25
%157 = fneg float %155
%158 = call float @llvm.fmuladd.f32(float %157, float %156, float %154)
%159 = load float*, float** %8
%160 = getelementptr inbounds float, float* %159, i64 2
store float %158, float* %160
%161 = load float*, float** %8
%162 = getelementptr inbounds float, float* %161, i64 1
%163 = load float, float* %162
%164 = load float*, float** %8
%165 = getelementptr inbounds float, float* %164, i64 3
store float %163, float* %165
%166 = load float, float* %20
%167 = load float, float* %17
%168 = fmul float %166, %167
%169 = load float, float* %17
%170 = load float, float* %21
%171 = fmul float 2.000000e+00, %170
%172 = load float, float* %17
%173 = fmul float %171, %172
%174 = load float, float* %18
%175 = fmul float %173, %174
%176 = call float @llvm.fmuladd.f32(float %168, float %169, float %175)
%177 = load float, float* %22
%178 = fmul float 2.000000e+00, %177
%179 = load float, float* %17
%180 = fmul float %178, %179
%181 = load float, float* %19
%182 = call float @llvm.fmuladd.f32(float %180, float %181, float %176)
%183 = load float, float* %23
%184 = load float, float* %18
%185 = fmul float %183, %184
%186 = load float, float* %18
%187 = call float @llvm.fmuladd.f32(float %185, float %186, float %182)
%188 = load float, float* %24
%189 = fmul float 2.000000e+00, %188
%190 = load float, float* %18
%191 = fmul float %189, %190
%192 = load float, float* %19
%193 = call float @llvm.fmuladd.f32(float %191, float %192, float %187)
%194 = load float, float* %25
%195 = load float, float* %19
%196 = fmul float %194, %195
%197 = load float, float* %19
%198 = call float @llvm.fmuladd.f32(float %196, float %197, float %193)
%199 = load float*, float** %8
%200 = getelementptr inbounds float, float* %199, i64 4
store float %198, float* %200
%201 = load float, float* %17
%202 = fneg float %201
%203 = load float, float* %22
%204 = load float, float* %18
%205 = load float, float* %24
%206 = fmul float %204, %205
%207 = fneg float %206
%208 = call float @llvm.fmuladd.f32(float %202, float %203, float %207)
%209 = load float, float* %19
%210 = load float, float* %25
%211 = fneg float %209
%212 = call float @llvm.fmuladd.f32(float %211, float %210, float %208)
%213 = load float*, float** %8
%214 = getelementptr inbounds float, float* %213, i64 5
store float %212, float* %214
%215 = load float*, float** %8
%216 = getelementptr inbounds float, float* %215, i64 2
%217 = load float, float* %216
%218 = load float*, float** %8
%219 = getelementptr inbounds float, float* %218, i64 6
store float %217, float* %219
%220 = load float*, float** %8
%221 = getelementptr inbounds float, float* %220, i64 5
%222 = load float, float* %221
%223 = load float*, float** %8
%224 = getelementptr inbounds float, float* %223, i64 7
store float %222, float* %224
%225 = load float, float* %25
%226 = load float*, float** %8
%227 = getelementptr inbounds float, float* %226, i64 8
store float %225, float* %227
%228 = load float, float* %12
%229 = fneg float %228
%230 = load float, float* %10
%231 = load float, float* %13
%232 = load float, float* %9
%233 = fmul float %231, %232
%234 = fneg float %233
%235 = call float @llvm.fmuladd.f32(float %229, float %230, float %234)
%236 = load float*, float** %7
%237 = getelementptr inbounds float, float* %236, i64 0
store float %235, float* %237
%238 = load float, float* %13
%239 = fneg float %238
%240 = load float, float* %10
%241 = load float, float* %12
%242 = load float, float* %9
%243 = fmul float %241, %242
%244 = call float @llvm.fmuladd.f32(float %239, float %240, float %243)
%245 = load float*, float** %7
%246 = getelementptr inbounds float, float* %245, i64 1
store float %244, float* %246
%247 = load float*, float** %5
%248 = getelementptr inbounds float, float* %247, i64 2
%249 = load float, float* %248
%250 = fneg float %249
%251 = load float*, float** %7
%252 = getelementptr inbounds float, float* %251, i64 2
store float %250, float* %252
ret void
}

LLVM IR (-O2):
define void @floats_xytcov_inv(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2, float* nocapture %3) {
%5 = load float, float* %0
%6 = getelementptr inbounds float, float* %0, i64 1
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %0, i64 2
%9 = load float, float* %8
%10 = tail call float @sin(float %9)
%11 = tail call float @cos(float %9)
%12 = fneg float %11
%13 = fneg float %10
%14 = fmul float %5, %10
%15 = tail call float @llvm.fmuladd.f32(float %12, float %7, float %14)
%16 = fmul float %5, %11
%17 = load float, float* %1
%18 = getelementptr inbounds float, float* %1, i64 1
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %1, i64 2
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %1, i64 4
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %1, i64 5
%25 = load float, float* %24
%26 = getelementptr inbounds float, float* %1, i64 8
%27 = load float, float* %26
%28 = fmul float %17, %12
%29 = fmul float %19, 2.000000e+00
%30 = fmul float %29, %12
%31 = fmul float %30, %13
%32 = tail call float @llvm.fmuladd.f32(float %28, float %12, float %31)
%33 = fmul float %21, 2.000000e+00
%34 = fmul float %33, %12
%35 = tail call float @llvm.fmuladd.f32(float %34, float %15, float %32)
%36 = fmul float %23, %13
%37 = tail call float @llvm.fmuladd.f32(float %36, float %13, float %35)
%38 = fmul float %25, 2.000000e+00
%39 = fmul float %38, %13
%40 = tail call float @llvm.fmuladd.f32(float %39, float %15, float %37)
%41 = fmul float %15, %27
%42 = tail call float @llvm.fmuladd.f32(float %41, float %15, float %40)
store float %42, float* %3
%43 = fmul float %19, %13
%44 = tail call float @llvm.fmuladd.f32(float %12, float %17, float %43)
%45 = tail call float @llvm.fmuladd.f32(float %15, float %21, float %44)
%46 = tail call float @llvm.fmuladd.f32(float %12, float %19, float %36)
%47 = tail call float @llvm.fmuladd.f32(float %15, float %25, float %46)
%48 = fmul float %47, %12
%49 = fmul float %25, %13
%50 = tail call float @llvm.fmuladd.f32(float %12, float %21, float %49)
%51 = insertelement <2 x float> poison, float %15, i64 0
%52 = insertelement <2 x float> %51, float %10, i64 1
%53 = insertelement <2 x float> poison, float %27, i64 0
%54 = insertelement <2 x float> %53, float %7, i64 1
%55 = insertelement <2 x float> poison, float %50, i64 0
%56 = insertelement <2 x float> %55, float %16, i64 1
%57 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %52, <2 x float> %54, <2 x float> %56)
%58 = getelementptr inbounds float, float* %3, i64 1
%59 = fneg float %49
%60 = fneg float %15
%61 = fmul float %10, %17
%62 = fmul float %10, %29
%63 = fmul float %62, %12
%64 = tail call float @llvm.fmuladd.f32(float %61, float %10, float %63)
%65 = fmul float %10, %33
%66 = extractelement <2 x float> %57, i64 1
%67 = tail call float @llvm.fmuladd.f32(float %65, float %66, float %64)
%68 = fmul float %23, %12
%69 = tail call float @llvm.fmuladd.f32(float %68, float %12, float %67)
%70 = fmul float %38, %12
%71 = fmul float %66, %27
%72 = fmul float %11, %25
%73 = insertelement <4 x float> poison, float %11, i64 0
%74 = insertelement <4 x float> %73, float %10, i64 1
%75 = insertelement <4 x float> %74, float %70, i64 2
%76 = insertelement <4 x float> %75, float %13, i64 3
%77 = insertelement <4 x float> poison, float %21, i64 0
%78 = insertelement <4 x float> %77, float %45, i64 1
%79 = insertelement <4 x float> %78, float %66, i64 2
%80 = insertelement <4 x float> %79, float %21, i64 3
%81 = insertelement <4 x float> poison, float %59, i64 0
%82 = insertelement <4 x float> %81, float %48, i64 1
%83 = insertelement <4 x float> %82, float %69, i64 2
%84 = insertelement <4 x float> %83, float %72, i64 3
%85 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %76, <4 x float> %80, <4 x float> %84)
%86 = fneg float %66
%87 = insertelement <4 x float> poison, float %60, i64 0
%88 = insertelement <4 x float> %87, float %66, i64 1
%89 = insertelement <4 x float> %88, float %71, i64 2
%90 = insertelement <4 x float> %89, float %86, i64 3
%91 = insertelement <4 x float> poison, float %27, i64 0
%92 = shufflevector <2 x float> %57, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%93 = shufflevector <4 x float> %91, <4 x float> %92, <4 x i32> <i32 0, i32 4, i32 5, i32 undef>
%94 = insertelement <4 x float> %93, float %27, i64 3
%95 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %90, <4 x float> %94, <4 x float> %85)
%96 = extractelement <4 x float> %95, i64 1
store float %96, float* %58
%97 = getelementptr inbounds float, float* %3, i64 2
%98 = bitcast float* %97 to <4 x float>*
store <4 x float> %95, <4 x float>* %98
%99 = getelementptr inbounds float, float* %3, i64 6
%100 = extractelement <4 x float> %95, i64 0
store float %100, float* %99
%101 = getelementptr inbounds float, float* %3, i64 7
%102 = extractelement <4 x float> %95, i64 3
store float %102, float* %101
%103 = getelementptr inbounds float, float* %3, i64 8
store float %27, float* %103
%104 = fneg float %16
%105 = tail call float @llvm.fmuladd.f32(float %13, float %7, float %104)
store float %105, float* %2
%106 = getelementptr inbounds float, float* %2, i64 1
store float %15, float* %106
%107 = load float, float* %8
%108 = fneg float %107
%109 = getelementptr inbounds float, float* %2, i64 2
store float %108, float* %109
ret void
}