



"""simple docstring"""







from __future__ import annotations






class   UpperCAmelCase__		:



		def __init__(			self	:     Tuple   ,				snake_case	:     Tuple					)      ->    None:






									'''simple docstring'''

									A    =       value
									A    =       None
									A    =       None






class   UpperCAmelCase__		:
		lowerCAmelCase_							:						str							=  42



		def __init__(			self	:     List[str]					)      ->    None:






									'''simple docstring'''

									A    =       0



		def        A_		(			self	:     List[str]   ,				snake_case	:     List[Any]   ,				snake_case	:     Tuple					)      ->    None:






									'''simple docstring'''

									if node is None:
																return

									if path_sum == self.target:
																self.paths += 1

									if node.left:
																self.depth_first_search(node.left   ,				path_sum + node.left.value					)
									if node.right:
																self.depth_first_search(node.right   ,				path_sum + node.right.value					)



		def        A_		(			self	:     Tuple   ,				snake_case	:     Optional[Any]   ,				snake_case	:     int = None					)      ->    int:






									'''simple docstring'''

									if node is None:
																return 0
									if target is not None:
																A    =       target

									self.depth_first_search(SCREAMING_SNAKE_CASE__   ,				node.value					)
									self.path_sum(node.left					)
									self.path_sum(node.right					)

									return self.paths


if __name__ == "__main__":
							import doctest

							doctest.testmod()






"""simple docstring"""




import math

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



def 						UpperCAmelCase__ (					A__ = 1						,     A__ = 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
   lowerCamelCase__						       =      QuantumRegister(2						,     "qr" )
   lowerCamelCase__						       =      ClassicalRegister(2						,     "cr" )

   lowerCamelCase__						       =      QuantumCircuit(A__						,     A__ )

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

   # send the information
   lowerCamelCase__						       =      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__ )

   lowerCamelCase__						       =      Aer.get_backend("aer_simulator" )
   lowerCamelCase__						       =      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)}''')




