

from __future__ import annotations



class SCREAMING_SNAKE_CASE	:
  """simple docstring"""






  def __init__(			self :    Optional[int]       ,							lowerCAmelCase :    int    )							->	Tuple:






     """simple docstring"""







     __lowerCAmelCase  :			Optional[Any]					    =						value
     __lowerCAmelCase  :			str					    =						None
     __lowerCAmelCase  :			Tuple					    =						None






class SCREAMING_SNAKE_CASE	:
  """simple docstring"""






  lowerCamelCase    :			int







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






     """simple docstring"""







     __lowerCAmelCase  :			int					    =						0







  def        SCREAMING_SNAKE_CASE    (			self :    Optional[int]       ,							lowerCAmelCase :    Node | None       ,							lowerCAmelCase :    int    )							->	Optional[Any]:






     """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        SCREAMING_SNAKE_CASE    (			self :    Any       ,							lowerCAmelCase :    Node | None       ,							lowerCAmelCase :    int | None = None    )							->	List[Any]:






     """simple docstring"""







     if node is None:
        return 0
     if target is not None:
        __lowerCAmelCase  :			int					    =						target

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

     return self.paths


if __name__ == "__main__":
   import doctest

   doctest.testmod()








import math

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




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						int = 1       ,     __UpperCamelCase			:						int = 1      )  ->							qiskit.result.counts.Counts:
    if isinstance(__UpperCamelCase       ,     __UpperCamelCase      ) or isinstance(__UpperCamelCase       ,     __UpperCamelCase      ):
        raise TypeError('''inputs must be integers.'''      )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError('''inputs must be positive.'''      )
    if (math.floor(__UpperCamelCase      ) != bit_a) or (math.floor(__UpperCamelCase      ) != 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_							 =     QuantumRegister(2       ,     '''qr'''      )
    UpperCAmelCase_							 =     ClassicalRegister(2       ,     '''cr'''      )

    UpperCAmelCase_							 =     QuantumCircuit(__UpperCamelCase       ,     __UpperCamelCase      )

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

    # send the information
    UpperCAmelCase_							 =     str(__UpperCamelCase      ) + str(__UpperCamelCase      )

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

    UpperCAmelCase_							 =     Aer.get_backend('''aer_simulator'''      )
    UpperCAmelCase_							 =     execute(__UpperCamelCase       ,     __UpperCamelCase       ,     shots=1000      )

    return job.result().get_counts(__UpperCamelCase      )


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





