import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
    from test_module.custom_tokenization_fast import CustomTokenizerFast


class 			lowerCamelCase_  (     unittest.TestCase				):






   '''simple docstring'''






   def     UpperCamelCase__     (			self) ->			Union[str, Any]:
       __UpperCamelCase  :List[str]    						=	0







   @slow
   def     UpperCamelCase__     (			self) ->			Dict:
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
           __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(__lowercase)
           self.assertIsNotNone(__lowercase)
           self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
           self.assertGreater(len(__lowercase)				,				0)

       for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
           __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase)
           self.assertIsNotNone(__lowercase)
           self.assertIsInstance(__lowercase				,				(GPTaTokenizer, GPTaTokenizerFast))
           self.assertGreater(len(__lowercase)				,				0)







   def     UpperCamelCase__     (			self) ->			Dict:
       __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)
       self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
       self.assertEqual(tokenizer.vocab_size				,				12)







   def     UpperCamelCase__     (			self) ->			Dict:
       __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase)
       self.assertIsInstance(__lowercase				,				(RobertaTokenizer, RobertaTokenizerFast))
       self.assertEqual(tokenizer.vocab_size				,				20)







   def     UpperCamelCase__     (			self) ->			Optional[int]:
       __UpperCamelCase  :List[str]    						=	AutoConfig.from_pretrained(__lowercase)
       self.assertIsInstance(__lowercase				,				__lowercase)
       # Check that tokenizer_type ≠ model_type
       __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				config=__lowercase)
       self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
       self.assertEqual(tokenizer.vocab_size				,				12)







   def     UpperCamelCase__     (			self) ->			Optional[Any]:
       with tempfile.TemporaryDirectory() as tmp_dir:
           shutil.copy('''./tests/fixtures/vocab.txt'''				,				os.path.join(__lowercase				,				'''vocab.txt'''))

           __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''bert'''				,				use_fast=__lowercase)
           self.assertIsInstance(__lowercase				,				__lowercase)

       with tempfile.TemporaryDirectory() as tmp_dir:
           shutil.copy('''./tests/fixtures/vocab.json'''				,				os.path.join(__lowercase				,				'''vocab.json'''))
           shutil.copy('''./tests/fixtures/merges.txt'''				,				os.path.join(__lowercase				,				'''merges.txt'''))

           __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''gpt2'''				,				use_fast=__lowercase)
           self.assertIsInstance(__lowercase				,				__lowercase)







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			str:
       with tempfile.TemporaryDirectory() as tmp_dir:
           shutil.copy('''./tests/fixtures/vocab.txt'''				,				os.path.join(__lowercase				,				'''vocab.txt'''))

           __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''bert''')
           self.assertIsInstance(__lowercase				,				__lowercase)

       with tempfile.TemporaryDirectory() as tmp_dir:
           shutil.copy('''./tests/fixtures/vocab.json'''				,				os.path.join(__lowercase				,				'''vocab.json'''))
           shutil.copy('''./tests/fixtures/merges.txt'''				,				os.path.join(__lowercase				,				'''merges.txt'''))

           __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''gpt2''')
           self.assertIsInstance(__lowercase				,				__lowercase)







   def     UpperCamelCase__     (			self) ->			Dict:
       with pytest.raises(__lowercase):
           AutoTokenizer.from_pretrained('''./'''				,				tokenizer_type='''xxx''')







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Optional[int]:
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
           __UpperCamelCase  :Optional[Any]    						=	tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased''')
           self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))

           if isinstance(__lowercase				,				__lowercase):
               self.assertEqual(tokenizer.basic_tokenizer.do_lower_case				,				__lowercase)
           else:
               self.assertEqual(tokenizer.do_lower_case				,				__lowercase)

           self.assertEqual(tokenizer.model_max_length				,				512)







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			List[Any]:
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
           with self.assertRaisesRegex(
               __lowercase				,				'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''				,				):
               __UpperCamelCase  :Union[str, Any]    						=	tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists''')







   def     UpperCamelCase__     (			self) ->			Optional[int]:
       # tests: https://github.com/huggingface/transformers/pull/13251
       # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
       # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
       __UpperCamelCase  :List[str]    						=	TOKENIZER_MAPPING.values()
       __UpperCamelCase  :int    						=	[]

       for slow_tok, fast_tok in tokenizers:
           if slow_tok is not None:
               tokenizer_names.append(slow_tok.__name__)

           if fast_tok is not None:
               tokenizer_names.append(fast_tok.__name__)

       for tokenizer_name in tokenizer_names:
           # must find the right class
           tokenizer_class_from_name(__lowercase)







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Optional[int]:
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''				,				use_fast=__lowercase)				,				__lowercase)
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''')				,				__lowercase)







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Optional[int]:
       __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained('''distilbert-base-uncased'''				,				do_lower_case=__lowercase)
       __UpperCamelCase  :Dict    						=	'''Hello, world. How are you?'''
       __UpperCamelCase  :Any    						=	tokenizer.tokenize(__lowercase)
       self.assertEqual('''[UNK]'''				,				tokens[0])

       __UpperCamelCase  :Union[str, Any]    						=	AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''				,				do_lower_case=__lowercase)
       __UpperCamelCase  :Tuple    						=	tokenizer.tokenize(__lowercase)
       self.assertEqual('''[UNK]'''				,				tokens[0])







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Optional[int]:
       __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config''')
       self.assertEqual(type(__lowercase)				,				__lowercase)
       self.assertEqual(tokenizer.model_max_length				,				512)
       self.assertEqual(tokenizer.vocab_size				,				30_000)
       self.assertEqual(tokenizer.unk_token				,				'''[UNK]''')
       self.assertEqual(tokenizer.padding_side				,				'''right''')
       self.assertEqual(tokenizer.truncation_side				,				'''right''')







   def     UpperCamelCase__     (			self) ->			Union[str, Any]:
       __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)
       self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
       with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(__lowercase)
           __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)

       self.assertIsInstance(__lowercase				,				tokenizer.__class__)
       self.assertEqual(tokenizera.vocab_size				,				12)







   def     UpperCamelCase__     (			self) ->			Union[str, Any]:
       __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''ctrl''')
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(__lowercase				,				__lowercase)







   def     UpperCamelCase__     (			self) ->			Union[str, Any]:
       # Check we can load the tokenizer config of an online model.
       __UpperCamelCase  :List[str]    						=	get_tokenizer_config('''bert-base-cased''')
       __UpperCamelCase  :str    						=	config.pop('''_commit_hash'''				,				__lowercase)
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(__lowercase				,				{'''do_lower_case''': False})

       # This model does not have a tokenizer_config so we get back an empty dict.
       __UpperCamelCase  :int    						=	get_tokenizer_config(__lowercase)
       self.assertDictEqual(__lowercase				,				{})

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained(__lowercase)
       with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(__lowercase)
           __UpperCamelCase  :Optional[Any]    						=	get_tokenizer_config(__lowercase)

       # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
       self.assertEqual(config['''tokenizer_class''']				,				'''BertTokenizer''')







   def     UpperCamelCase__     (			self) ->			List[str]:
       try:
           AutoConfig.register('''custom'''				,				__lowercase)

           AutoTokenizer.register(__lowercase				,				slow_tokenizer_class=__lowercase)
           # Trying to register something existing in the Transformers library will raise an error
           with self.assertRaises(__lowercase):
               AutoTokenizer.register(__lowercase				,				slow_tokenizer_class=__lowercase)

           __UpperCamelCase  :List[Any]    						=	CustomTokenizer.from_pretrained(__lowercase)
           with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__lowercase)

               __UpperCamelCase  :Union[str, Any]    						=	AutoTokenizer.from_pretrained(__lowercase)
               self.assertIsInstance(__lowercase				,				__lowercase)

       finally:
           if "custom" in CONFIG_MAPPING._extra_content:
               del CONFIG_MAPPING._extra_content["custom"]
           if CustomConfig in TOKENIZER_MAPPING._extra_content:
               del TOKENIZER_MAPPING._extra_content[CustomConfig]







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Optional[int]:
       try:
           AutoConfig.register('''custom'''				,				__lowercase)

           # Can register in two steps
           AutoTokenizer.register(__lowercase				,				slow_tokenizer_class=__lowercase)
           self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				,				(CustomTokenizer, None))
           AutoTokenizer.register(__lowercase				,				fast_tokenizer_class=__lowercase)
           self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				,				(CustomTokenizer, CustomTokenizerFast))

           del TOKENIZER_MAPPING._extra_content[CustomConfig]
           # Can register in one step
           AutoTokenizer.register(
               __lowercase				,				slow_tokenizer_class=__lowercase				,				fast_tokenizer_class=__lowercase)
           self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				,				(CustomTokenizer, CustomTokenizerFast))

           # Trying to register something existing in the Transformers library will raise an error
           with self.assertRaises(__lowercase):
               AutoTokenizer.register(__lowercase				,				fast_tokenizer_class=__lowercase)

           # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
           # and that model does not have a tokenizer.json
           with tempfile.TemporaryDirectory() as tmp_dir:
               __UpperCamelCase  :str    						=	BertTokenizerFast.from_pretrained(__lowercase)
               bert_tokenizer.save_pretrained(__lowercase)
               __UpperCamelCase  :List[str]    						=	CustomTokenizerFast.from_pretrained(__lowercase)

           with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__lowercase)

               __UpperCamelCase  :int    						=	AutoTokenizer.from_pretrained(__lowercase)
               self.assertIsInstance(__lowercase				,				__lowercase)

               __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				use_fast=__lowercase)
               self.assertIsInstance(__lowercase				,				__lowercase)

       finally:
           if "custom" in CONFIG_MAPPING._extra_content:
               del CONFIG_MAPPING._extra_content["custom"]
           if CustomConfig in TOKENIZER_MAPPING._extra_content:
               del TOKENIZER_MAPPING._extra_content[CustomConfig]







   def     UpperCamelCase__     (			self) ->			List[str]:
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(__lowercase):
           __UpperCamelCase  :int    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''')
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(__lowercase):
           __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)

       __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
       self.assertTrue(tokenizer.special_attribute_present)
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(__lowercase)
           __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase				,				trust_remote_code=__lowercase)
       self.assertTrue(reloaded_tokenizer.special_attribute_present)

       if is_tokenizers_available():
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
           self.assertEqual(reloaded_tokenizer.__class__.__name__				,				'''NewTokenizerFast''')

           # Test we can also load the slow version
           __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
           self.assertTrue(tokenizer.special_attribute_present)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
           # Test tokenizer can be reloaded.
           with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__lowercase)
               __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
           self.assertEqual(reloaded_tokenizer.__class__.__name__				,				'''NewTokenizer''')
           self.assertTrue(reloaded_tokenizer.special_attribute_present)
       else:
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
           self.assertEqual(reloaded_tokenizer.__class__.__name__				,				'''NewTokenizer''')







   @require_tokenizers
   def     UpperCamelCase__     (			self) ->			Any:


       class 			lowerCamelCase_  (     UpperCAmelCase_				):






          '''simple docstring'''






          a__			:		Union[str, Any]      			=   False


       class 			lowerCamelCase_  (     UpperCAmelCase_				):






          '''simple docstring'''






          a__			:		str      			=   NewTokenizer
          a__			:		str      			=   False

       try:
           AutoConfig.register('''custom'''				,				__lowercase)
           AutoTokenizer.register(__lowercase				,				slow_tokenizer_class=__lowercase)
           AutoTokenizer.register(__lowercase				,				fast_tokenizer_class=__lowercase)
           # If remote code is not set, the default is to use local
           __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''')
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
           self.assertFalse(tokenizer.special_attribute_present)
           __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''				,				use_fast=__lowercase)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
           self.assertFalse(tokenizer.special_attribute_present)

           # If remote code is disabled, we load the local one.
           __UpperCamelCase  :Optional[int]    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
           self.assertFalse(tokenizer.special_attribute_present)
           __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
           self.assertFalse(tokenizer.special_attribute_present)

           # If remote is enabled, we load from the Hub
           __UpperCamelCase  :List[Any]    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
           self.assertTrue(tokenizer.special_attribute_present)
           __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
           self.assertTrue(tokenizer.special_attribute_present)

       finally:
           if "custom" in CONFIG_MAPPING._extra_content:
               del CONFIG_MAPPING._extra_content["custom"]
           if CustomConfig in TOKENIZER_MAPPING._extra_content:
               del TOKENIZER_MAPPING._extra_content[CustomConfig]







   def     UpperCamelCase__     (			self) ->			Dict:
       __UpperCamelCase  :List[Any]    						=	AutoTokenizer.from_pretrained(
           '''hf-internal-testing/test_dynamic_tokenizer_legacy'''				,				trust_remote_code=__lowercase)
       self.assertTrue(tokenizer.special_attribute_present)
       if is_tokenizers_available():
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')

           # Test we can also load the slow version
           __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(
               '''hf-internal-testing/test_dynamic_tokenizer_legacy'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
           self.assertTrue(tokenizer.special_attribute_present)
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
       else:
           self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')







   def     UpperCamelCase__     (			self) ->			Optional[int]:
       with self.assertRaisesRegex(
           __lowercase				,				'''bert-base is not a local folder and is not a valid model identifier'''):
           __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained('''bert-base''')







   def     UpperCamelCase__     (			self) ->			List[str]:
       with self.assertRaisesRegex(
           __lowercase				,				r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''):
           __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(__lowercase				,				revision='''aaaaaa''')







   def     UpperCamelCase__     (			self) ->			List[str]:
       # Make sure we have cached the tokenizer.
       __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''')
       with RequestCounter() as counter:
           __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''')
           self.assertEqual(counter.get_request_count				,				0)
           self.assertEqual(counter.head_request_count				,				1)
           self.assertEqual(counter.other_request_count				,				0)






import qiskit



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	qiskit.Aer.get_backend('''aer_simulator'''			)

    __UpperCamelCase  :Tuple    						=	qiskit.QuantumCircuit(4						,    2			)
    # encode inputs in qubits 0 and 1
    if bita == 1:
        qc_ha.x(0			)
    if bita == 1:
        qc_ha.x(1			)
    qc_ha.barrier()

    # use cnots to write XOR of the inputs on qubit2
    qc_ha.cx(0						,    2			)
    qc_ha.cx(1						,    2			)

    # use ccx / toffoli gate to write AND of the inputs on qubit3
    qc_ha.ccx(0						,    1						,    3			)
    qc_ha.barrier()

    # extract outputs
    qc_ha.measure(2						,    0			)  # extract XOR value
    qc_ha.measure(3						,    1			)  # extract AND value

    # Execute the circuit on the qasm simulator
    __UpperCamelCase  :Optional[Any]    						=	qiskit.execute(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    shots=1_000			)

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


if __name__ == "__main__":
    __lowercase											=      half_adder(1, 1)
    print(F'Half Adder Output Qubit Counts: {counts}')





