





'''simple docstring'''


from __future__ import annotations

from typing import Any
class  a_  :





     def __init__(					self						:   Union[str, Any]      , lowercase						:   int = 6		):





        """simple docstring"""




        lowercase_     :Dict            =					None
        lowercase_     :Optional[Any]            =					None
        self.create_linked_list(snake_case__		)





     def 				lowercase__ (					self						:   List[str]      , lowercase						:   int		):





        """simple docstring"""




        lowercase_     :List[Any]            =					Node()
        lowercase_     :Tuple            =					current_node
        lowercase_     :Dict            =					current_node
        lowercase_     :List[str]            =					current_node
        for _ in range(1      , snake_case__		):
           lowercase_     :Tuple            =					Node()
           lowercase_     :Dict            =					current_node
           lowercase_     :str            =					previous_node
           lowercase_     :Union[str, Any]            =					current_node
        lowercase_     :Any            =					self.front
        lowercase_     :Tuple            =					previous_node





     def 				lowercase__ (					self						:   Optional[int]		):





        """simple docstring"""




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





     def 				lowercase__ (					self						:   Optional[Any]		):





        """simple docstring"""




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





     def 				lowercase__ (					self						:   Tuple      , lowercase						:   Any		):





        """simple docstring"""




        if self.rear is None:
           return

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





     def 				lowercase__ (					self						:   Union[str, 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:
           lowercase_     :Optional[int]            =					self.front.data
           lowercase_     :Tuple            =					None
           return data

        lowercase_     :Tuple            =					self.front
        lowercase_     :str            =					old_front.next
        lowercase_     :Dict            =					old_front.data
        lowercase_     :str            =					None
        return data





     def 				lowercase__ (					self						:   List[str]		):





        """simple docstring"""




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







     def 				lowercase__ (					self						:   Dict		):





        """simple docstring"""




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







class  a_  :





     def __init__(					self						:   Optional[int]		):





        """simple docstring"""




        lowercase_     :List[Any]            =					None
        lowercase_     :str            =					None
        lowercase_     :List[Any]            =					None


if __name__ == "__main__":
 import doctest

 doctest.testmod()








from __future__ import annotations

import math


def 					_a							(					lowerCAmelCase )->	bool:

		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5    ,						int(math.sqrt(lowerCAmelCase ) + 1 )    ,						6 ):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True


SCREAMING_SNAKE_CASE:     List[str]									= [num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]


def 					_a							(					lowerCAmelCase )->	list[int]:
		if not isinstance(lowerCAmelCase    ,						lowerCAmelCase ):
				raise ValueError('n must be an integer' )
		if n <= 0:
				raise ValueError('n must be >= 0' )

		SCREAMING_SNAKE_CASE_					      =							[]
		for num in range(len(lowerCAmelCase ) ):
				SCREAMING_SNAKE_CASE_					      =							0
				while 2 * i * i <= odd_composites[num]:
						SCREAMING_SNAKE_CASE_					      =							odd_composites[num] - 2 * i * i
						if is_prime(lowerCAmelCase ):
								break
						i += 1
				else:
						list_nums.append(odd_composites[num] )
						if len(lowerCAmelCase ) == n:
								return list_nums

		return []


def 					_a							(					)->	int:
		return compute_nums(1 )[0]


if __name__ == "__main__":
						print(f"""{solution() = }""")