






from __future__ import annotations

from typing import Any


class 			SCREAMING_SNAKE_CASE      :
     '''simple docstring'''


     def __init__(					self							:						List[str]       ,			UpperCAmelCase_							:						int = 6   ):
       SCREAMING_SNAKE_CASE							:   Node | None						    =     None
       SCREAMING_SNAKE_CASE							:   Node | None						    =     None
       self.create_linked_list(UpperCAmelCase_   )


     def 					_A							(					self							:						List[Any]       ,			UpperCAmelCase_							:						int   ):
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     Node()
       SCREAMING_SNAKE_CASE							:   str						    =     current_node
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     current_node
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     current_node
       for _ in range(1       ,			UpperCAmelCase_   ):
         SCREAMING_SNAKE_CASE							:   Tuple						    =     Node()
         SCREAMING_SNAKE_CASE							:   Dict						    =     current_node
         SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     previous_node
         SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     current_node
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.front
       SCREAMING_SNAKE_CASE							:   List[str]						    =     previous_node


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


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


     def 					_A							(					self							:						Optional[int]       ,			UpperCAmelCase_							:						Any   ):
       if self.rear is None:
         return

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


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

       SCREAMING_SNAKE_CASE							:   List[str]						    =     self.front
       SCREAMING_SNAKE_CASE							:   List[str]						    =     old_front.next
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     old_front.data
       SCREAMING_SNAKE_CASE							:   List[str]						    =     None
       return data


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






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





class 			SCREAMING_SNAKE_CASE      :
     '''simple docstring'''


     def __init__(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   Any | None						    =     None
       SCREAMING_SNAKE_CASE							:   Node | None						    =     None
       SCREAMING_SNAKE_CASE							:   Node | None						    =     None


if __name__ == "__main__":
   import doctest

   doctest.testmod()










from __future__ import annotations

import numpy as np
def 							UpperCamelCase_(					_A :list[float]	)->		Optional[Any]:
			return np.maximum(0					,  _A	)


if __name__ == "__main__":
						print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]


