






from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

snake_case    				=		TypeVar("""T""")


class  SCREAMING_SNAKE_CASE			(			Generic[T]					):
  '''simple docstring'''


  def __init__(				self       :	Any					, UpperCAmelCase_       :	Optional[int]      ):
    SCREAMING_SNAKE_CASE       :      Optional[Any]							=    data
    SCREAMING_SNAKE_CASE       :      Node[T] | None							=    None






  def __str__(				self       :	int      ):
    return f'''{self.data}'''





class  SCREAMING_SNAKE_CASE			(			Generic[T]					):
  '''simple docstring'''


  def __init__(				self       :	Union[str, Any]      ):
    SCREAMING_SNAKE_CASE       :      Node[T] | None							=    None


  def __iter__(				self       :	Union[str, Any]      ):
    SCREAMING_SNAKE_CASE       :      Tuple							=    self.top
    while node:
      yield node.data
      SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    node.next


  def __str__(				self       :	Optional[Any]      ):
    return "->".join([str(_a      ) for item in self]      )


  def __len__(				self       :	List[Any]      ):
    return len(tuple(iter(self      )      )      )


  def 				_A       (				self       :	List[Any]      ):
    return self.top is None


  def 				_A       (				self       :	Dict					, UpperCAmelCase_       :	Optional[int]      ):
    SCREAMING_SNAKE_CASE       :      Optional[Any]							=    Node(_a      )
    if not self.is_empty():
      SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.top
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    node


  def 				_A       (				self       :	Any      ):
    if self.is_empty():
      raise IndexError("pop from empty stack"      )
    assert isinstance(self.top					, _a      )
    SCREAMING_SNAKE_CASE       :      List[Any]							=    self.top
    SCREAMING_SNAKE_CASE       :      str							=    self.top.next
    return pop_node.data


  def 				_A       (				self       :	Tuple      ):
    if self.is_empty():
      raise IndexError("peek from empty stack"      )

    assert self.top is not None
    return self.top.data






  def 				_A       (				self       :	Any      ):
    SCREAMING_SNAKE_CASE       :      List[Any]							=    None


if __name__ == "__main__":
   from doctest import testmod

   testmod()














import qiskit


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      List[str]							=    qiskit.Aer.get_backend("aer_simulator"				)

  # Create a Quantum Circuit acting on the q register
  SCREAMING_SNAKE_CASE       :      Dict							=    qiskit.QuantumCircuit(lowercase						,     lowercase				)

  # Map the quantum measurement to the classical bits
  circuit.measure([0]						,     [0]				)

  # Execute the circuit on the simulator
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    qiskit.execute(lowercase						,     lowercase						,     shots=1000				)

  # Return the histogram data of the results of the experiment.
  return job.result().get_counts(lowercase				)


if __name__ == "__main__":
   print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")






