#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 fabs(float);
float cycle_max_diff_from_three(float a, float b, float c, float cycle) {
  float diffab = (((fabs(a - b)) < (fabs(fabs(a - b) - cycle)))
                      ? (fabs(a - b))
                      : (fabs(fabs(a - b) - cycle)));
  float diffbc = (((fabs(b - c)) < (fabs(fabs(b - c) - cycle)))
                      ? (fabs(b - c))
                      : (fabs(fabs(b - c) - cycle)));
  float diffca = (((fabs(c - a)) < (fabs(fabs(c - a) - cycle)))
                      ? (fabs(c - a))
                      : (fabs(fabs(c - a) - cycle)));
  return ((((((diffab) > (diffbc)) ? (diffab) : (diffbc))) > (diffca))
              ? ((((diffab) > (diffbc)) ? (diffab) : (diffbc)))
              : (diffca));
}


x86 assembly (clang, -O0):
<cycle_max_diff_from_three>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  -0x4(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x20(%rbp)
movss  -0x4(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  -0x20(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1180 <cycle_max_diff_from_three+0x70>
movss  -0x4(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
jmp    119e <cycle_max_diff_from_three+0x8e>
movss  -0x4(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x8(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x28(%rbp)
movss  -0x8(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  -0x28(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    11fc <cycle_max_diff_from_three+0xec>
movss  -0x8(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x2c(%rbp)
jmp    121a <cycle_max_diff_from_three+0x10a>
movss  -0x8(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0xc(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x30(%rbp)
movss  -0xc(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  -0x30(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1278 <cycle_max_diff_from_three+0x168>
movss  -0xc(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x34(%rbp)
jmp    1296 <cycle_max_diff_from_three+0x186>
movss  -0xc(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
call   1030 <fabs@plt>
subss  -0x10(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jbe    12be <cycle_max_diff_from_three+0x1ae>
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    12c8 <cycle_max_diff_from_three+0x1b8>
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x1c(%rbp),%xmm0
jbe    130e <cycle_max_diff_from_three+0x1fe>
movss  -0x14(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jbe    12f5 <cycle_max_diff_from_three+0x1e5>
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    12ff <cycle_max_diff_from_three+0x1ef>
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1318 <cycle_max_diff_from_three+0x208>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cycle_max_diff_from_three>:
movaps %xmm0,%xmm4
unpcklps %xmm1,%xmm0
unpcklps %xmm2,%xmm1
subps  %xmm1,%xmm0
movaps 0xeed(%rip),%xmm1
andps  %xmm1,%xmm0
subss  %xmm4,%xmm2
andps  %xmm1,%xmm2
movaps %xmm2,%xmm4
subss  %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm3
movaps %xmm0,%xmm5
subps  %xmm3,%xmm5
andps  %xmm1,%xmm5
minps  %xmm5,%xmm0
andps  %xmm1,%xmm4
minss  %xmm4,%xmm2
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
maxss  %xmm1,%xmm0
maxss  %xmm2,%xmm0
ret

LLVM IR (-O0):
define float @cycle_max_diff_from_three(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
store float %0, float* %5
store float %1, float* %6
store float %2, float* %7
store float %3, float* %8
%12 = load float, float* %5
%13 = load float, float* %6
%14 = fsub float %12, %13
%15 = call float @fabs(float %14)
%16 = load float, float* %5
%17 = load float, float* %6
%18 = fsub float %16, %17
%19 = call float @fabs(float %18)
%20 = load float, float* %8
%21 = fsub float %19, %20
%22 = call float @fabs(float %21)
%23 = fcmp olt float %15, %22
br i1 %23, label %24, label %29
24: ; preds = %4
%25 = load float, float* %5
%26 = load float, float* %6
%27 = fsub float %25, %26
%28 = call float @fabs(float %27)
br label %37
29: ; preds = %4
%30 = load float, float* %5
%31 = load float, float* %6
%32 = fsub float %30, %31
%33 = call float @fabs(float %32)
%34 = load float, float* %8
%35 = fsub float %33, %34
%36 = call float @fabs(float %35)
br label %37
37: ; preds = %29, %24
%38 = phi float [ %28, %24 ], [ %36, %29 ]
store float %38, float* %9
%39 = load float, float* %6
%40 = load float, float* %7
%41 = fsub float %39, %40
%42 = call float @fabs(float %41)
%43 = load float, float* %6
%44 = load float, float* %7
%45 = fsub float %43, %44
%46 = call float @fabs(float %45)
%47 = load float, float* %8
%48 = fsub float %46, %47
%49 = call float @fabs(float %48)
%50 = fcmp olt float %42, %49
br i1 %50, label %51, label %56
51: ; preds = %37
%52 = load float, float* %6
%53 = load float, float* %7
%54 = fsub float %52, %53
%55 = call float @fabs(float %54)
br label %64
56: ; preds = %37
%57 = load float, float* %6
%58 = load float, float* %7
%59 = fsub float %57, %58
%60 = call float @fabs(float %59)
%61 = load float, float* %8
%62 = fsub float %60, %61
%63 = call float @fabs(float %62)
br label %64
64: ; preds = %56, %51
%65 = phi float [ %55, %51 ], [ %63, %56 ]
store float %65, float* %10
%66 = load float, float* %7
%67 = load float, float* %5
%68 = fsub float %66, %67
%69 = call float @fabs(float %68)
%70 = load float, float* %7
%71 = load float, float* %5
%72 = fsub float %70, %71
%73 = call float @fabs(float %72)
%74 = load float, float* %8
%75 = fsub float %73, %74
%76 = call float @fabs(float %75)
%77 = fcmp olt float %69, %76
br i1 %77, label %78, label %83
78: ; preds = %64
%79 = load float, float* %7
%80 = load float, float* %5
%81 = fsub float %79, %80
%82 = call float @fabs(float %81)
br label %91
83: ; preds = %64
%84 = load float, float* %7
%85 = load float, float* %5
%86 = fsub float %84, %85
%87 = call float @fabs(float %86)
%88 = load float, float* %8
%89 = fsub float %87, %88
%90 = call float @fabs(float %89)
br label %91
91: ; preds = %83, %78
%92 = phi float [ %82, %78 ], [ %90, %83 ]
store float %92, float* %11
%93 = load float, float* %9
%94 = load float, float* %10
%95 = fcmp ogt float %93, %94
br i1 %95, label %96, label %98
96: ; preds = %91
%97 = load float, float* %9
br label %100
98: ; preds = %91
%99 = load float, float* %10
br label %100
100: ; preds = %98, %96
%101 = phi float [ %97, %96 ], [ %99, %98 ]
%102 = load float, float* %11
%103 = fcmp ogt float %101, %102
br i1 %103, label %104, label %114
104: ; preds = %100
%105 = load float, float* %9
%106 = load float, float* %10
%107 = fcmp ogt float %105, %106
br i1 %107, label %108, label %110
108: ; preds = %104
%109 = load float, float* %9
br label %112
110: ; preds = %104
%111 = load float, float* %10
br label %112
112: ; preds = %110, %108
%113 = phi float [ %109, %108 ], [ %111, %110 ]
br label %116
114: ; preds = %100
%115 = load float, float* %11
br label %116
116: ; preds = %114, %112
%117 = phi float [ %113, %112 ], [ %115, %114 ]
ret float %117
}

LLVM IR (-O2):
define float @cycle_max_diff_from_three(float %0, float %1, float %2, float %3) {
%5 = insertelement <2 x float> poison, float %0, i64 0
%6 = insertelement <2 x float> %5, float %1, i64 1
%7 = insertelement <2 x float> poison, float %1, i64 0
%8 = insertelement <2 x float> %7, float %2, i64 1
%9 = fsub <2 x float> %6, %8
%10 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %9)
%11 = insertelement <2 x float> poison, float %3, i64 0
%12 = shufflevector <2 x float> %11, <2 x float> poison, <2 x i32> zeroinitializer
%13 = fsub <2 x float> %10, %12
%14 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %13)
%15 = fcmp olt <2 x float> %10, %14
%16 = select <2 x i1> %15, <2 x float> %10, <2 x float> %14
%17 = fsub float %2, %0
%18 = tail call float @llvm.fabs.f32(float %17)
%19 = fsub float %18, %3
%20 = tail call float @llvm.fabs.f32(float %19)
%21 = fcmp olt float %18, %20
%22 = select i1 %21, float %18, float %20
%23 = extractelement <2 x float> %16, i64 0
%24 = extractelement <2 x float> %16, i64 1
%25 = fcmp ogt float %23, %24
%26 = select i1 %25, float %23, float %24
%27 = fcmp ogt float %26, %22
%28 = select i1 %27, float %26, float %22
ret float %28
}