



"""simple docstring"""

from collections.abc import Iterable
from typing import Any




class SCREAMING_SNAKE_CASE__					:



						def __init__(self						,     _lowercase = None							):





													'''simple docstring'''

													__a		:		int									=       value
													__a		:		Node | None									=       None  # Added in order to delete a node easier
													__a		:		Node | None									=       None
													__a		:		Node | None									=       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 SCREAMING_SNAKE_CASE__					:



						def __init__(self						,     _lowercase = None							):





													'''simple docstring'''

													__a		:		str									=       root



						def __str__(self							):





													'''simple docstring'''

													return str(self.root							)



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													if new_children is not None:  # reset its kids
																				__a		:		Tuple									=       node.parent
													if node.parent is not None:  # reset its parent
																				if self.is_right(_lowercase							):  # If it is the right children
																											__a		:		Dict									=       new_children
																				else:
																											__a		:		List[Any]									=       new_children
													else:
																				__a		:		str									=       new_children



						def     lowerCAmelCase__(self						,     _lowercase							):





													'''simple docstring'''

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



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													return self.root is None



						def     lowerCAmelCase__(self						,     _lowercase							):





													'''simple docstring'''

													__a		:		Optional[Any]									=       Node(_lowercase							)  # create a new Node
													if self.empty():  # if Tree is empty
																				__a		:		Any									=       new_node  # set its root
													else:  # Tree is not empty
																				__a		:		Dict									=       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:
																																									__a		:		Optional[int]									=       new_node  # We insert the new node in a leaf
																																									break
																																		else:
																																									__a		:		Optional[int]									=       parent_node.left
																											else:
																																		if parent_node.right is None:
																																									__a		:		Optional[Any]									=       new_node
																																									break
																																		else:
																																									__a		:		str									=       parent_node.right
																				__a		:		Union[str, Any]									=       parent_node



						def     lowerCAmelCase__(self						,     *_lowercase							):





													'''simple docstring'''

													for value in values:
																				self.__insert(_lowercase							)



						def     lowerCAmelCase__(self						,     _lowercase							):





													'''simple docstring'''

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



						def     lowerCAmelCase__(self						,     _lowercase = None							):





													'''simple docstring'''

													if node is None:
																				if self.root is None:
																											return None
																				__a		:		Union[str, Any]									=       self.root

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



						def     lowerCAmelCase__(self						,     _lowercase = None							):





													'''simple docstring'''

													if node is None:
																				__a		:		Any									=       self.root
													if self.root is None:
																				return None
													if not self.empty():
																				__a		:		str									=       self.root
																				while node.left is not None:
																											__a		:		List[Any]									=       node.left
													return node



						def     lowerCAmelCase__(self						,     _lowercase							):





													'''simple docstring'''

													__a		:		int									=       self.search(_lowercase							)  # 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(_lowercase						,     _lowercase							)
																				elif node.left is None:  # Has only right children
																											self.__reassign_nodes(_lowercase						,     node.right							)
																				elif node.right is None:  # Has only left children
																											self.__reassign_nodes(_lowercase						,     node.left							)
																				else:
																											__a		:		Optional[Any]									=       self.get_max(
																											    node.left							)  # Gets the max value of the left branch
																											self.remove(tmp_node.value							)  # type: ignore
																											__a		:		Tuple									=       (
																											    tmp_node.value  # type: ignore
																											)  # Assigns the value to the node to delete and keep tree structure



						def     lowerCAmelCase__(self						,     _lowercase							):





													'''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     lowerCAmelCase__(self						,     _lowercase=None							):





													'''simple docstring'''

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



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

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





						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

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







def       __magic_name__    (   _lowerCamelCase				: Node | None					):
							__a		:		str									=       []
							if curr_node is not None:
														__a		:		Dict									=       postorder(curr_node.left					) + postorder(curr_node.right					) + [curr_node]
							return node_list





def       __magic_name__    (   ):
							__a		:		Dict									=       (8, 3, 6, 1, 1_0, 1_4, 1_3, 4, 7)
							__a		:		List[str]									=       BinarySearchTree()
							for i in testlist:
														t.insert(_lowerCamelCase					)

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

							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(_lowerCamelCase					)
														print(_lowerCamelCase					)


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)






"""simple docstring"""

import os





def       __magic_name__    (   _lowerCamelCase				: Dict					):
							__a		:		List[str]									=       len(grid[0]					)
							__a		:		int									=       len(_lowerCamelCase					)

							__a		:		Tuple									=       0
							__a		:		List[Any]									=       0
							__a		:		List[str]									=       0

							# Check vertically, horizontally, diagonally at the same time (only works
							# for nxn grid)
							for i in range(_lowerCamelCase					):
														for j in range(n_rows - 3					):
																					__a		:		List[Any]									=       grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
																					__a		:		Tuple									=       grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

																					# Left-to-right diagonal (\) product
																					if i < n_columns - 3:
																												__a		:		List[Any]									=       (
																												    grid[i][j]
																												    * grid[i + 1][j + 1]
																												    * grid[i + 2][j + 2]
																												    * grid[i + 3][j + 3]
																												)

																					# Right-to-left diagonal(/) product
																					if i > 2:
																												__a		:		List[Any]									=       (
																												    grid[i][j]
																												    * grid[i - 1][j + 1]
																												    * grid[i - 2][j + 2]
																												    * grid[i - 3][j + 3]
																												)

																					__a		:		str									=       max(
																					    _lowerCamelCase  ,       _lowerCamelCase  ,       _lowerCamelCase  ,       _lowerCamelCase					)
																					if max_product > largest:
																												__a		:		Optional[Any]									=       max_product

							return largest





def       __magic_name__    (   ):
							__a		:		Tuple									=       []
							with open(os.path.dirname(_lowerCamelCase					) + """/grid.txt"""					) as file:
														for line in file:
																					grid.append(line.strip("""\n"""					).split(""" """					)					)

							__a		:		Tuple									=       [[int(_lowerCamelCase					) for i in grid[j]] for j in range(len(_lowerCamelCase					)					)]

							return largest_product(_lowerCamelCase					)


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

