





import math

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




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						int = 1 ,     snake_case_		:						int = 1						):
     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
     __magic_name__				=       QuantumRegister(2 ,     '''qr'''						)
     __magic_name__				=       ClassicalRegister(2 ,     '''cr'''						)

     __magic_name__				=       QuantumCircuit(snake_case_ ,     snake_case_						)

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

     # send the information
     __magic_name__				=       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_						)

     __magic_name__				=       Aer.get_backend('''aer_simulator'''						)
     __magic_name__				=       execute(snake_case_ ,     snake_case_ ,     shots=1000						)

     return job.result().get_counts(snake_case_						)


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






from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
a_    :				List[str]					=			TypeVar('T', bound='Enum')



@unique
class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__			):


  """simple docstring"""





  _a								=							80
  _a								=							70
  _a								=							60
  _a								=							50
  _a								=							40
  _a								=							30
  _a								=							20
  _a								=							10



@unique
class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__			):


  """simple docstring"""





  _a								=							24
  _a								=							21
  _a								=							18
  _a								=							15
  _a								=							12
  _a								=							9
  _a								=							6
  _a								=							3
  _a								=							2
  _a								=							1
  _a								=							-1
  _a								=							-2
  _a								=							-3
  _a								=							-6
  _a								=							-9
  _a								=							-12
  _a								=							-15
  _a								=							-18
  _a								=							-21
  _a								=							-24





  @classmethod
  def 			__A      (  cls						)		->   dict:





       '''simple docstring'''







       return {unit.name: unit.value for unit in cls if unit.value > 0}







  @classmethod
  def 			__A      (  cls						)		->   dict:





       '''simple docstring'''







       return {unit.name: unit.value for unit in cls if unit.value < 0}




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						float						):
     __magic_name__				=       SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
     for name_prefix, value_prefix in prefixes.items():
          __magic_name__				=       value / (10**value_prefix)
          if numerical_part > 1:
               return f'{numerical_part!s} {name_prefix}'
     return str(snake_case_						)




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						float						):
     for prefix in BinaryUnit:
          __magic_name__				=       value / (2**prefix.value)
          if numerical_part > 1:
               return f'{numerical_part!s} {prefix.name}'
     return str(snake_case_						)


if __name__ == "__main__":
    import doctest

    doctest.testmod()