


from ..utils import DummyObject, requires_backends


class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Dict						,      *a:       List[Any]						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       Dict						,      **a:       Any				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       List[Any]						,      **a:       Dict				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       int						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       Optional[Any]						,      **a:       Dict				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[Any]						,      *a:       List[str]						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       str						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Any						,      *a:       List[Any]						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       Tuple						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       int						,      *a:       Optional[int]						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[Any]						,      *a:       List[Any]						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       str						,      **a:       Any				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       Optional[int]						,      **a:       Optional[int]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Any						,      *a:       Tuple						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       int						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       List[Any]						,      **a:       Dict				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       int						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       List[str]						,      **a:       Union[str, Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       List[Any]						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       Optional[int]						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       List[str]						,      **a:       Union[str, Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[Any]						,      *a:       List[Any]						,      **a:       Optional[int]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       Tuple						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       int						,      *a:       int						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Any						,      *a:       Optional[Any]						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       int						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[int]						,      *a:       List[Any]						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[Any]						,      *a:       Optional[int]						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Dict						,      *a:       Tuple						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       Any						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       Any						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Dict						,      *a:       List[str]						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       Dict						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       Tuple						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       Any						,      **a:       Union[str, Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       Optional[Any]						,      **a:       List[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       Dict						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       List[Any]						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       Any						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       Optional[int]						,      **a:       Any				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       List[str]						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       Dict						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       Optional[int]						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       int						,      **a:       Optional[Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       Tuple						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Any						,      *a:       Tuple						,      **a:       Optional[int]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       Any						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       int						,      *a:       Optional[int]						,      **a:       Union[str, Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       List[str]						,      *a:       Union[str, Any]						,      **a:       Union[str, Any]				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       Union[str, Any]						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       int						,      *a:       Optional[Any]						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       Tuple						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Dict						,      *a:       Dict						,      **a:       str				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Tuple						,      *a:       Optional[Any]						,      **a:       Dict				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       str						,      *a:       Any						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Union[str, Any]						,      *a:       Optional[Any]						,      **a:       int				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Optional[Any]						,      *a:       int						,      **a:       Dict				):
       requires_backends(self						,      ['tokenizers']				)



class        A_					(       metaclass=__UpperCamelCase    ):




      '''simple docstring'''


      __snake_case					       =   ["""tokenizers"""]




      def __init__(				self:       Dict						,      *a:       List[str]						,      **a:       Tuple				):
       requires_backends(self						,      ['tokenizers']				)





import doctest

import projectq
from projectq.ops import H, Measure
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							int							=						quantum_engine.allocate_qubit()
 H | qubit
 Measure | qubit
 return int(SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       doctest.testmod()

       # initialises a new quantum backend
       lowercase_           =	projectq.MainEngine()

       # Generate a list of 10 random numbers
       lowercase_           =	[get_random_number(quantum_engine) for _ in range(1_0)]

       # Flushes the quantum engine from memory
       quantum_engine.flush()

       print('Random numbers', random_numbers_list)

