#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 sqrt(float);
float DistanceFromLine(float cx, float cy, float ax, float ay, float bx,
                       float by) {
  float r_numerator, r_denomenator, r, s, distanceLine, distanceSegment, dist1,
      dist2;
  r_numerator = (cx - ax) * (bx - ax) + (cy - ay) * (by - ay);
  r_denomenator = (bx - ax) * (bx - ax) + (by - ay) * (by - ay);
  r = r_numerator / r_denomenator;
  s = ((ay - cy) * (bx - ax) - (ax - cx) * (by - ay)) / r_denomenator;
  distanceLine = fabs(s) * sqrt(r_denomenator);
  if ((r >= 0) && (r <= 1)) {
    distanceSegment = distanceLine;
  } else {
    dist1 = (cx - ax) * (cx - ax) + (cy - ay) * (cy - ay);
    dist2 = (cx - bx) * (cx - bx) + (cy - by) * (cy - by);
    if (dist1 < dist2) {
      distanceSegment = sqrt(dist1);
    } else {
      distanceSegment = sqrt(dist2);
    }
  }
  return distanceSegment;
}


x86 assembly (clang, -O0):
<DistanceFromLine>:
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  %xmm4,-0x14(%rbp)
movss  %xmm5,-0x18(%rbp)
movss  -0x4(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
movss  -0x8(%rbp),%xmm1
subss  -0x10(%rbp),%xmm1
movss  -0x18(%rbp),%xmm3
subss  -0x10(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
subss  -0x10(%rbp),%xmm1
movss  -0x18(%rbp),%xmm3
subss  -0x10(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x10(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
movss  -0xc(%rbp),%xmm1
subss  -0x4(%rbp),%xmm1
movss  -0x18(%rbp),%xmm3
subss  -0x10(%rbp),%xmm3
mulss  %xmm3,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x3c(%rbp)
movss  -0x20(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x24(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     126e <DistanceFromLine+0x14e>
movss  0xdab(%rip),%xmm0
ucomiss -0x24(%rbp),%xmm0
jb     126e <DistanceFromLine+0x14e>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    131b <DistanceFromLine+0x1fb>
movss  -0x4(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
subss  -0xc(%rbp),%xmm2
movss  -0x8(%rbp),%xmm1
subss  -0x10(%rbp),%xmm1
movss  -0x8(%rbp),%xmm3
subss  -0x10(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x4(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
subss  -0x14(%rbp),%xmm2
movss  -0x8(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
movss  -0x8(%rbp),%xmm3
subss  -0x18(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1307 <DistanceFromLine+0x1e7>
movss  -0x34(%rbp),%xmm0
call   1040 <sqrt@plt>
movss  %xmm0,-0x30(%rbp)
jmp    1316 <DistanceFromLine+0x1f6>
movss  -0x38(%rbp),%xmm0
call   1040 <sqrt@plt>
movss  %xmm0,-0x30(%rbp)
jmp    131b <DistanceFromLine+0x1fb>
movss  -0x30(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DistanceFromLine>:
sub    $0x88,%rsp
movaps %xmm0,%xmm8
movaps %xmm0,%xmm11
subss  %xmm2,%xmm11
movaps %xmm4,%xmm10
subss  %xmm2,%xmm10
movaps %xmm1,%xmm9
subss  %xmm3,%xmm9
movaps %xmm5,%xmm12
subss  %xmm3,%xmm12
movaps %xmm9,%xmm0
mulss  %xmm12,%xmm0
movaps %xmm11,%xmm6
mulss  %xmm10,%xmm6
addss  %xmm0,%xmm6
movaps %xmm12,%xmm0
mulss  %xmm12,%xmm0
movaps %xmm10,%xmm13
mulss  %xmm10,%xmm13
addss  %xmm0,%xmm13
divss  %xmm13,%xmm6
xorps  %xmm7,%xmm7
ucomiss %xmm7,%xmm13
jb     1190 <DistanceFromLine+0x80>
xorps  %xmm0,%xmm0
sqrtss %xmm13,%xmm0
ucomiss %xmm7,%xmm6
jae    1231 <DistanceFromLine+0x121>
jmp    1268 <DistanceFromLine+0x158>
movaps %xmm13,%xmm0
movaps %xmm3,0x70(%rsp)
movaps %xmm11,0x60(%rsp)
movaps %xmm8,0x50(%rsp)
movaps %xmm1,0x40(%rsp)
movaps %xmm9,0x30(%rsp)
movss  %xmm5,0x1c(%rsp)
movss  %xmm2,0x18(%rsp)
movss  %xmm4,0x14(%rsp)
movss  %xmm10,0x10(%rsp)
movss  %xmm12,0xc(%rsp)
movss  %xmm13,0x8(%rsp)
movaps %xmm6,0x20(%rsp)
call   1030 <sqrt@plt>
xorps  %xmm7,%xmm7
movaps 0x20(%rsp),%xmm6
movss  0x8(%rsp),%xmm13
movss  0xc(%rsp),%xmm12
movss  0x10(%rsp),%xmm10
movss  0x14(%rsp),%xmm4
movss  0x18(%rsp),%xmm2
movss  0x1c(%rsp),%xmm5
movaps 0x30(%rsp),%xmm9
movaps 0x40(%rsp),%xmm1
movaps 0x50(%rsp),%xmm8
movaps 0x60(%rsp),%xmm11
movaps 0x70(%rsp),%xmm3
ucomiss %xmm7,%xmm6
jb     1268 <DistanceFromLine+0x158>
movss  0xdc7(%rip),%xmm7
ucomiss %xmm6,%xmm7
jb     1268 <DistanceFromLine+0x158>
subss  %xmm1,%xmm3
subss  %xmm8,%xmm2
mulss  %xmm2,%xmm12
mulss  %xmm10,%xmm3
subss  %xmm12,%xmm3
divss  %xmm13,%xmm3
andps  0xdae(%rip),%xmm3
mulss  %xmm0,%xmm3
jmp    12b6 <DistanceFromLine+0x1a6>
subss  %xmm4,%xmm8
subss  %xmm5,%xmm1
unpcklps %xmm1,%xmm9
mulps  %xmm9,%xmm9
unpcklps %xmm8,%xmm11
mulps  %xmm11,%xmm11
addps  %xmm9,%xmm11
movaps %xmm11,%xmm0
shufps $0x55,%xmm11,%xmm0
ucomiss %xmm11,%xmm0
jbe    12a7 <DistanceFromLine+0x197>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm11
jb     12c1 <DistanceFromLine+0x1b1>
xorps  %xmm3,%xmm3
sqrtss %xmm11,%xmm3
jmp    12b6 <DistanceFromLine+0x1a6>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12c5 <DistanceFromLine+0x1b5>
xorps  %xmm3,%xmm3
sqrtss %xmm0,%xmm3
movaps %xmm3,%xmm0
add    $0x88,%rsp
ret
movaps %xmm11,%xmm0
add    $0x88,%rsp
jmp    1030 <sqrt@plt>

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

LLVM IR (-O2):
define float @DistanceFromLine(float %0, float %1, float %2, float %3, float %4, float %5) {
%7 = fsub float %0, %2
%8 = fsub float %4, %2
%9 = fsub float %1, %3
%10 = fsub float %5, %3
%11 = fmul float %9, %10
%12 = tail call float @llvm.fmuladd.f32(float %7, float %8, float %11)
%13 = fmul float %10, %10
%14 = tail call float @llvm.fmuladd.f32(float %8, float %8, float %13)
%15 = fdiv float %12, %14
%16 = tail call float @sqrt(float %14)
%17 = fcmp oge float %15, 0.000000e+00
%18 = fcmp ole float %15, 1.000000e+00
%19 = and i1 %17, %18
br i1 %19, label %20, label %29
20: ; preds = %6
%21 = fsub float %3, %1
%22 = fsub float %2, %0
%23 = fneg float %22
%24 = fmul float %10, %23
%25 = tail call float @llvm.fmuladd.f32(float %21, float %8, float %24)
%26 = fdiv float %25, %14
%27 = tail call float @llvm.fabs.f32(float %26)
%28 = fmul float %27, %16
br label %45
29: ; preds = %6
%30 = fsub float %0, %4
%31 = fsub float %1, %5
%32 = insertelement <2 x float> poison, float %9, i64 0
%33 = insertelement <2 x float> %32, float %31, i64 1
%34 = fmul <2 x float> %33, %33
%35 = insertelement <2 x float> poison, float %7, i64 0
%36 = insertelement <2 x float> %35, float %30, i64 1
%37 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %36, <2 x float> %36, <2 x float> %34)
%38 = extractelement <2 x float> %37, i64 0
%39 = extractelement <2 x float> %37, i64 1
%40 = fcmp olt float %38, %39
br i1 %40, label %41, label %43
41: ; preds = %29
%42 = tail call float @sqrt(float %38)
br label %45
43: ; preds = %29
%44 = tail call float @sqrt(float %39)
br label %45
45: ; preds = %41, %43, %20
%46 = phi float [ %28, %20 ], [ %42, %41 ], [ %44, %43 ]
ret float %46
}