

"""simple docstring"""






from __future__ import annotations

from collections.abc import Iterable
class       _UpperCAmelCase     :
			def __init__(						self ,						_A ,						_A       )      ->      Tuple:






				'''simple docstring'''







				_UpperCAmelCase      :							List[str]       =   float(_A       ), float(_A       )
			def __eq__(						self ,						_A       )      ->      Union[str, Any]:






				'''simple docstring'''







				return self.x == other.x and self.y == other.y
			def __ne__(						self ,						_A       )      ->      Union[str, Any]:






				'''simple docstring'''







				return not self == other
			def __gt__(						self ,						_A       )      ->      Optional[Any]:






				'''simple docstring'''







				if self.x > other.x:
					return True
				elif self.x == other.x:
					return self.y > other.y
				return False
			def __lt__(						self ,						_A       )      ->      Union[str, Any]:






				'''simple docstring'''







				return not self > other
			def __ge__(						self ,						_A       )      ->      int:






				'''simple docstring'''







				if self.x > other.x:
					return True
				elif self.x == other.x:
					return self.y >= other.y
				return False
			def __le__(						self ,						_A       )      ->      Dict:






				'''simple docstring'''







				if self.x < other.x:
					return True
				elif self.x == other.x:
					return self.y <= other.y
				return False
			def __repr__(						self       )      ->      List[str]:






				'''simple docstring'''







				return f'''({self.x}, {self.y})'''
			def __hash__(						self       )      ->      Any:






				'''simple docstring'''







				return hash(self.x       )
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point] | list[list[float]] | Iterable[list[float]],					)			->     list[Point]:
	_UpperCAmelCase      :							list[Point]       =   []
	if list_of_tuples:
		for p in list_of_tuples:
			if isinstance(_lowerCAmelCase,					_lowerCAmelCase	):
				points.append(_lowerCAmelCase	)
			else:
				try:
					points.append(Point(p[0],					p[1]	)	)
				except (IndexError, TypeError):
					print(
					    f'''Ignoring deformed point {p}. All points'''
					    """ must have at least 2 coordinates."""	)
	return points
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point] | list[list[float]]	)			->     list[Point]:

	if not hasattr(_lowerCAmelCase,					"""__iter__"""	):
		_UpperCAmelCase      :							Any       =   f'''Expecting an iterable object but got an non-iterable type {points}'''
		raise ValueError(_lowerCAmelCase	)

	if not points:
		_UpperCAmelCase      :							Any       =   f'''Expecting a list of points but got {points}'''
		raise ValueError(_lowerCAmelCase	)

	return _construct_points(_lowerCAmelCase	)
def  UpperCamelCase   (     _lowerCAmelCase       :  Point,					_lowerCAmelCase       :  Point,					_lowerCAmelCase       :  Point	)			->     float:
	_UpperCAmelCase      :							Union[str, Any]       =   (a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
	return det
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point]	)			->     list[Point]:
	_UpperCAmelCase      :							List[str]       =   sorted(_validate_input(_lowerCAmelCase	)	)
	_UpperCAmelCase      :							str       =   len(_lowerCAmelCase	)
	_UpperCAmelCase      :							Union[str, Any]       =   set()

	for i in range(n - 1	):
		for j in range(i + 1,					_lowerCAmelCase	):
			_UpperCAmelCase      :							List[str]       =   False
			_UpperCAmelCase      :							Union[str, Any]       =   True
			for k in range(_lowerCAmelCase	):
				if k != i and k != j:
					_UpperCAmelCase      :							Optional[int]       =   _det(points[i],					points[j],					points[k]	)

					if det_k > 0:
						_UpperCAmelCase      :							str       =   True
					elif det_k < 0:
						_UpperCAmelCase      :							Tuple       =   True
					else:
						# point[i], point[j], point[k] all lie on a straight line
						# if point[k] is to the left of point[i] or it's to the
						# right of point[j], then point[i], point[j] cannot be
						# part of the convex hull of A
						if points[k] < points[i] or points[k] > points[j]:
							_UpperCAmelCase      :							Dict       =   False
							break

				if points_left_of_ij and points_right_of_ij:
					_UpperCAmelCase      :							Optional[Any]       =   False
					break

			if ij_part_of_convex_hull:
				convex_set.update([points[i], points[j]]	)

	return sorted(_lowerCAmelCase	)
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point]	)			->     list[Point]:
	_UpperCAmelCase      :							Tuple       =   sorted(_validate_input(_lowerCAmelCase	)	)
	_UpperCAmelCase      :							Dict       =   len(_lowerCAmelCase	)

	# divide all the points into an upper hull and a lower hull
	# the left most point and the right most point are definitely
	# members of the convex hull by definition.
	# use these two anchors to divide all the points into two hulls,
	# an upper hull and a lower hull.

	# all points to the left (above) the line joining the extreme points belong to the
	# upper hull
	# all points to the right (below) the line joining the extreme points below to the
	# lower hull
	# ignore all points on the line joining the extreme points since they cannot be
	# part of the convex hull

	_UpperCAmelCase      :							Optional[Any]       =   points[0]
	_UpperCAmelCase      :							Union[str, Any]       =   points[n - 1]

	_UpperCAmelCase      :							List[str]       =   {left_most_point, right_most_point}
	_UpperCAmelCase      :							Dict       =   []
	_UpperCAmelCase      :							List[Any]       =   []

	for i in range(1,					n - 1	):
		_UpperCAmelCase      :							Dict       =   _det(_lowerCAmelCase,					_lowerCAmelCase,					points[i]	)

		if det > 0:
			upper_hull.append(points[i]	)
		elif det < 0:
			lower_hull.append(points[i]	)

	_construct_hull(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase	)
	_construct_hull(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase	)

	return sorted(_lowerCAmelCase	)
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point],					_lowerCAmelCase       :  Point,					_lowerCAmelCase       :  Point,					_lowerCAmelCase       :  set[Point]	)			->     None:
	if points:
		_UpperCAmelCase      :							Optional[Any]       =   None
		_UpperCAmelCase      :							Optional[int]       =   float("""-inf"""	)
		_UpperCAmelCase      :							Optional[Any]       =   []

		for p in points:
			_UpperCAmelCase      :							Union[str, Any]       =   _det(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase	)

			if det > 0:
				candidate_points.append(_lowerCAmelCase	)

				if det > extreme_point_distance:
					_UpperCAmelCase      :							Dict       =   det
					_UpperCAmelCase      :							Optional[Any]       =   p

		if extreme_point:
			_construct_hull(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase	)
			convex_set.add(_lowerCAmelCase	)
			_construct_hull(_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase	)
def  UpperCamelCase   (     _lowerCAmelCase       :  list[Point]	)			->     list[Point]:
	_UpperCAmelCase      :							Optional[Any]       =   sorted(_validate_input(_lowerCAmelCase	)	)
	_UpperCAmelCase      :							int       =   len(_lowerCAmelCase	)

	_UpperCAmelCase      :							Tuple       =   points[:2]
	for i in range(2,					_lowerCAmelCase	):
		_UpperCAmelCase      :							str       =   _det(convex_hull[1],					convex_hull[0],					points[i]	)
		if det > 0:
			convex_hull.insert(0,					points[i]	)
			break
		elif det < 0:
			convex_hull.append(points[i]	)
			break
		else:
			_UpperCAmelCase      :							Tuple       =   points[i]
	i += 1

	for j in range(_lowerCAmelCase,					_lowerCAmelCase	):
		if (
		    _det(convex_hull[0],					convex_hull[-1],					points[j]	) > 0
		    and _det(convex_hull[-1],					convex_hull[0],					points[1]	) < 0
		):
			# The point lies within the convex hull
			continue

		convex_hull.insert(0,					points[j]	)
		convex_hull.append(points[j]	)
		while _det(convex_hull[0],					convex_hull[1],					convex_hull[2]	) >= 0:
			del convex_hull[1]
		while _det(convex_hull[-1],					convex_hull[-2],					convex_hull[-3]	) <= 0:
			del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
	return sorted(convex_hull[1:] if len(_lowerCAmelCase	) > 3 else convex_hull	)
def  UpperCamelCase   (     )			->     List[Any]:
	_UpperCAmelCase      :							Any       =   [
	    (0, 3),
	    (2, 2),
	    (1, 1),
	    (2, 1),
	    (3, 0),
	    (0, 0),
	    (3, 3),
	    (2, -1),
	    (2, -4),
	    (1, -3),
	]
	# the convex set of points is
	# [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
	_UpperCAmelCase      :							List[str]       =   convex_hull_bf(_lowerCAmelCase	)

	_UpperCAmelCase      :							Optional[Any]       =   convex_hull_recursive(_lowerCAmelCase	)
	assert results_bf == results_recursive

	_UpperCAmelCase      :							List[str]       =   convex_hull_melkman(_lowerCAmelCase	)
	assert results_bf == results_melkman

	print(_lowerCAmelCase	)


if __name__ == "__main__":
						main()








"""simple docstring"""






from math import factorial
def  UpperCamelCase   (     _lowerCAmelCase       :  Dict,					_lowerCAmelCase       :  List[str]	)			->     Dict:
	return factorial(_lowerCAmelCase	) / (factorial(_lowerCAmelCase	) * factorial(n - r	))
def  UpperCamelCase   (     )			->     Tuple:
	_UpperCAmelCase      :							Optional[int]       =   0

	for i in range(1,					101	):
		for j in range(1,					i + 1	):
			if combinations(_lowerCAmelCase,					_lowerCAmelCase	) > 1E6:
				total += 1
	return total


if __name__ == "__main__":
						print(solution())





