from __future__ import annotations

from typing import Any





class 					A							:


   def __init__(self					:						Optional[int]	,  __UpperCAmelCase					:						int = 6		)						->    None:
         """simple docstring"""



         UpperCAmelCase__								=  None
         UpperCAmelCase__								=  None
         self.create_linked_list(__UpperCAmelCase		)


   def       lowercase_				(self					:						Optional[Any]	,  __UpperCAmelCase					:						int		)						->    None:
         """simple docstring"""



         UpperCAmelCase__								=  Node()
         UpperCAmelCase__								=  current_node
         UpperCAmelCase__								=  current_node
         UpperCAmelCase__								=  current_node
         for _ in range(1	,  __UpperCAmelCase		):
               UpperCAmelCase__								=  Node()
               UpperCAmelCase__								=  current_node
               UpperCAmelCase__								=  previous_node
               UpperCAmelCase__								=  current_node
         UpperCAmelCase__								=  self.front
         UpperCAmelCase__								=  previous_node


   def       lowercase_				(self					:						int		)						->    bool:
         """simple docstring"""



         return (
             self.front == self.rear
             and self.front is not None
             and self.front.data is None
         )


   def       lowercase_				(self					:						str		)						->    Any | None:
         """simple docstring"""



         self.check_can_perform_operation()
         return self.front.data if self.front else None


   def       lowercase_				(self					:						Tuple	,  __UpperCAmelCase					:						Any		)						->    None:
         """simple docstring"""



         if self.rear is None:
               return

         self.check_is_full()
         if not self.is_empty():
               UpperCAmelCase__								=  self.rear.next
         if self.rear:
               UpperCAmelCase__								=  data


   def       lowercase_				(self					:						Dict		)						->    Any:
         """simple docstring"""



         self.check_can_perform_operation()
         if self.rear is None or self.front is None:
               return None
         if self.front == self.rear:
               UpperCAmelCase__								=  self.front.data
               UpperCAmelCase__								=  None
               return data

         UpperCAmelCase__								=  self.front
         UpperCAmelCase__								=  old_front.next
         UpperCAmelCase__								=  old_front.data
         UpperCAmelCase__								=  None
         return data


   def       lowercase_				(self					:						Union[str, Any]		)						->    None:
         """simple docstring"""



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





   def       lowercase_				(self					:						Dict		)						->    None:
         """simple docstring"""



         if self.rear and self.rear.next == self.front:
               raise Exception("Full Queue"		)





class 					A							:


   def __init__(self					:						Tuple		)						->    None:
         """simple docstring"""



         UpperCAmelCase__								=  None
         UpperCAmelCase__								=  None
         UpperCAmelCase__								=  None


if __name__ == "__main__":
      import doctest

      doctest.testmod()




from __future__ import annotations




def        lowerCAmelCase_			(					__A,  __A,  __A,  )					->    tuple:







      '''simple docstring'''


      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()



