
"""simple docstring"""




from collections.abc import Iterable
from typing import Any





class  snake_case     :

							def __init__(self       ,       SCREAMING_SNAKE_CASE_ = None    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = value
									SCREAMING_SNAKE_CASE_						 = None  # Added in order to delete a node easier
									SCREAMING_SNAKE_CASE_						 = None
									SCREAMING_SNAKE_CASE_						 = None







							def __repr__(self    ):

									"""simple docstring"""







									from pprint import pformat

									if self.left is None and self.right is None:
											return str(self.value    )
									return pformat({f'{self.value}': (self.left, self.right)}       ,       indent=1    )







class  snake_case     :

							def __init__(self       ,       SCREAMING_SNAKE_CASE_ = None    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = root

							def __str__(self    ):

									"""simple docstring"""







									return str(self.root    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									if new_children is not None:  # reset its kids
											SCREAMING_SNAKE_CASE_						 = node.parent
									if node.parent is not None:  # reset its parent
											if self.is_right(SCREAMING_SNAKE_CASE_    ):  # If it is the right children
													SCREAMING_SNAKE_CASE_						 = new_children
											else:
													SCREAMING_SNAKE_CASE_						 = new_children
									else:
											SCREAMING_SNAKE_CASE_						 = new_children

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									if node.parent and node.parent.right:
											return node == node.parent.right
									return False

							def _lowercase					(self    ):

									"""simple docstring"""







									return self.root is None

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = Node(SCREAMING_SNAKE_CASE_    )  # create a new Node
									if self.empty():  # if Tree is empty
											SCREAMING_SNAKE_CASE_						 = new_node  # set its root
									else:  # Tree is not empty
											SCREAMING_SNAKE_CASE_						 = self.root  # from root
											if parent_node is None:
													return
											while True:  # While we don't get to a leaf
													if value < parent_node.value:  # We go left
															if parent_node.left is None:
																	SCREAMING_SNAKE_CASE_						 = new_node  # We insert the new node in a leaf
																	break
															else:
																	SCREAMING_SNAKE_CASE_						 = parent_node.left
													else:
															if parent_node.right is None:
																	SCREAMING_SNAKE_CASE_						 = new_node
																	break
															else:
																	SCREAMING_SNAKE_CASE_						 = parent_node.right
											SCREAMING_SNAKE_CASE_						 = parent_node

							def _lowercase					(self       ,       *SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									for value in values:
											self.__insert(SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									if self.empty():
											raise IndexError('''Warning: Tree is empty! please use another.'''    )
									else:
											SCREAMING_SNAKE_CASE_						 = self.root
											# use lazy evaluation here to avoid NoneType Attribute error
											while node is not None and node.value is not value:
													SCREAMING_SNAKE_CASE_						 = node.left if value < node.value else node.right
											return node

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_ = None    ):

									"""simple docstring"""







									if node is None:
											if self.root is None:
													return None
											SCREAMING_SNAKE_CASE_						 = self.root

									if not self.empty():
											while node.right is not None:
													SCREAMING_SNAKE_CASE_						 = node.right
									return node

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_ = None    ):

									"""simple docstring"""







									if node is None:
											SCREAMING_SNAKE_CASE_						 = self.root
									if self.root is None:
											return None
									if not self.empty():
											SCREAMING_SNAKE_CASE_						 = self.root
											while node.left is not None:
													SCREAMING_SNAKE_CASE_						 = node.left
									return node

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.search(SCREAMING_SNAKE_CASE_    )  # Look for the node with that label
									if node is not None:
											if node.left is None and node.right is None:  # If it has no children
													self.__reassign_nodes(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											elif node.left is None:  # Has only right children
													self.__reassign_nodes(SCREAMING_SNAKE_CASE_       ,       node.right    )
											elif node.right is None:  # Has only left children
													self.__reassign_nodes(SCREAMING_SNAKE_CASE_       ,       node.left    )
											else:
													SCREAMING_SNAKE_CASE_						 = self.get_max(
													    node.left    )  # Gets the max value of the left branch
													self.remove(tmp_node.value    )  # type: ignore
													SCREAMING_SNAKE_CASE_						 = (
													    tmp_node.value  # type: ignore
													)  # Assigns the value to the node to delete and keep tree structure

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									if node is not None:
											yield node  # Preorder Traversal
											yield from self.preorder_traverse(node.left    )
											yield from self.preorder_traverse(node.right    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_=None    ):

									"""simple docstring"""







									if traversal_function is None:
											return self.preorder_traverse(self.root    )
									else:
											return traversal_function(self.root    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									if node:
											self.inorder(SCREAMING_SNAKE_CASE_       ,       node.left    )
											arr.append(node.value    )
											self.inorder(SCREAMING_SNAKE_CASE_       ,       node.right    )







							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = []
									self.inorder(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )  # append all values to list using inorder traversal
									return arr[k - 1]







def        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = []
		if curr_node is not None:
				SCREAMING_SNAKE_CASE_						 = postorder(curr_node.left    ) + postorder(curr_node.right    ) + [curr_node]
		return node_list



def        _lowerCamelCase ( ):
		SCREAMING_SNAKE_CASE_						 = (8, 3, 6, 1, 10, 14, 13, 4, 7)
		SCREAMING_SNAKE_CASE_						 = BinarySearchTree()
		for i in testlist:
				t.insert(__a    )

		# Prints all the elements of the list in order traversal
		print(__a    )

		if t.search(6    ) is not None:
				print('''The value 6 exists'''    )
		else:
				print('''The value 6 doesn\'t exist'''    )

		if t.search(-1    ) is not None:
				print('''The value -1 exists'''    )
		else:
				print('''The value -1 doesn\'t exist'''    )

		if not t.empty():
				print('''Max Value: ''',							t.get_max().value    )  # type: ignore
				print('''Min Value: ''',							t.get_min().value    )  # type: ignore

		for i in testlist:
				t.remove(__a    )
				print(__a    )


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)

"""simple docstring"""




from __future__ import annotations

import typing
from collections import Counter



def        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = Counter()
		for base in range(1,							max_perimeter + 1    ):
				for perpendicular in range(__a,							max_perimeter + 1    ):
						SCREAMING_SNAKE_CASE_						 = (base * base + perpendicular * perpendicular) ** 0.5
						if hypotenuse == int(__a    ):
								SCREAMING_SNAKE_CASE_						 = int(base + perpendicular + hypotenuse    )
								if perimeter > max_perimeter:
										continue
								triplets[perimeter] += 1
		return triplets



def        _lowerCamelCase ( __a = 1_000    ):
		SCREAMING_SNAKE_CASE_						 = pythagorean_triple(__a    )
		return triplets.most_common(1    )[0][0]


if __name__ == "__main__":
						print(f'''Perimeter {solution()} has maximum solutions''')