




'''simple docstring'''


from ..utils import DummyObject, requires_backends

class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  str							,      *lowerCAmelCase_	:  Dict							,      **lowerCAmelCase_	:  List[Any] )      ->							List[Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  List[Any] )      ->							int:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[str]							,      *lowerCAmelCase_	:  Dict							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							Dict:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Optional[int]							,      *lowerCAmelCase_	:  Union[str, Any]							,      **lowerCAmelCase_	:  Tuple )      ->							Union[str, Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Any							,      *lowerCAmelCase_	:  Dict							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							Dict:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Optional[int]							,      *lowerCAmelCase_	:  Union[str, Any]							,      **lowerCAmelCase_	:  str )      ->							int:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  int							,      **lowerCAmelCase_	:  int )      ->							Dict:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  int							,      *lowerCAmelCase_	:  List[Any]							,      **lowerCAmelCase_	:  List[str] )      ->							Tuple:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  str							,      *lowerCAmelCase_	:  Optional[Any]							,      **lowerCAmelCase_	:  str )      ->							Union[str, Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[Any]							,      *lowerCAmelCase_	:  Optional[Any]							,      **lowerCAmelCase_	:  int )      ->							Optional[Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Dict							,      *lowerCAmelCase_	:  int							,      **lowerCAmelCase_	:  List[str] )      ->							Optional[int]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  int							,      *lowerCAmelCase_	:  Any							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							Optional[Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  Dict )      ->							Dict:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Optional[int]							,      *lowerCAmelCase_	:  List[Any]							,      **lowerCAmelCase_	:  int )      ->							str:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  int							,      *lowerCAmelCase_	:  str							,      **lowerCAmelCase_	:  Tuple )      ->							int:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  Tuple )      ->							Union[str, Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Optional[Any]							,      *lowerCAmelCase_	:  str							,      **lowerCAmelCase_	:  int )      ->							Any:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[Any]							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  List[str] )      ->							str:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  List[Any]							,      **lowerCAmelCase_	:  int )      ->							Any:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Tuple							,      *lowerCAmelCase_	:  Dict							,      **lowerCAmelCase_	:  Any )      ->							Optional[int]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[str]							,      *lowerCAmelCase_	:  Dict							,      **lowerCAmelCase_	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[Any]							,      *lowerCAmelCase_	:  Union[str, Any]							,      **lowerCAmelCase_	:  Any )      ->							List[str]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[Any]							,      *lowerCAmelCase_	:  Union[str, Any]							,      **lowerCAmelCase_	:  Dict )      ->							Tuple:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Optional[int]							,      *lowerCAmelCase_	:  Tuple							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							List[str]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  str							,      *lowerCAmelCase_	:  int							,      **lowerCAmelCase_	:  Tuple )      ->							List[str]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Any							,      *lowerCAmelCase_	:  str							,      **lowerCAmelCase_	:  Optional[int] )      ->							int:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  int							,      *lowerCAmelCase_	:  str							,      **lowerCAmelCase_	:  Union[str, Any] )      ->							List[str]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  int							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  Dict )      ->							List[Any]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[str]							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  List[str] )      ->							Optional[int]:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  List[Any]							,      *lowerCAmelCase_	:  int							,      **lowerCAmelCase_	:  List[Any] )      ->							str:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )



class       A   (		metaclass=_a   ):
							lowercase_          =    ['sentencepiece']







							def __init__(  self	:  Any							,      *lowerCAmelCase_	:  List[str]							,      **lowerCAmelCase_	:  Optional[int] )      ->							Any:


														"""simple docstring"""


														requires_backends(self							,      ['''sentencepiece'''] )







'''simple docstring'''


def 		snake_case_   (UpperCamelCase	:  str			,						UpperCamelCase	:  Any				):





							'''simple docstring'''


							return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2
def 		snake_case_   (UpperCamelCase	:  Any			,						UpperCamelCase	:  str=0				):





							'''simple docstring'''


							return sorted(UpperCamelCase			,						key=lambda UpperCamelCase				: x[column]				)
def 		snake_case_   (UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  Any			,						UpperCamelCase	:  Union[str, Any]=float('''inf'''				)				):





							'''simple docstring'''


							for i in range(points_counts - 1				):
														for j in range(i + 1			,						UpperCamelCase				):
																					_a     					=    euclidean_distance_sqr(points[i]			,						points[j]				)
																					if current_dis < min_dis:
																												_a     					=    current_dis
							return min_dis
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  Tuple			,						UpperCamelCase	:  List[str]=float('''inf'''				)				):





							'''simple docstring'''


							for i in range(min(6			,						points_counts - 1				)			,						UpperCamelCase				):
														for j in range(max(0			,						i - 6				)			,						UpperCamelCase				):
																					_a     					=    euclidean_distance_sqr(points[i]			,						points[j]				)
																					if current_dis < min_dis:
																												_a     					=    current_dis
							return min_dis
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  List[Any]			,						UpperCamelCase	:  int				):





							'''simple docstring'''


							if points_counts <= 3:
														return dis_between_closest_pair(UpperCamelCase			,						UpperCamelCase				)

							# recursion
							_a     					=    points_counts // 2
							_a     					=    closest_pair_of_points_sqr(
							    UpperCamelCase			,						points_sorted_on_y[:mid]			,						UpperCamelCase				)
							_a     					=    closest_pair_of_points_sqr(
							    UpperCamelCase			,						points_sorted_on_y[mid:]			,						points_counts - mid				)
							_a     					=    min(UpperCamelCase			,						UpperCamelCase				)
							_a     					=    []
							for point in points_sorted_on_x:
														if abs(point[0] - points_sorted_on_x[mid][0]				) < closest_pair_dis:
																					cross_strip.append(UpperCamelCase				)

							_a     					=    dis_between_closest_in_strip(
							    UpperCamelCase			,						len(UpperCamelCase				)			,						UpperCamelCase				)
							return min(UpperCamelCase			,						UpperCamelCase				)
def 		snake_case_   (UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  List[str]				):





							'''simple docstring'''


							_a     					=    column_based_sort(UpperCamelCase			,						column=0				)
							_a     					=    column_based_sort(UpperCamelCase			,						column=1				)
							return (
							    closest_pair_of_points_sqr(
							        UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase				)
							) ** 0.5


if __name__ == "__main__":
				_snake_case				:				int       							=		[(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
				print('Distance:', closest_pair_of_points(points, len(points)))

