

from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

a_      =     TypeVar('KEY')
a_      =     TypeVar('VAL')






@dataclass(frozen=__A				,						slots=__A )
class _UpperCamelCase				(				Generic[KEY, VAL] ):
			'''simple docstring'''







			lowerCamelCase__							     =42
			lowerCamelCase__							     =42






class _UpperCamelCase				(				_Item ):
			'''simple docstring'''







			def __init__(      self				:			Dict						)				->							None:

				"""simple docstring"""

				super().__init__(a   ,   a						)






			def __bool__(      self				:			str						)				->							bool:

				"""simple docstring"""

				return False

a_      =     _DeletedItem()






class _UpperCamelCase				(				MutableMapping[KEY, VAL] ):
			'''simple docstring'''







			def __init__(      self				:			Union[str, Any]   ,   a				:			int = 8   ,   a				:			float = 0.75						)				->							None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   int					  =							initial_block_size
				SCREAMING_SNAKE_CASE :   list[_Item | None]					  =							[None] * initial_block_size
				assert 0.0 < capacity_factor < 1.0
				SCREAMING_SNAKE_CASE :   List[str]					  =							capacity_factor
				SCREAMING_SNAKE_CASE :   List[Any]					  =							0
			def 				__UpperCamelCase			(      self				:			str   ,   a				:			KEY						)				->							int:

				"""simple docstring"""

				return hash(a						) % len(self._buckets						)
			def 				__UpperCamelCase			(      self				:			Optional[Any]   ,   a				:			int						)				->							int:

				"""simple docstring"""

				return (ind + 1) % len(self._buckets						)
			def 				__UpperCamelCase			(      self				:			List[Any]   ,   a				:			int   ,   a				:			KEY   ,   a				:			VAL						)				->							bool:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Tuple					  =							self._buckets[ind]
				if not stored:
					SCREAMING_SNAKE_CASE :   int					  =							_Item(a   ,   a						)
					self._len += 1
					return True
				elif stored.key == key:
					SCREAMING_SNAKE_CASE :   Dict					  =							_Item(a   ,   a						)
					return True
				else:
					return False
			def 				__UpperCamelCase			(      self				:			Union[str, Any]						)				->							bool:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   int					  =							len(self._buckets						) * self._capacity_factor
				return len(self						) >= int(a						)
			def 				__UpperCamelCase			(      self				:			Tuple						)				->							bool:

				"""simple docstring"""

				if len(self._buckets						) <= self._initial_block_size:
					return False
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							len(self._buckets						) * self._capacity_factor / 2
				return len(self						) < limit
			def 				__UpperCamelCase			(      self				:			Any   ,   a				:			int						)				->							None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Tuple					  =							self._buckets
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							[None] * new_size
				SCREAMING_SNAKE_CASE :   Dict					  =							0
				for item in old_buckets:
					if item:
						self._add_item(item.key   ,   item.val						)
			def 				__UpperCamelCase			(      self				:			Tuple						)				->							None:

				"""simple docstring"""

				self._resize(len(self._buckets						) * 2						)
			def 				__UpperCamelCase			(      self				:			List[str]						)				->							None:

				"""simple docstring"""

				self._resize(len(self._buckets						) // 2						)
			def 				__UpperCamelCase			(      self				:			List[str]   ,   a				:			KEY						)				->							Iterator[int]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Dict					  =							self._get_bucket_index(a						)
				for _ in range(len(self._buckets						)						):
					yield ind
					SCREAMING_SNAKE_CASE :   int					  =							self._get_next_ind(a						)
			def 				__UpperCamelCase			(      self				:			List[Any]   ,   a				:			KEY   ,   a				:			VAL						)				->							None:

				"""simple docstring"""

				for ind in self._iterate_buckets(a						):
					if self._try_set(a   ,   a   ,   a						):
						break
			def __setitem__(      self				:			List[str]   ,   a				:			KEY   ,   a				:			VAL						)				->							None:

				"""simple docstring"""

				if self._is_full():
					self._size_up()

				self._add_item(a   ,   a						)
			def __delitem__(      self				:			int   ,   a				:			KEY						)				->							None:

				"""simple docstring"""

				for ind in self._iterate_buckets(a						):
					SCREAMING_SNAKE_CASE :   List[str]					  =							self._buckets[ind]
					if item is None:
						raise KeyError(a						)
					if item is _deleted:
						continue
					if item.key == key:
						SCREAMING_SNAKE_CASE :   int					  =							_deleted
						self._len -= 1
						break
				if self._is_sparse():
					self._size_down()
			def __getitem__(      self				:			List[str]   ,   a				:			KEY						)				->							VAL:

				"""simple docstring"""

				for ind in self._iterate_buckets(a						):
					SCREAMING_SNAKE_CASE :   List[Any]					  =							self._buckets[ind]
					if item is None:
						break
					if item is _deleted:
						continue
					if item.key == key:
						return item.val
				raise KeyError(a						)
			def __len__(      self				:			Optional[Any]						)				->							int:

				"""simple docstring"""

				return self._len
			def __iter__(      self				:			Any						)				->							Iterator[KEY]:

				"""simple docstring"""

				yield from (item.key for item in self._buckets if item)






			def __repr__(      self				:			Optional[int]						)				->							str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   int					  =							" ,".join(
				    F"{item.key}: {item.val}" for item in self._buckets if item						)
				return F"HashMap({val_string})"


from math import pi, sqrt, tan

def 			lowerCamelCase__			(       _a):
	if side_length < 0:
		raise ValueError("surface_area_cube() only accepts non-negative values")
	return 6 * side_length**2

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if length < 0 or breadth < 0 or height < 0:
		raise ValueError("surface_area_cuboid() only accepts non-negative values")
	return 2 * ((length * breadth) + (breadth * height) + (length * height))

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("surface_area_sphere() only accepts non-negative values")
	return 4 * pi * radius**2

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("surface_area_hemisphere() only accepts non-negative values")
	return 3 * pi * radius**2

def 			lowerCamelCase__			(       _a				,      _a):
	if radius < 0 or height < 0:
		raise ValueError("surface_area_cone() only accepts non-negative values")
	return pi * radius * (radius + (height**2 + radius**2) ** 0.5)

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if radius_a < 0 or radius_a < 0 or height < 0:
		raise ValueError(
		    "surface_area_conical_frustum() only accepts non-negative values")
	SCREAMING_SNAKE_CASE :   Any					  =							(height**2 + (radius_a - radius_a) ** 2) ** 0.5
	return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)

def 			lowerCamelCase__			(       _a				,      _a):
	if radius < 0 or height < 0:
		raise ValueError("surface_area_cylinder() only accepts non-negative values")
	return 2 * pi * radius * (height + radius)

def 			lowerCamelCase__			(       _a				,      _a):
	if torus_radius < 0 or tube_radius < 0:
		raise ValueError("surface_area_torus() only accepts non-negative values")
	if torus_radius < tube_radius:
		raise ValueError(
		    "surface_area_torus() does not support spindle or self intersecting tori")
	return 4 * pow(_a				,      2) * torus_radius * tube_radius

def 			lowerCamelCase__			(       _a				,      _a):
	if length < 0 or width < 0:
		raise ValueError("area_rectangle() only accepts non-negative values")
	return length * width

def 			lowerCamelCase__			(       _a):
	if side_length < 0:
		raise ValueError("area_square() only accepts non-negative values")
	return side_length**2

def 			lowerCamelCase__			(       _a				,      _a):
	if base < 0 or height < 0:
		raise ValueError("area_triangle() only accepts non-negative values")
	return (base * height) / 2

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if sidea < 0 or sidea < 0 or sidea < 0:
		raise ValueError("area_triangle_three_sides() only accepts non-negative values")
	elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
		raise ValueError("Given three sides do not form a triangle")
	SCREAMING_SNAKE_CASE :   List[str]					  =							(sidea + sidea + sidea) / 2
	SCREAMING_SNAKE_CASE :   Optional[int]					  =							sqrt(
	    semi_perimeter
	    * (semi_perimeter - sidea)
	    * (semi_perimeter - sidea)
	    * (semi_perimeter - sidea))
	return area

def 			lowerCamelCase__			(       _a				,      _a):
	if base < 0 or height < 0:
		raise ValueError("area_parallelogram() only accepts non-negative values")
	return base * height

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if basea < 0 or basea < 0 or height < 0:
		raise ValueError("area_trapezium() only accepts non-negative values")
	return 1 / 2 * (basea + basea) * height

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("area_circle() only accepts non-negative values")
	return pi * radius**2

def 			lowerCamelCase__			(       _a				,      _a):
	if radius_x < 0 or radius_y < 0:
		raise ValueError("area_ellipse() only accepts non-negative values")
	return pi * radius_x * radius_y

def 			lowerCamelCase__			(       _a				,      _a):
	if diagonal_a < 0 or diagonal_a < 0:
		raise ValueError("area_rhombus() only accepts non-negative values")
	return 1 / 2 * diagonal_a * diagonal_a

def 			lowerCamelCase__			(       _a				,      _a):
	if not isinstance(_a				,      _a) or sides < 3:
		raise ValueError(
		    "area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides")
	elif length < 0:
		raise ValueError(
		    "area_reg_polygon() only accepts non-negative values as \
length of a side")
	return (sides * length**2) / (4 * tan(pi / sides))
	return (sides * length**2) / (4 * tan(pi / sides))


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

			print('[DEMO] Areas of various geometric shapes: \n')
			print(F'''Rectangle: {area_rectangle(10, 20) = }''')
			print(F'''Square: {area_square(10) = }''')
			print(F'''Triangle: {area_triangle(10, 10) = }''')
			print(F'''Triangle: {area_triangle_three_sides(5, 12, 13) = }''')
			print(F'''Parallelogram: {area_parallelogram(10, 20) = }''')
			print(F'''Rhombus: {area_rhombus(10, 20) = }''')
			print(F'''Trapezium: {area_trapezium(10, 20, 30) = }''')
			print(F'''Circle: {area_circle(20) = }''')
			print(F'''Ellipse: {area_ellipse(10, 20) = }''')
			print('\nSurface Areas of various geometric shapes: \n')
			print(F'''Cube: {surface_area_cube(20) = }''')
			print(F'''Cuboid: {surface_area_cuboid(10, 20, 30) = }''')
			print(F'''Sphere: {surface_area_sphere(20) = }''')
			print(F'''Hemisphere: {surface_area_hemisphere(20) = }''')
			print(F'''Cone: {surface_area_cone(10, 20) = }''')
			print(F'''Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }''')
			print(F'''Cylinder: {surface_area_cylinder(10, 20) = }''')
			print(F'''Torus: {surface_area_torus(20, 10) = }''')
			print(F'''Equilateral Triangle: {area_reg_polygon(3, 10) = }''')
			print(F'''Square: {area_reg_polygon(4, 10) = }''')
			print(F'''Reqular Pentagon: {area_reg_polygon(5, 10) = }''')