



import math

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

def      A_ (		__a       :			Tuple = 1	,						__a       :			List[str] = 1						):

				"""simple docstring"""
				if isinstance(snake_case__	,						snake_case__						) or isinstance(snake_case__	,						snake_case__						):
								raise TypeError("""inputs must be integers."""						)
				if (bit_a < 0) or (bit_a < 0):
								raise ValueError("""inputs must be positive."""						)
				if (math.floor(snake_case__						) != bit_a) or (math.floor(snake_case__						) != 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(snake_case__	,						snake_case__						)

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

				# send the information
				a__			 =						str(snake_case__						) + str(snake_case__						)

				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(snake_case__	,						snake_case__						)

				a__			 =						Aer.get_backend("""aer_simulator"""						)
				a__			 =						execute(snake_case__	,						snake_case__	,						shots=1_000						)

				return job.result().get_counts(snake_case__						)


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






import unittest

from transformers import BlenderbotTokenizer, BlenderbotTokenizerFast
from transformers.utils import cached_property

class 	__snake_case (				unittest.TestCase):







							'''simple docstring'''






							@cached_property
							def _a (							self						):
											return BlenderbotTokenizer.from_pretrained("""facebook/blenderbot-3B"""						)


							@cached_property
							def _a (							self						):
											return BlenderbotTokenizerFast.from_pretrained("""facebook/blenderbot-3B"""						)


							def _a (							self						):
											a__			 =						self.tokenizer_ab
											a__			 =						""" I am a small frog."""
											a__			 =						tok([src_text]					,					padding=a_					,					truncation=a_						)["""input_ids"""]
											a__			 =						tok.batch_decode(a_					,					skip_special_tokens=a_					,					clean_up_tokenization_spaces=a_						)[0]
											assert src_text == decoded


							def _a (							self						):
											a__			 =						self.rust_tokenizer_ab
											a__			 =						""" I am a small frog."""
											a__			 =						tok([src_text]					,					padding=a_					,					truncation=a_						)["""input_ids"""]
											a__			 =						tok.batch_decode(a_					,					skip_special_tokens=a_					,					clean_up_tokenization_spaces=a_						)[0]
											assert src_text == decoded


							def _a (							self						):
											assert self.tokenizer_ab.add_prefix_space
											assert self.tokenizer_ab([""" Sam""", """Sam"""]						).input_ids == [[5_502, 2], [5_502, 2]]







							def _a (							self						):
											assert self.rust_tokenizer_ab.add_prefix_space
											assert self.rust_tokenizer_ab([""" Sam""", """Sam"""]						).input_ids == [[5_502, 2], [5_502, 2]]

