code: 
  import qiskit
  from qiskit.providers import Backend
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int   , _UpperCAmelCase     :      int     )      -> tuple[qiskit.QuantumCircuit, str, str]:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						_lowercase			,						_lowercase					:  int    			=      bin(_UpperCAmelCase     )[2:], bin(_UpperCAmelCase     )[2:]  # Remove leading '0b'
  
  						# Ensure that both strings are of the same length
  						if len(_UpperCAmelCase     ) > len(_UpperCAmelCase     ):
  												_lowercase					:  Optional[int]    			=      y.zfill(len(_UpperCAmelCase     )     )
  						else:
  												_lowercase					:  List[Any]    			=      x.zfill(len(_UpperCAmelCase     )     )
  
  						# 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
  						_lowercase					:  Union[str, Any]    			=      qiskit.QuantumCircuit((len(_UpperCAmelCase     ) * 3) + 1   , len(_UpperCAmelCase     ) + 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(_UpperCAmelCase     )     ):
  												if x[::-1][i] == "1":
  																		circuit.x(_UpperCAmelCase     )
  						for j in range(len(_UpperCAmelCase     )     ):
  												if y[::-1][j] == "1":
  																		circuit.x(len(_UpperCAmelCase     ) + j     )
  
  						return circuit, x, y
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      qiskit.QuantumCircuit   , _UpperCAmelCase     :      int   , _UpperCAmelCase     :      int   , _UpperCAmelCase     :      int   , _UpperCAmelCase     :      int   , )      -> Tuple:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						circuit.ccx(_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase     )
  						circuit.cx(_UpperCAmelCase   , _UpperCAmelCase     )
  						circuit.ccx(_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase     )
  						circuit.cx(_UpperCAmelCase   , _UpperCAmelCase     )
  						circuit.cx(_UpperCAmelCase   , _UpperCAmelCase     )
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int   , _UpperCAmelCase     :      int   , _UpperCAmelCase     :      Backend = qiskit.Aer.get_backend("aer_simulator"     )   , )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						if vala < 0 or vala < 0:
  												raise ValueError("Both Integers must be positive!"     )
  
  						# Store the Integers
  						_lowercase			,						_lowercase			,						_lowercase					:  Optional[int]    			=      store_two_classics(_UpperCAmelCase   , _UpperCAmelCase     )
  						for i in range(len(_UpperCAmelCase     )     ):
  												full_adder(_UpperCAmelCase   , _UpperCAmelCase   , len(_UpperCAmelCase     ) + i   , len(_UpperCAmelCase     ) + len(_UpperCAmelCase     ) + i   , len(_UpperCAmelCase     ) + len(_UpperCAmelCase     ) + i + 1     )
  												circuit.barrier()  # Optional, just for aesthetics
  
  						# Measure the resultant qBits
  						for i in range(len(_UpperCAmelCase     ) + 1     ):
  												circuit.measure([(len(_UpperCAmelCase     ) * 2) + i]   , [i]     )
  
  						_lowercase					:  Optional[Any]    			=      qiskit.execute(_UpperCAmelCase   , _UpperCAmelCase   , 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()
  
  
  
  
  
style_context: 
  import os
  import unittest
  
  from transformers.models.bertweet.tokenization_bertweet import VOCAB_FILES_NAMES, BertweetTokenizer
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  class      __lowercase	(	__snake_case      ,   unittest.TestCase					):
  	_A   			=      BertweetTokenizer
  	_A   			=      False
  
  
  
  
  
  
  	def 			_a(self							:   Tuple						)   -> Any:
  							super().setUp()
  
  							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
  							_lowercase					:  Tuple    			=      ["I", "m", "V@@", "R@@", "r", "e@@"]
  							_lowercase					:  Tuple    			=      dict(zip(snake_case			,  range(len(snake_case						)						)						)						)
  							_lowercase					:  Tuple    			=      ["#version: 0.2", "a m</w>"]
  							_lowercase					:  Optional[Any]    			=      {"unk_token": "<unk>"}
  
  							_lowercase					:  int    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["vocab_file"]						)
  							_lowercase					:  Optional[int]    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["merges_file"]						)
  							with open(self.vocab_file			,  "w"			,  encoding="utf-8"						) as fp:
  													for token in vocab_tokens:
  																			fp.write(F"""{token} {vocab_tokens[token]}\n"""						)
  							with open(self.merges_file			,  "w"			,  encoding="utf-8"						) as fp:
  													fp.write("\n".join(snake_case						)						)
  
  
  
  
  
  
  	def 			_a(self							:   List[Any]			,  **snake_case							:   Tuple						)   -> Union[str, Any]:
  							kwargs.update(self.special_tokens_map						)
  							return BertweetTokenizer.from_pretrained(self.tmpdirname			,  **snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   Any			,  snake_case							:   Any						)   -> List[Any]:
  							_lowercase					:  Tuple    			=      "I am VinAI Research"
  							_lowercase					:  Optional[int]    			=      "I <unk> m V<unk> <unk> <unk> I Re<unk> e<unk> <unk> <unk> <unk>"
  							return input_text, output_text
  
  
  
  
  
  
  	def 			_a(self							:   str						)   -> Optional[int]:
  							_lowercase					:  str    			=      BertweetTokenizer(self.vocab_file			,  self.merges_file			,  **self.special_tokens_map						)
  							_lowercase					:  Optional[Any]    			=      "I am VinAI Research"
  							_lowercase					:  str    			=      "I a@@ m V@@ i@@ n@@ A@@ I R@@ e@@ s@@ e@@ a@@ r@@ c@@ h".split()
  							_lowercase					:  Tuple    			=      tokenizer.tokenize(snake_case						)
  							self.assertListEqual(snake_case			,  snake_case						)
  
  							_lowercase					:  str    			=      tokens + [tokenizer.unk_token]
  
  							_lowercase					:  str    			=      [4, 3, 5, 6, 3, 3, 3, 4, 7, 9, 3, 9, 3, 3, 3, 3, 3]
  							self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case						)			,  snake_case						)
  
  
  
  
  