






from __future__ import annotations

from typing import Any

class     _SCREAMING_SNAKE_CASE       :





	def __init__(		self				:					Optional[int] ,  __lowerCamelCase				:					Any = 6	):
		UpperCamelCase     :List[Any]          =	None
		UpperCamelCase     :Optional[int]          =	None
		self.create_linked_list(A__	)





	def 						_A (		self				:					str ,  __lowerCamelCase				:					Any	):
		UpperCamelCase     :Tuple          =	Node()
		UpperCamelCase     :str          =	current_node
		UpperCamelCase     :Union[str, Any]          =	current_node
		UpperCamelCase     :Tuple          =	current_node
		for _ in range(1 ,  A__	):
			UpperCamelCase     :Dict          =	Node()
			UpperCamelCase     :int          =	current_node
			UpperCamelCase     :Tuple          =	previous_node
			UpperCamelCase     :Union[str, Any]          =	current_node
		UpperCamelCase     :str          =	self.front
		UpperCamelCase     :Dict          =	previous_node





	def 						_A (		self				:					Optional[Any]	):
		return (
		    self.front == self.rear
		    and self.front is not None
		    and self.front.data is None
		)





	def 						_A (		self				:					int	):
		self.check_can_perform_operation()
		return self.front.data if self.front else None





	def 						_A (		self				:					Union[str, Any] ,  __lowerCamelCase				:					List[Any]	):
		if self.rear is None:
			return

		self.check_is_full()
		if not self.is_empty():
			UpperCamelCase     :List[str]          =	self.rear.next
		if self.rear:
			UpperCamelCase     :List[str]          =	data





	def 						_A (		self				:					Optional[Any]	):
		self.check_can_perform_operation()
		if self.rear is None or self.front is None:
			return None
		if self.front == self.rear:
			UpperCamelCase     :List[Any]          =	self.front.data
			UpperCamelCase     :int          =	None
			return data

		UpperCamelCase     :Union[str, Any]          =	self.front
		UpperCamelCase     :str          =	old_front.next
		UpperCamelCase     :Tuple          =	old_front.data
		UpperCamelCase     :Optional[Any]          =	None
		return data





	def 						_A (		self				:					str	):
		if self.is_empty():
			raise Exception("""Empty Queue"""	)





	def 						_A (		self				:					List[Any]	):
		if self.rear and self.rear.next == self.front:
			raise Exception("""Full Queue"""	)

class     _SCREAMING_SNAKE_CASE       :





	def __init__(		self				:					int	):
		UpperCamelCase     :Any          =	None
		UpperCamelCase     :int          =	None
		UpperCamelCase     :Any          =	None


if __name__ == "__main__":
	import doctest

	doctest.testmod()


def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''

					if edge <= 0 or not isinstance(lowerCAmelCase__ ,			lowerCAmelCase__		):
										raise ValueError('''Length must be a positive.'''		)
					return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2)



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''

					if edge <= 0 or not isinstance(lowerCAmelCase__ ,			lowerCAmelCase__		):
										raise ValueError('''Length must be a positive.'''		)
					return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




