





import qiskit
from qiskit.providers import Backend
def  __UpperCamelCase    (						snake_case							,			snake_case      )    ->		Tuple:


   '''simple docstring'''







   __A   ,		__A    =  bin(lowercase__      )[2:], bin(lowercase__      )[2:]  # Remove leading '0b'

   # Ensure that both strings are of the same length
   if len(lowercase__      ) > len(lowercase__      ):
      __A    =  y.zfill(len(lowercase__      )      )
   else:
      __A    =  x.zfill(len(lowercase__      )      )

   # We need (3 * number of bits in the larger number)+1 qBits
   # The second parameter is the number of classical registers, to measure the result
   __A    =  qiskit.QuantumCircuit((len(lowercase__      ) * 3) + 1							,			len(lowercase__      ) + 1      )

   # We are essentially "not-ing" the bits that are 1
   # Reversed because it's easier to perform ops on more significant bits
   for i in range(len(lowercase__      )      ):
      if x[::-1][i] == "1":
         circuit.x(lowercase__      )
   for j in range(len(lowercase__      )      ):
      if y[::-1][j] == "1":
         circuit.x(len(lowercase__      ) + j      )

   return circuit, x, y
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case							,			snake_case							,			snake_case							,			)    ->		Any:


   '''simple docstring'''







   circuit.ccx(lowercase__							,			lowercase__							,			lowercase__      )
   circuit.cx(lowercase__							,			lowercase__      )
   circuit.ccx(lowercase__							,			lowercase__							,			lowercase__      )
   circuit.cx(lowercase__							,			lowercase__      )
   circuit.cx(lowercase__							,			lowercase__      )
def  __UpperCamelCase    (						snake_case							,			snake_case							,			snake_case = qiskit.Aer.get_backend('''aer_simulator'''      )							,			)    ->		str:


   '''simple docstring'''







   if vala < 0 or vala < 0:
      raise ValueError('''Both Integers must be positive!'''      )

   # Store the Integers
   __A   ,		__A   ,		__A    =  store_two_classics(lowercase__							,			lowercase__      )
   for i in range(len(lowercase__      )      ):
      full_adder(lowercase__							,			lowercase__							,			len(lowercase__      ) + i							,			len(lowercase__      ) + len(lowercase__      ) + i							,			len(lowercase__      ) + len(lowercase__      ) + i + 1      )
      circuit.barrier()  # Optional, just for aesthetics

   # Measure the resultant qBits
   for i in range(len(lowercase__      ) + 1      ):
      circuit.measure([(len(lowercase__      ) * 2) + i]							,			[i]      )

   __A    =  qiskit.execute(lowercase__							,			lowercase__							,			shots=1      ).result()

   # The result is in binary. Convert it back to int
   return int(list(res.get_counts()      )[0]							,			2      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()









'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_keras_nlp_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A				:				Union[str, Any]					=		{
    """configuration_gpt2""": ["""GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPT2Config""", """GPT2OnnxConfig"""],
    """tokenization_gpt2""": ["""GPT2Tokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Tuple					=		["""GPT2TokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Optional[int]					=		[
     """GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """GPT2DoubleHeadsModel""",
     """GPT2ForQuestionAnswering""",
     """GPT2ForSequenceClassification""",
     """GPT2ForTokenClassification""",
     """GPT2LMHeadModel""",
     """GPT2Model""",
     """GPT2PreTrainedModel""",
     """load_tf_weights_in_gpt2""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Optional[Any]					=		[
     """TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """TFGPT2DoubleHeadsModel""",
     """TFGPT2ForSequenceClassification""",
     """TFGPT2LMHeadModel""",
     """TFGPT2MainLayer""",
     """TFGPT2Model""",
     """TFGPT2PreTrainedModel""",
 ]

try:
 if not is_keras_nlp_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Any					=		["""TFGPT2Tokenizer"""]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Tuple					=		["""FlaxGPT2LMHeadModel""", """FlaxGPT2Model""", """FlaxGPT2PreTrainedModel"""]

if TYPE_CHECKING:
 from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
 from .tokenization_gpta import GPTaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_gpta_fast import GPTaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_gpta import (
      GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
      GPTaDoubleHeadsModel,
      GPTaForQuestionAnswering,
      GPTaForSequenceClassification,
      GPTaForTokenClassification,
      GPTaLMHeadModel,
      GPTaModel,
      GPTaPreTrainedModel,
      load_tf_weights_in_gpta,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_gpta import (
      TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFGPTaDoubleHeadsModel,
      TFGPTaForSequenceClassification,
      TFGPTaLMHeadModel,
      TFGPTaMainLayer,
      TFGPTaModel,
      TFGPTaPreTrainedModel,
  )

 try:
  if not is_keras_nlp_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_gpta_tf import TFGPTaTokenizer

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel

else:
 import sys

 __A				:				Tuple					=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

