
"""simple docstring"""




from __future__ import annotations

import math
import random
from typing import Any





class 							UpperCAmelCase				:




	'''simple docstring'''





	def __init__(	self :			str			):
					__A             =			[]
					__A             =			0
					__A             =			0






	def     UpperCamelCase_  (	self :			Optional[int]			):
					return self.head == self.tail






	def     UpperCamelCase_  (	self :			Tuple							,A :			Any			):
					self.data.append(A			)
					__A             =			self.tail + 1






	def     UpperCamelCase_  (	self :			Dict			):
					__A             =			self.data[self.head]
					__A             =			self.head + 1
					return ret






	def     UpperCamelCase_  (	self :			int			):
					return self.tail - self.head







	def     UpperCamelCase_  (	self :			Optional[int]			):
					print(self.data			)
					print("**************"			)
					print(self.data[self.head : self.tail]			)





class 							UpperCAmelCase				:




	'''simple docstring'''





	def __init__(	self :			Optional[Any]							,A :			Any			):
					__A             =			data
					__A             =			None
					__A             =			None
					__A             =			1






	def     UpperCamelCase_  (	self :			Dict			):
					return self.data






	def     UpperCamelCase_  (	self :			List[str]			):
					return self.left






	def     UpperCamelCase_  (	self :			List[str]			):
					return self.right






	def     UpperCamelCase_  (	self :			List[str]			):
					return self.height






	def     UpperCamelCase_  (	self :			List[str]							,A :			Any			):
					__A             =			data






	def     UpperCamelCase_  (	self :			Union[str, Any]							,A :			MyNode | None			):
					__A             =			node






	def     UpperCamelCase_  (	self :			Optional[Any]							,A :			MyNode | None			):
					__A             =			node







	def     UpperCamelCase_  (	self :			Dict							,A :			int			):
					__A             =			height





def 						UpperCAmelCase      (     a_						)		->     int:







				"""simple docstring"""



				if node is None:
								return 0
				return node.get_height()


def 						UpperCAmelCase      (     a_		,       a_						)		->     int:







				"""simple docstring"""



				if a > b:
								return a
				return b


def 						UpperCAmelCase      (     a_						)		->     MyNode:







				"""simple docstring"""



				print("left rotation node:"		,       node.get_data()						)
				__A             =			node.get_left()
				assert ret is not None
				node.set_left(ret.get_right()						)
				ret.set_right(a_						)
				__A             =			my_max(get_height(node.get_right()						)		,       get_height(node.get_left()						)						) + 1
				node.set_height(a_						)
				__A             =			my_max(get_height(ret.get_right()						)		,       get_height(ret.get_left()						)						) + 1
				ret.set_height(a_						)
				return ret


def 						UpperCAmelCase      (     a_						)		->     MyNode:







				"""simple docstring"""



				print("right rotation node:"		,       node.get_data()						)
				__A             =			node.get_right()
				assert ret is not None
				node.set_right(ret.get_left()						)
				ret.set_left(a_						)
				__A             =			my_max(get_height(node.get_right()						)		,       get_height(node.get_left()						)						) + 1
				node.set_height(a_						)
				__A             =			my_max(get_height(ret.get_right()						)		,       get_height(ret.get_left()						)						) + 1
				ret.set_height(a_						)
				return ret


def 						UpperCAmelCase      (     a_						)		->     MyNode:







				"""simple docstring"""



				__A             =			node.get_left()
				assert left_child is not None
				node.set_left(left_rotation(a_						)						)
				return right_rotation(a_						)


def 						UpperCAmelCase      (     a_						)		->     MyNode:







				"""simple docstring"""



				__A             =			node.get_right()
				assert right_child is not None
				node.set_right(right_rotation(a_						)						)
				return left_rotation(a_						)


def 						UpperCAmelCase      (     a_		,       a_						)		->     MyNode | None:







				"""simple docstring"""



				if node is None:
								return MyNode(a_						)
				if data < node.get_data():
								node.set_left(insert_node(node.get_left()		,       a_						)						)
								if (
								    get_height(node.get_left()						) - get_height(node.get_right()						) == 2
								):  # an unbalance detected
												__A             =			node.get_left()
												assert left_child is not None
												if (
												    data < left_child.get_data()
												):  # new node is the left child of the left child
																__A             =			right_rotation(a_						)
												else:
																__A             =			lr_rotation(a_						)
				else:
								node.set_right(insert_node(node.get_right()		,       a_						)						)
								if get_height(node.get_right()						) - get_height(node.get_left()						) == 2:
												__A             =			node.get_right()
												assert right_child is not None
												if data < right_child.get_data():
																__A             =			rl_rotation(a_						)
												else:
																__A             =			left_rotation(a_						)
				__A             =			my_max(get_height(node.get_right()						)		,       get_height(node.get_left()						)						) + 1
				node.set_height(a_						)
				return node


def 						UpperCAmelCase      (     a_						)		->     Any:







				"""simple docstring"""



				while True:
								__A             =			root.get_right()
								if right_child is None:
												break
								__A             =			right_child
				return root.get_data()


def 						UpperCAmelCase      (     a_						)		->     Any:







				"""simple docstring"""



				while True:
								__A             =			root.get_left()
								if left_child is None:
												break
								__A             =			left_child
				return root.get_data()


def 						UpperCAmelCase      (     a_		,       a_						)		->     MyNode | None:







				"""simple docstring"""



				__A             =			root.get_left()
				__A             =			root.get_right()
				if root.get_data() == data:
								if left_child is not None and right_child is not None:
												__A             =			get_left_most(a_						)
												root.set_data(a_						)
												root.set_right(del_node(a_		,       a_						)						)
								elif left_child is not None:
												__A             =			left_child
								elif right_child is not None:
												__A             =			right_child
								else:
												return None
				elif root.get_data() > data:
								if left_child is None:
												print("No such data"						)
												return root
								else:
												root.set_left(del_node(a_		,       a_						)						)
				else:  # root.get_data() < data
								if right_child is None:
												return root
								else:
												root.set_right(del_node(a_		,       a_						)						)

				if get_height(a_						) - get_height(a_						) == 2:
								assert right_child is not None
								if get_height(right_child.get_right()						) > get_height(right_child.get_left()						):
												__A             =			left_rotation(a_						)
								else:
												__A             =			rl_rotation(a_						)
				elif get_height(a_						) - get_height(a_						) == -2:
								assert left_child is not None
								if get_height(left_child.get_left()						) > get_height(left_child.get_right()						):
												__A             =			right_rotation(a_						)
								else:
												__A             =			lr_rotation(a_						)
				__A             =			my_max(get_height(root.get_right()						)		,       get_height(root.get_left()						)						) + 1
				root.set_height(a_						)
				return root





class 							UpperCAmelCase				:




	'''simple docstring'''





	def __init__(	self :			Dict			):
					__A             =			None






	def     UpperCamelCase_  (	self :			List[Any]			):
					return get_height(self.root			)






	def     UpperCamelCase_  (	self :			List[Any]							,A :			Any			):
					print("insert:" + str(A			)			)
					__A             =			insert_node(self.root							,A			)






	def     UpperCamelCase_  (	self :			List[Any]							,A :			Any			):
					print("delete:" + str(A			)			)
					if self.root is None:
									print("Tree is empty!"			)
									return
					__A             =			del_node(self.root							,A			)







	def __str__(	self :			str							,):  # a level traversale, gives a more intuitive look on the tree
					__A             =			""
					__A             =			MyQueue()
					q.push(self.root			)
					__A             =			self.get_height()
					if layer == 0:
									return output
					__A             =			0
					while not q.is_empty():
									__A             =			q.pop()
									__A             =			" " * int(math.pow(2							,layer - 1			)			)
									output += space
									if node is None:
													output += "*"
													q.push(A			)
													q.push(A			)
									else:
													output += str(node.get_data()			)
													q.push(node.get_left()			)
													q.push(node.get_right()			)
									output += space
									__A             =			cnt + 1
									for i in range(1_00			):
													if cnt == math.pow(2							,A			) - 1:
																	__A             =			layer - 1
																	if layer == 0:
																					output += "\n*************************************"
																					return output
																	output += "\n"
																	break
					output += "\n*************************************"
					return output





def 						UpperCAmelCase      (     )		->     None:







				"""simple docstring"""



				import doctest

				doctest.testmod()


if __name__ == "__main__":
					_test()
					SCREAMING_SNAKE_CASE							:List[Any]										=    AVLtree()
					SCREAMING_SNAKE_CASE							:str										=    list(range(10))
					random.shuffle(lst)
					for i in lst:
										t.insert(i)
										print(str(t))
					random.shuffle(lst)
					for i in lst:
										t.del_node(i)
										print(str(t))


from __future__ import annotations


def 						UpperCAmelCase      (     a_ = 4						)		->     list[list[int]]:







				"""simple docstring"""



				__A             =			abs(a_						) or 4
				return [[1 + x + y * row_size for x in range(a_						)] for y in range(a_						)]


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				return reverse_row(transpose(a_						)						)
				# OR.. transpose(reverse_column(matrix))


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				return reverse_row(reverse_column(a_						)						)
				# OR.. reverse_column(reverse_row(matrix))


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				return reverse_column(transpose(a_						)						)
				# OR.. transpose(reverse_row(matrix))


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				__A             =			[list(a_						) for x in zip(*a_						)]
				return matrix


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				__A             =			matrix[::-1]
				return matrix


def 						UpperCAmelCase      (     a_						)		->     list[list[int]]:







				"""simple docstring"""



				__A             =			[x[::-1] for x in matrix]
				return matrix


def 						UpperCAmelCase      (     a_						)		->     None:







				"""simple docstring"""



				for i in matrix:
								print(*a_						)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE							:Union[str, Any]										=    make_matrix()
					print('\norigin:\n')
					print_matrix(matrix)
					print('\nrotate 90 counterclockwise:\n')
					print_matrix(rotate_aa(matrix))

					SCREAMING_SNAKE_CASE							:Tuple										=    make_matrix()
					print('\norigin:\n')
					print_matrix(matrix)
					print('\nrotate 180:\n')
					print_matrix(rotate_aaa(matrix))

					SCREAMING_SNAKE_CASE							:Union[str, Any]										=    make_matrix()
					print('\norigin:\n')
					print_matrix(matrix)
					print('\nrotate 270 counterclockwise:\n')
					print_matrix(rotate_aaa(matrix))
