'''simple docstring'''


import math

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


def    _lowerCamelCase       ( lowerCamelCase_   :				int = 1      ,	lowerCamelCase_   :				int = 1  ):



     """simple docstring"""





     if isinstance(lowerCamelCase_      ,	lowerCamelCase_  ) or isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('inputs must be integers.'  )
     if (bit_a < 0) or (bit_a < 0):
          raise ValueError('inputs must be positive.'  )
     if (math.floor(lowerCamelCase_  ) != bit_a) or (math.floor(lowerCamelCase_  ) != 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
     UpperCAmelCase_				:  Dict  = QuantumRegister(2      ,	'qr'  )
     UpperCAmelCase_				:  str  = ClassicalRegister(2      ,	'cr'  )

     UpperCAmelCase_				:  int  = QuantumCircuit(lowerCamelCase_      ,	lowerCamelCase_  )

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

     # send the information
     UpperCAmelCase_				:  Union[str, Any]  = str(lowerCamelCase_  ) + str(lowerCamelCase_  )

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

     UpperCAmelCase_				:  List[Any]  = Aer.get_backend('aer_simulator'  )
     UpperCAmelCase_				:  int  = execute(lowerCamelCase_      ,	lowerCamelCase_      ,	shots=1000  )

     return job.result().get_counts(lowerCamelCase_  )


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










"""simple docstring"""
from typing import Any





class   __A  :





							'''simple docstring'''

							def __init__(					self				:   List[Any]							)       ->int:



														"""simple docstring"""



														snake_case_     							=		[]
														snake_case_     							=		0



							def __str__(					self				:   List[str]							)       ->Union[str, Any]:



														"""simple docstring"""



														snake_case_     							=		"""<""" + str(self.stack							)[1:-1] + """>"""
														return printed



							def 		lowerCAmelCase							(					self				:   List[Any]		,							UpperCAmelCase_				:   Any							)       ->None:



														"""simple docstring"""



														self.stack.append(UpperCAmelCase_							)
														snake_case_     							=		self.length + 1



							def 		lowerCAmelCase							(					self				:   List[str]							)       ->Any:



														"""simple docstring"""



														self.rotate(1							)
														snake_case_     							=		self.stack[self.length - 1]
														snake_case_     							=		self.stack[:-1]
														self.rotate(self.length - 1							)
														snake_case_     							=		self.length - 1
														return dequeued



							def 		lowerCAmelCase							(					self				:   List[str]		,							UpperCAmelCase_				:   int							)       ->None:



														"""simple docstring"""



														for _ in range(UpperCAmelCase_							):
																					snake_case_     							=		self.stack[0]
																					snake_case_     							=		self.stack[1:]
																					self.put(UpperCAmelCase_							)
																					snake_case_     							=		self.length - 1



							def 		lowerCAmelCase							(					self				:   Dict							)       ->Any:



														"""simple docstring"""



														snake_case_     							=		self.get()
														self.put(UpperCAmelCase_							)
														self.rotate(self.length - 1							)
														return front



							def 		lowerCAmelCase							(					self				:   Optional[Any]							)       ->int:



														"""simple docstring"""



														return self.length



