



from typing import List

from tokenizers import NormalizedString, PreTokenizedString, normalizers


class 	snake_case_			:




       """simple docstring"""






       def __init__(  self  ,lowercase):

             """simple docstring"""





             UpperCAmelCase_	:						List[str]					   =		vocab
             UpperCAmelCase_	:						Any					   =		normalizers.BertNormalizer(
                 clean_text=lowercase  ,handle_chinese_chars=lowercase  ,strip_accents=lowercase  ,lowercase=lowercase  ,)
             try:
                   import rjieba
             except ImportError:
                   raise ImportError(
                       "You need to install rjieba to use RoFormerTokenizer. "
                       "See https://pypi.org/project/rjieba/ for installation.")
             UpperCAmelCase_	:						Union[str, Any]					   =		rjieba



       def 			A_ (  self  ,lowercase  ,lowercase):

             """simple docstring"""





             UpperCAmelCase_	:						List[str]					   =		[]

             # this code slice normalized_string is too slow (6s) but test_alignement_methods can pass
             for token, start, end in self.jieba.tokenize(str(lowercase)  ,hmm=lowercase):
                   if token in self.vocab:
                         splits.append(normalized_string[start:end])
                   else:
                         UpperCAmelCase_	:						Optional[int]					   =		self.normalizers.normalize_str(lowercase).split()
                         for token in token_list:
                               if token:
                                     UpperCAmelCase_	:						Any					   =		start + len(lowercase)
                                     splits.append(normalized_string[start:end])
                                     UpperCAmelCase_	:						Optional[Any]					   =		end

        # this code test_alignement_methods can't pass but fast (300ms)
        # for token in self.jieba.cut(str(normalized_string), False):
        #     if token in self.vocab:
        #         splits.append(NormalizedString(token))
        #     else:
        #         token_list = self.normalizers.normalize_str(token).split()
        #         for token in token_list:
        #             if token:
        #                 splits.append(NormalizedString(token))

             return splits



       def 			A_ (  self  ,lowercase):

             """simple docstring"""





             pretok.split(self.jieba_split)





import math

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







def  _snake_case			(							__snake_case = 1       ,	__snake_case = 1     )  ->  qiskit.result.counts.Counts:






      '''simple docstring'''







      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
      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumRegister(2       ,	"qr"     )
      UpperCAmelCase_	:						Tuple					   =		ClassicalRegister(2       ,	"cr"     )

      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumCircuit(__snake_case       ,	__snake_case     )

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

      # send the information
      UpperCAmelCase_	:						Any					   =		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     )

      UpperCAmelCase_	:						Union[str, Any]					   =		Aer.get_backend("aer_simulator"     )
      UpperCAmelCase_	:						Dict					   =		execute(__snake_case       ,	__snake_case       ,	shots=1_0_0_0     )

      return job.result().get_counts(__snake_case     )


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