
def 				_lowerCamelCase      (       lowerCamelCase_:	List[Any]		):



				'''simple docstring'''







				if not head:
								return True
				# split the list to two parts
				A  :	Optional[Any]				=					head.next, head
				while fast and fast.next:
								A  :	str				=					fast.next.next
								A  :	Dict				=					slow.next
				A  :	List[Any]				=					slow.next
				A  :	str				=					None  # Don't forget here! But forget still works!
				# reverse the second part
				A  :	Any				=					None
				while second:
								A  :	List[Any]				=					second.next
								A  :	List[Any]				=					node
								A  :	Dict				=					second
								A  :	str				=					nxt
				# compare two parts
				# second part has the same or one less node
				while node:
								if node.val != head.val:
												return False
								A  :	Optional[int]				=					node.next
								A  :	Any				=					head.next
				return True





def 				_lowerCamelCase      (       lowerCamelCase_:	Tuple		):



				'''simple docstring'''







				if not head or not head.next:
								return True

				# 1. Get the midpoint (slow)
				A  :	Dict				=					head
				while fast and fast.next:
								A  :	int				=					fast.next.next, slow.next

				# 2. Push the second half into the stack
				A  :	List[Any]				=					[slow.val]
				while slow.next:
								A  :	str				=					slow.next
								stack.append(slow.val		)

				# 3. Comparison
				while stack:
								if stack.pop() != cur.val:
												return False
								A  :	List[str]				=					cur.next

				return True






def 				_lowerCamelCase      (       lowerCamelCase_:	Union[str, Any]		):



				'''simple docstring'''







				if not head or not head.next:
								return True
				A  :	List[str]				=					{}
				A  :	Dict				=					0
				while head:
								if head.val in d:
												d[head.val].append(_SCREAMING_SNAKE_CASE		)
								else:
												A  :	Tuple				=					[pos]
								A  :	int				=					head.next
								pos += 1
				A  :	List[str]				=					pos - 1
				A  :	List[str]				=					0
				for v in d.values():
								if len(_SCREAMING_SNAKE_CASE		) % 2 != 0:
												middle += 1
								else:
												A  :	Tuple				=					0
												for i in range(0					,						len(_SCREAMING_SNAKE_CASE		)		):
																if v[i] + v[len(_SCREAMING_SNAKE_CASE		) - 1 - step] != checksum:
																				return False
																step += 1
								if middle > 1:
												return False
				return True
from __future__ import annotations






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				float		, _SCREAMING_SNAKE_CASE     :				float		, _SCREAMING_SNAKE_CASE     :				float		, ):
						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()






