import math

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

def     lowercase_       (    _lowerCamelCase							: int = 1	,			_lowerCamelCase							: int = 1):
    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
    lowercase__				:     int					      =       QuantumRegister(2	,			"qr")
    lowercase__				:     str					      =       ClassicalRegister(2	,			"cr")

    lowercase__				:     List[Any]					      =       QuantumCircuit(_lowerCamelCase	,			_lowerCamelCase)

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

    # send the information
    lowercase__				:     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)

    lowercase__				:     Union[str, Any]					      =       Aer.get_backend("aer_simulator")
    lowercase__				:     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)}")




from typing import Callable

def     lowercase_       (    _lowerCamelCase							: Callable):

    def wrapper(_lowerCamelCase							: str):
        lowercase__				:     Tuple					      =       function_with_docstring.__doc__
        return target_function

    return wrapper



