



import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute






def        a( A			:       int = 1					,	A			:       int = 1			)						->			qiskit.result.counts.Counts:
					"""simple docstring"""





					if isinstance(A					,	A			) or isinstance(A					,	A			):
										raise TypeError("inputs must be integers."			)
					if (bit_a < 0) or (bit_a < 0):
										raise ValueError("inputs must be positive."			)
					if (math.floor(A			) != bit_a) or (math.floor(A			) != bit_a):
										raise ValueError("inputs must be exact integers."			)
					if (bit_a > 1) or (bit_a > 1):
										raise ValueError("inputs must be less or equal to 1."			)

					# build registers
					a   	=  QuantumRegister(2					,	"qr"			)
					a   	=  ClassicalRegister(2					,	"cr"			)

					a   	=  QuantumCircuit(A					,	A			)

					# entanglement the qubits
					quantum_circuit.h(1			)
					quantum_circuit.cx(1					,	0			)

					# send the information
					a   	=  str(A			) + str(A			)

					if c_information == "11":
										quantum_circuit.x(1			)
										quantum_circuit.z(1			)
					elif c_information == "10":
										quantum_circuit.z(1			)
					elif c_information == "01":
										quantum_circuit.x(1			)
					else:
										quantum_circuit.i(1			)

					# unentangled the circuit
					quantum_circuit.cx(1					,	0			)
					quantum_circuit.h(1			)

					# measure the circuit
					quantum_circuit.measure(A					,	A			)

					a   	=  Aer.get_backend("aer_simulator"			)
					a   	=  execute(A					,	A					,	shots=1000			)

					return job.result().get_counts(A			)


if __name__ == "__main__":
				print(F"""Counts for classical state send: {superdense_coding(1,1)}""")





from typing import Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_openai import OpenAIGPTTokenizer


_lowercase:					List[str]      =						logging.get_logger(__name__)

_lowercase:					str      =						{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

_lowercase:					Union[str, Any]      =						{
    "vocab_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/vocab.json"},
    "merges_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/merges.txt"},
    "tokenizer_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/tokenizer.json"},
}

_lowercase:					int      =						{
    "openai-gpt": 512,
}



class       _lowercase				(  lowerCAmelCase      ):





	"""simple docstring"""
	__A		      =				VOCAB_FILES_NAMES
	__A		      =				PRETRAINED_VOCAB_FILES_MAP
	__A		      =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	__A		      =				["input_ids", "attention_mask"]
	__A		      =				OpenAIGPTTokenizer




	def __init__(self						,			lowerCamelCase_=None						,			lowerCamelCase_=None						,			lowerCamelCase_=None						,			lowerCamelCase_="<unk>"						,			**lowerCamelCase_						):
						"""simple docstring"""

						super().__init__(lowerCamelCase_						,			lowerCamelCase_						,			tokenizer_file=lowerCamelCase_						,			unk_token=lowerCamelCase_						,			**lowerCamelCase_						)




	@property
	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						return True




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						):
						"""simple docstring"""

						a   	=  self._tokenizer.model.save(lowerCamelCase_						,			name=lowerCamelCase_						)
						return tuple(lowerCamelCase_						)
