


"""simple docstring"""
import numpy as np

__SCREAMING_SNAKE_CASE				:     Tuple		=     [
    ['a', 'b', 'c', 'd', 'e'],
    ['f', 'g', 'h', 'i', 'k'],
    ['l', 'm', 'n', 'o', 'p'],
    ['q', 'r', 's', 't', 'u'],
    ['v', 'w', 'x', 'y', 'z'],
]





class   __A  :





							'''simple docstring'''

							def __init__(					self				:   Any							)       ->None:



														"""simple docstring"""



														snake_case_     							=		np.array(UpperCAmelCase_							)



							def 		lowerCAmelCase							(					self				:   List[Any]		,							UpperCAmelCase_				:   str							)       ->np.ndarray:



														"""simple docstring"""



														snake_case_							,    snake_case_     							=		np.where(letter == self.SQUARE							)
														snake_case_     							=		np.concatenate([indexa + 1, indexa + 1]							)
														return indexes



							def 		lowerCAmelCase							(					self				:   Union[str, Any]		,							UpperCAmelCase_				:   int		,							UpperCAmelCase_				:   int							)       ->str:



														"""simple docstring"""



														return self.SQUARE[indexa - 1, indexa - 1]



							def 		lowerCAmelCase							(					self				:   Dict		,							UpperCAmelCase_				:   str							)       ->str:



														"""simple docstring"""



														snake_case_     							=		message.lower()
														snake_case_     							=		message.replace("""j"""		,							"""i"""							)

														snake_case_     							=		""""""
														for letter_index in range(len(UpperCAmelCase_							)							):
																					if message[letter_index] != " ":
																												snake_case_     							=		self.letter_to_numbers(message[letter_index]							)
																												snake_case_     							=		encoded_message + str(numbers[0]							) + str(numbers[1]							)
																					elif message[letter_index] == " ":
																												snake_case_     							=		encoded_message + """ """

														return encoded_message



							def 		lowerCAmelCase							(					self				:   str		,							UpperCAmelCase_				:   str							)       ->str:



														"""simple docstring"""



														snake_case_     							=		message.replace(""" """		,							"""  """							)
														snake_case_     							=		""""""
														for numbers_index in range(int(len(UpperCAmelCase_							) / 2							)							):
																					if message[numbers_index * 2] != " ":
																												snake_case_     							=		message[numbers_index * 2]
																												snake_case_     							=		message[numbers_index * 2 + 1]

																												snake_case_     							=		self.numbers_to_letter(int(UpperCAmelCase_							)		,							int(UpperCAmelCase_							)							)
																												snake_case_     							=		decoded_message + letter
																					elif message[numbers_index * 2] == " ":
																												snake_case_     							=		decoded_message + """ """

														return decoded_message







"""simple docstring"""
import doctest

import projectq
from projectq.ops import H, Measure







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					int:
							snake_case_     							=		quantum_engine.allocate_qubit()
							H | qubit
							Measure | qubit
							return int(_SCREAMING_SNAKE_CASE					)


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

				# initialises a new quantum backend
				__SCREAMING_SNAKE_CASE				:     Dict		=     projectq.MainEngine()

				# Generate a list of 10 random numbers
				__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     [get_random_number(quantum_engine) for _ in range(10)]

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

				print('Random numbers', random_numbers_list)



