#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 */
scalar_t__ point_in_rectangle_full(float, float, float, float, float, float);
int collision_radius_to_line_segment(float x1, float y1, float x2, float y2,
                                     float px, float py, float radius) {
  if (point_in_rectangle_full(px, py, x1 - radius, y1 - radius, x2 + radius,
                              y2 + radius)) {
    float dx = x2 - x1;
    float dy = y2 - y1;
    float d2 = dx * dx + dy * dy;
    float ex = px - x1;
    float ey = py - y1;
    float scale = (dx * ex + dy * ey) / d2;
    float dist2;
    if (scale <= 0.0) {
      dist2 = ex * ex + ey * ey;
    } else if (scale >= 1.0) {
      float fx = px - x2;
      float fy = py - y2;
      dist2 = fx * fx + fy * fy;
    } else {
      float temp = dy * px - dx * py - x1 * y2 + x2 * y1;
      dist2 = temp * temp / d2;
    }
    return dist2 < radius * radius;
  }
  return 0;
}


x86 assembly (clang, -O0):
<collision_radius_to_line_segment>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movss  %xmm0,-0x8(%rbp)
movss  %xmm1,-0xc(%rbp)
movss  %xmm2,-0x10(%rbp)
movss  %xmm3,-0x14(%rbp)
movss  %xmm4,-0x18(%rbp)
movss  %xmm5,-0x1c(%rbp)
movss  %xmm6,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
subss  -0x20(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
subss  -0x20(%rbp),%xmm3
movss  -0x10(%rbp),%xmm4
addss  -0x20(%rbp),%xmm4
movss  -0x14(%rbp),%xmm5
addss  -0x20(%rbp),%xmm5
call   1030 <point_in_rectangle_full@plt>
cmp    $0x0,%rax
je     1334 <collision_radius_to_line_segment+0x224>
movss  -0x10(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x24(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     123b <collision_radius_to_line_segment+0x12b>
movss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1312 <collision_radius_to_line_segment+0x202>
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdb4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     129a <collision_radius_to_line_segment+0x18a>
movss  -0x18(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    130d <collision_radius_to_line_segment+0x1fd>
movss  -0x28(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x8(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x10(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1312 <collision_radius_to_line_segment+0x202>
movss  -0x3c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
ucomiss %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    133b <collision_radius_to_line_segment+0x22b>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<collision_radius_to_line_segment>:
sub    $0x78,%rsp
movaps %xmm5,%xmm8
movaps %xmm4,%xmm7
movaps %xmm3,%xmm5
movaps %xmm2,%xmm4
movaps %xmm0,0x10(%rsp)
movaps %xmm0,%xmm2
subss  %xmm6,%xmm2
movaps %xmm1,0x30(%rsp)
movaps %xmm1,%xmm3
subss  %xmm6,%xmm3
movaps %xmm4,0x20(%rsp)
addss  %xmm6,%xmm4
movaps %xmm5,0x40(%rsp)
movss  %xmm6,0xc(%rsp)
addss  %xmm6,%xmm5
movaps %xmm7,0x50(%rsp)
movaps %xmm7,%xmm0
movaps %xmm8,0x60(%rsp)
movaps %xmm8,%xmm1
call   1030 <point_in_rectangle_full@plt>
test   %rax,%rax
je     1232 <collision_radius_to_line_segment+0x122>
movaps 0x50(%rsp),%xmm11
movaps %xmm11,%xmm0
movaps 0x20(%rsp),%xmm7
unpcklps %xmm7,%xmm0
movaps 0x10(%rsp),%xmm12
movaps %xmm12,%xmm1
shufps $0x0,%xmm12,%xmm1
subps  %xmm1,%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps 0x60(%rsp),%xmm8
movaps %xmm8,%xmm4
movaps 0x40(%rsp),%xmm9
unpcklps %xmm9,%xmm4
movaps 0x30(%rsp),%xmm10
movaps %xmm10,%xmm2
shufps $0x0,%xmm10,%xmm2
subps  %xmm2,%xmm4
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
movaps %xmm2,%xmm3
mulps  %xmm4,%xmm3
movaps %xmm1,%xmm5
mulps  %xmm0,%xmm5
addps  %xmm3,%xmm5
movaps %xmm5,%xmm3
shufps $0x55,%xmm5,%xmm3
divss  %xmm3,%xmm5
xorps  %xmm6,%xmm6
ucomiss %xmm5,%xmm6
jae    1239 <collision_radius_to_line_segment+0x129>
movaps %xmm7,%xmm6
movaps %xmm11,%xmm7
ucomiss 0xe07(%rip),%xmm5
movss  0xc(%rsp),%xmm4
jae    124d <collision_radius_to_line_segment+0x13d>
movaps %xmm12,%xmm11
mulss  %xmm8,%xmm1
mulss  %xmm7,%xmm2
subss  %xmm1,%xmm2
mulss  %xmm9,%xmm11
subss  %xmm11,%xmm2
mulss  %xmm10,%xmm6
addss  %xmm2,%xmm6
mulss  %xmm6,%xmm6
divss  %xmm3,%xmm6
movaps %xmm6,%xmm0
jmp    1267 <collision_radius_to_line_segment+0x157>
xor    %eax,%eax
add    $0x78,%rsp
ret
mulss  %xmm4,%xmm4
mulss  %xmm0,%xmm0
addss  %xmm4,%xmm0
movss  0xc(%rsp),%xmm4
jmp    1267 <collision_radius_to_line_segment+0x157>
subss  %xmm6,%xmm7
subss  %xmm9,%xmm8
mulss  %xmm8,%xmm8
mulss  %xmm7,%xmm7
addss  %xmm8,%xmm7
movaps %xmm7,%xmm0
mulss  %xmm4,%xmm4
xor    %eax,%eax
ucomiss %xmm0,%xmm4
seta   %al
add    $0x78,%rsp
ret

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

LLVM IR (-O2):
define i32 @collision_radius_to_line_segment(float %0, float %1, float %2, float %3, float %4, float %5, float %6) {
%8 = fsub float %0, %6
%9 = fsub float %1, %6
%10 = fadd float %2, %6
%11 = fadd float %3, %6
%12 = tail call i64 @point_in_rectangle_full(float %4, float %5, float %8, float %9, float %10, float %11)
%13 = icmp eq i64 %12, 0
br i1 %13, label %61, label %14
14: ; preds = %7
%15 = insertelement <2 x float> poison, float %4, i64 0
%16 = insertelement <2 x float> %15, float %2, i64 1
%17 = insertelement <2 x float> poison, float %0, i64 0
%18 = shufflevector <2 x float> %17, <2 x float> poison, <2 x i32> zeroinitializer
%19 = fsub <2 x float> %16, %18
%20 = insertelement <2 x float> poison, float %5, i64 0
%21 = insertelement <2 x float> %20, float %3, i64 1
%22 = insertelement <2 x float> poison, float %1, i64 0
%23 = shufflevector <2 x float> %22, <2 x float> poison, <2 x i32> zeroinitializer
%24 = fsub <2 x float> %21, %23
%25 = extractelement <2 x float> %24, i64 1
%26 = shufflevector <2 x float> %24, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%27 = fmul <2 x float> %26, %24
%28 = extractelement <2 x float> %19, i64 1
%29 = shufflevector <2 x float> %19, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%30 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %29, <2 x float> %19, <2 x float> %27)
%31 = extractelement <2 x float> %30, i64 0
%32 = extractelement <2 x float> %30, i64 1
%33 = fdiv float %31, %32
%34 = fcmp ugt float %33, 0.000000e+00
br i1 %34, label %40, label %35
35: ; preds = %14
%36 = fmul <2 x float> %24, %24
%37 = extractelement <2 x float> %36, i64 0
%38 = extractelement <2 x float> %19, i64 0
%39 = tail call float @llvm.fmuladd.f32(float %38, float %38, float %37)
br label %56
40: ; preds = %14
%41 = fcmp ult float %33, 1.000000e+00
br i1 %41, label %47, label %42
42: ; preds = %40
%43 = fsub float %4, %2
%44 = fsub float %5, %3
%45 = fmul float %44, %44
%46 = tail call float @llvm.fmuladd.f32(float %43, float %43, float %45)
br label %56
47: ; preds = %40
%48 = fneg float %28
%49 = fmul float %48, %5
%50 = tail call float @llvm.fmuladd.f32(float %25, float %4, float %49)
%51 = fneg float %0
%52 = tail call float @llvm.fmuladd.f32(float %51, float %3, float %50)
%53 = tail call float @llvm.fmuladd.f32(float %2, float %1, float %52)
%54 = fmul float %53, %53
%55 = fdiv float %54, %32
br label %56
56: ; preds = %42, %47, %35
%57 = phi float [ %39, %35 ], [ %46, %42 ], [ %55, %47 ]
%58 = fmul float %6, %6
%59 = fcmp olt float %57, %58
%60 = zext i1 %59 to i32
br label %61
61: ; preds = %7, %56
%62 = phi i32 [ %60, %56 ], [ 0, %7 ]
ret i32 %62
}