




"""simple docstring"""






class lowerCAmelCase__      :






			'''simple docstring'''



			def __init__(    self    , lowercase    , lowercase=None    , lowercase=None    ):
							_lowerCamelCase	:     Any       =       data
							_lowerCamelCase	:     List[Any]       =       previous
							_lowerCamelCase	:     str       =       next_node
			def __str__(    self    ):
							return F'''{self.data}'''
			def    A_       (    self    ):
							return self.data
			def    A_       (    self    ):
							return self.next






			def    A_       (    self    ):
							return self.previous






class lowerCAmelCase__      :






			'''simple docstring'''



			def __init__(    self    , lowercase    ):
							_lowerCamelCase	:     Dict       =       head
			def __iter__(    self    ):
							return self






			def    A_       (    self    ):
							if not self.current:
											raise StopIteration
							else:
											_lowerCamelCase	:     List[Any]       =       self.current.get_data()
											_lowerCamelCase	:     List[str]       =       self.current.get_next()
											return value






class lowerCAmelCase__      :






			'''simple docstring'''



			def __init__(    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       None  # First node in list
							_lowerCamelCase	:     Dict       =       None  # Last node in list
			def __str__(    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       self.head
							_lowerCamelCase	:     str       =       []
							while current is not None:
											nodes.append(current.get_data()    )
											_lowerCamelCase	:     int       =       current.get_next()
							return " ".join(str(__UpperCamelCase    ) for node in nodes    )
			def __contains__(    self    , lowercase    ):
							_lowerCamelCase	:     Union[str, Any]       =       self.head
							while current:
											if current.get_data() == value:
															return True
											_lowerCamelCase	:     Optional[int]       =       current.get_next()
							return False
			def __iter__(    self    ):
							return LinkedListIterator(self.head    )
			def    A_       (    self    ):
							if self.head:
											return self.head.get_data()
							return None
			def    A_       (    self    ):
							if self.tail:
											return self.tail.get_data()
							return None
			def    A_       (    self    , lowercase    ):
							if self.head is None:
											_lowerCamelCase	:     List[str]       =       node
											_lowerCamelCase	:     Tuple       =       node
							else:
											self.insert_before_node(self.head    , __UpperCamelCase    )
			def    A_       (    self    , lowercase    ):
							if self.head is None:
											self.set_head(__UpperCamelCase    )
							else:
											self.insert_after_node(self.tail    , __UpperCamelCase    )
			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     List[str]       =       Node(__UpperCamelCase    )
							if self.head is None:
											self.set_head(__UpperCamelCase    )
							else:
											self.set_tail(__UpperCamelCase    )
			def    A_       (    self    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Any       =       node
							_lowerCamelCase	:     Optional[int]       =       node.previous

							if node.get_previous() is None:
											_lowerCamelCase	:     Union[str, Any]       =       node_to_insert
							else:
											_lowerCamelCase	:     str       =       node_to_insert

							_lowerCamelCase	:     Union[str, Any]       =       node_to_insert
			def    A_       (    self    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Tuple       =       node
							_lowerCamelCase	:     List[str]       =       node.next

							if node.get_next() is None:
											_lowerCamelCase	:     Optional[int]       =       node_to_insert
							else:
											_lowerCamelCase	:     Any       =       node_to_insert

							_lowerCamelCase	:     Dict       =       node_to_insert
			def    A_       (    self    , lowercase    , lowercase    ):
							_lowerCamelCase	:     int       =       1
							_lowerCamelCase	:     Optional[Any]       =       Node(__UpperCamelCase    )
							_lowerCamelCase	:     int       =       self.head
							while node:
											if current_position == position:
															self.insert_before_node(__UpperCamelCase    , __UpperCamelCase    )
															return
											current_position += 1
											_lowerCamelCase	:     Union[str, Any]       =       node.next
							self.insert_after_node(self.tail    , __UpperCamelCase    )
			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     str       =       self.head
							while node:
											if node.get_data() == item:
															return node
											_lowerCamelCase	:     Optional[int]       =       node.get_next()
							raise Exception('Node not found'    )
			def    A_       (    self    , lowercase    ):
							if (node := self.get_node(__UpperCamelCase    )) is not None:
											if node == self.head:
															_lowerCamelCase	:     Dict       =       self.head.get_next()

											if node == self.tail:
															_lowerCamelCase	:     str       =       self.tail.get_previous()

											self.remove_node_pointers(__UpperCamelCase    )
			@staticmethod
			def    A_       (    lowercase    ):
							if node.get_next():
											_lowerCamelCase	:     Any       =       node.previous

							if node.get_previous():
											_lowerCamelCase	:     Dict       =       node.next

							_lowerCamelCase	:     Optional[int]       =       None
							_lowerCamelCase	:     Any       =       None






			def    A_       (    self    ):
							return self.head is None







def 	_snake_case     (							):
				pass


if __name__ == "__main__":
			import doctest

			doctest.testmod()

from __future__ import annotations




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	float		,   SCREAMING_SNAKE_CASE_	:	float		,   SCREAMING_SNAKE_CASE_	:	float		,   )  ->     tuple:
						if (electron_conc, hole_conc, intrinsic_conc).count(0       ) != 1:
												raise ValueError("""You cannot supply more or less than 2 values"""       )
						elif electron_conc < 0:
												raise ValueError("""Electron concentration cannot be negative in a semiconductor"""       )
						elif hole_conc < 0:
												raise ValueError("""Hole concentration cannot be negative in a semiconductor"""       )
						elif intrinsic_conc < 0:
												raise ValueError(
												    """Intrinsic concentration cannot be negative in a semiconductor"""       )
						elif electron_conc == 0:
												return (
												    "electron_conc",
												    intrinsic_conc**2 / hole_conc,
												)
						elif hole_conc == 0:
												return (
												    "hole_conc",
												    intrinsic_conc**2 / electron_conc,
												)
						elif intrinsic_conc == 0:
												return (
												    "intrinsic_conc",
												    (electron_conc * hole_conc) ** 0.5,
												)
						else:
												return (-1, -1)


if __name__ == "__main__":
		import doctest

		doctest.testmod()