#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*/ assert(int /*<<< orphan*/);
void _trical_measurement_calibrate(float state[12], float measurement[3],
                                   float calibrated_measurement[3]) {
  assert(state && measurement && calibrated_measurement);
  float v[3], *restrict s = state, *restrict c = calibrated_measurement;
  v[0] = measurement[0] - s[0];
  v[1] = measurement[1] - s[1];
  v[2] = measurement[2] - s[2];
  c[0] = v[0] * (s[3] + 1.0f) + v[1] * s[4] + v[2] * s[5];
  c[1] = v[0] * s[6] + v[1] * (s[7] + 1.0f) + v[2] * s[8];
  c[2] = v[0] * s[9] + v[1] * s[10] + v[2] * (s[11] + 1.0f);
}


x86 assembly (clang, -O0):
<_trical_measurement_calibrate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x39(%rbp)
je     114f <_trical_measurement_calibrate+0x3f>
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x39(%rbp)
je     114f <_trical_measurement_calibrate+0x3f>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x24(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  0xe40(%rip),%xmm2
addss  0xc(%rax),%xmm2
movss  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x10(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x24(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  0x18(%rax),%xmm2
movss  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0xde8(%rip),%xmm3
addss  0x1c(%rax),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x24(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  0x24(%rax),%xmm2
movss  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x28(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0xd83(%rip),%xmm2
addss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_trical_measurement_calibrate>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
test   %rdi,%rdi
setne  %al
test   %rsi,%rsi
setne  %cl
and    %al,%cl
test   %rdx,%rdx
setne  %al
and    %cl,%al
movzbl %al,%edi
call   1030 <assert@plt>
movss  (%r15),%xmm0
movss  0x4(%r15),%xmm1
subss  (%rbx),%xmm0
subss  0x4(%rbx),%xmm1
movss  0x8(%r15),%xmm2
subss  0x8(%rbx),%xmm2
movss  0xe9d(%rip),%xmm3
movss  0xc(%rbx),%xmm4
addss  %xmm3,%xmm4
movss  0x10(%rbx),%xmm5
mulss  %xmm1,%xmm5
mulss  %xmm0,%xmm4
addss  %xmm5,%xmm4
movss  0x14(%rbx),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%r14)
movss  0x1c(%rbx),%xmm4
addss  %xmm3,%xmm4
mulss  %xmm1,%xmm4
movss  0x18(%rbx),%xmm5
mulss  %xmm0,%xmm5
addss  %xmm4,%xmm5
movss  0x20(%rbx),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,0x4(%r14)
mulss  0x28(%rbx),%xmm1
mulss  0x24(%rbx),%xmm0
addss  0x2c(%rbx),%xmm3
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x8(%r14)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @_trical_measurement_calibrate(float* %0, float* %1, float* %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca [3 x float]
%8 = alloca float*
%9 = alloca float*
store float* %0, float** %4
store float* %1, float** %5
store float* %2, float** %6
%10 = load float*, float** %4
%11 = icmp ne float* %10, null
br i1 %11, label %12, label %18
12: ; preds = %3
%13 = load float*, float** %5
%14 = icmp ne float* %13, null
br i1 %14, label %15, label %18
15: ; preds = %12
%16 = load float*, float** %6
%17 = icmp ne float* %16, null
br label %18
18: ; preds = %15, %12, %3
%19 = phi i1 [ false, %12 ], [ false, %3 ], [ %17, %15 ]
%20 = zext i1 %19 to i32
%21 = call i32 @assert(i32 %20)
%22 = load float*, float** %4
store float* %22, float** %8
%23 = load float*, float** %6
store float* %23, float** %9
%24 = load float*, float** %5
%25 = getelementptr inbounds float, float* %24, i64 0
%26 = load float, float* %25
%27 = load float*, float** %8
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
%30 = fsub float %26, %29
%31 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
store float %30, float* %31
%32 = load float*, float** %5
%33 = getelementptr inbounds float, float* %32, i64 1
%34 = load float, float* %33
%35 = load float*, float** %8
%36 = getelementptr inbounds float, float* %35, i64 1
%37 = load float, float* %36
%38 = fsub float %34, %37
%39 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
store float %38, float* %39
%40 = load float*, float** %5
%41 = getelementptr inbounds float, float* %40, i64 2
%42 = load float, float* %41
%43 = load float*, float** %8
%44 = getelementptr inbounds float, float* %43, i64 2
%45 = load float, float* %44
%46 = fsub float %42, %45
%47 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
store float %46, float* %47
%48 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%49 = load float, float* %48
%50 = load float*, float** %8
%51 = getelementptr inbounds float, float* %50, i64 3
%52 = load float, float* %51
%53 = fadd float %52, 1.000000e+00
%54 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%55 = load float, float* %54
%56 = load float*, float** %8
%57 = getelementptr inbounds float, float* %56, i64 4
%58 = load float, float* %57
%59 = fmul float %55, %58
%60 = call float @llvm.fmuladd.f32(float %49, float %53, float %59)
%61 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%62 = load float, float* %61
%63 = load float*, float** %8
%64 = getelementptr inbounds float, float* %63, i64 5
%65 = load float, float* %64
%66 = call float @llvm.fmuladd.f32(float %62, float %65, float %60)
%67 = load float*, float** %9
%68 = getelementptr inbounds float, float* %67, i64 0
store float %66, float* %68
%69 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%70 = load float, float* %69
%71 = load float*, float** %8
%72 = getelementptr inbounds float, float* %71, i64 6
%73 = load float, float* %72
%74 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%75 = load float, float* %74
%76 = load float*, float** %8
%77 = getelementptr inbounds float, float* %76, i64 7
%78 = load float, float* %77
%79 = fadd float %78, 1.000000e+00
%80 = fmul float %75, %79
%81 = call float @llvm.fmuladd.f32(float %70, float %73, float %80)
%82 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%83 = load float, float* %82
%84 = load float*, float** %8
%85 = getelementptr inbounds float, float* %84, i64 8
%86 = load float, float* %85
%87 = call float @llvm.fmuladd.f32(float %83, float %86, float %81)
%88 = load float*, float** %9
%89 = getelementptr inbounds float, float* %88, i64 1
store float %87, float* %89
%90 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%91 = load float, float* %90
%92 = load float*, float** %8
%93 = getelementptr inbounds float, float* %92, i64 9
%94 = load float, float* %93
%95 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%96 = load float, float* %95
%97 = load float*, float** %8
%98 = getelementptr inbounds float, float* %97, i64 10
%99 = load float, float* %98
%100 = fmul float %96, %99
%101 = call float @llvm.fmuladd.f32(float %91, float %94, float %100)
%102 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%103 = load float, float* %102
%104 = load float*, float** %8
%105 = getelementptr inbounds float, float* %104, i64 11
%106 = load float, float* %105
%107 = fadd float %106, 1.000000e+00
%108 = call float @llvm.fmuladd.f32(float %103, float %107, float %101)
%109 = load float*, float** %9
%110 = getelementptr inbounds float, float* %109, i64 2
store float %108, float* %110
ret void
}

LLVM IR (-O2):
define void @_trical_measurement_calibrate(float* %0, float* %1, float* writeonly %2) {
%4 = icmp ne float* %0, null
%5 = icmp ne float* %1, null
%6 = and i1 %4, %5
%7 = icmp ne float* %2, null
%8 = and i1 %6, %7
%9 = zext i1 %8 to i32
%10 = tail call i32 @assert(i32 %9)
%11 = load float, float* %1
%12 = load float, float* %0
%13 = fsub float %11, %12
%14 = getelementptr inbounds float, float* %1, i64 1
%15 = load float, float* %14
%16 = getelementptr inbounds float, float* %0, i64 1
%17 = load float, float* %16
%18 = fsub float %15, %17
%19 = getelementptr inbounds float, float* %1, i64 2
%20 = load float, float* %19
%21 = getelementptr inbounds float, float* %0, i64 2
%22 = load float, float* %21
%23 = fsub float %20, %22
%24 = getelementptr inbounds float, float* %0, i64 3
%25 = load float, float* %24
%26 = fadd float %25, 1.000000e+00
%27 = getelementptr inbounds float, float* %0, i64 4
%28 = load float, float* %27
%29 = fmul float %18, %28
%30 = tail call float @llvm.fmuladd.f32(float %13, float %26, float %29)
%31 = getelementptr inbounds float, float* %0, i64 5
%32 = load float, float* %31
%33 = tail call float @llvm.fmuladd.f32(float %23, float %32, float %30)
store float %33, float* %2
%34 = getelementptr inbounds float, float* %0, i64 6
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %0, i64 7
%37 = load float, float* %36
%38 = fadd float %37, 1.000000e+00
%39 = fmul float %18, %38
%40 = tail call float @llvm.fmuladd.f32(float %13, float %35, float %39)
%41 = getelementptr inbounds float, float* %0, i64 8
%42 = load float, float* %41
%43 = tail call float @llvm.fmuladd.f32(float %23, float %42, float %40)
%44 = getelementptr inbounds float, float* %2, i64 1
store float %43, float* %44
%45 = getelementptr inbounds float, float* %0, i64 9
%46 = load float, float* %45
%47 = getelementptr inbounds float, float* %0, i64 10
%48 = load float, float* %47
%49 = fmul float %18, %48
%50 = tail call float @llvm.fmuladd.f32(float %13, float %46, float %49)
%51 = getelementptr inbounds float, float* %0, i64 11
%52 = load float, float* %51
%53 = fadd float %52, 1.000000e+00
%54 = tail call float @llvm.fmuladd.f32(float %23, float %53, float %50)
%55 = getelementptr inbounds float, float* %2, i64 2
store float %54, float* %55
ret void
}