




'''simple docstring'''






from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


_lowerCAmelCase				     = logging.get_logger(__name__)

# General docstring
_lowerCAmelCase				     = '''ResNetConfig'''

# Base docstring
_lowerCAmelCase				     = '''microsoft/resnet-50'''
_lowerCAmelCase				     = [1, 2048, 7, 7]

# Image classification docstring
_lowerCAmelCase				     = '''microsoft/resnet-50'''
_lowerCAmelCase				     = '''tiger cat'''

_lowerCAmelCase				     = [
    '''microsoft/resnet-50''',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]



class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase = 3			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = "relu"			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      Dict									=       kernel_size // 2
							__UpperCamelCase				:      int									=       tf.keras.layers.ConvaD(
							    _UpperCAmelCase			,  kernel_size=_UpperCAmelCase			,  strides=_UpperCAmelCase			,  padding="valid"			,  use_bias=_UpperCAmelCase			,  name="convolution"      )
							# Use same default momentum and epsilon as PyTorch equivalent
							__UpperCamelCase				:      Optional[int]									=       tf.keras.layers.BatchNormalization(epsilon=1E-5			,  momentum=0.9			,  name="normalization"      )
							__UpperCamelCase				:      Union[str, Any]									=       ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"      )
				def 	a_	(self			,  _UpperCAmelCase      )     ->	tf.Tensor:
							# Pad to match that done in the PyTorch Conv2D model
							__UpperCamelCase				:      int									=       (self.pad_value, self.pad_value)
							__UpperCamelCase				:      Optional[int]									=       tf.pad(_UpperCAmelCase			,  [(0, 0), height_pad, width_pad, (0, 0)]      )
							__UpperCamelCase				:      Dict									=       self.conv(_UpperCAmelCase      )
							return hidden_state





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							__UpperCamelCase				:      List[str]									=       self.convolution(_UpperCAmelCase      )
							__UpperCamelCase				:      Tuple									=       self.normalization(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      List[str]									=       self.activation(_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      Dict									=       TFResNetConvLayer(
							    config.embedding_size			,  kernel_size=7			,  stride=2			,  activation=config.hidden_act			,  name="embedder"			,  )
							__UpperCamelCase				:      List[Any]									=       tf.keras.layers.MaxPoolaD(pool_size=3			,  strides=2			,  padding="valid"			,  name="pooler"      )
							__UpperCamelCase				:      List[str]									=       config.num_channels





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							__UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase		, __UpperCamelCase				:      Optional[Any]									=       shape_list(_UpperCAmelCase      )
							if tf.executing_eagerly() and num_channels != self.num_channels:
										raise ValueError(
										    "Make sure that the channel dimension of the pixel values match with the one set in the configuration."      )
							__UpperCamelCase				:      Optional[int]									=       pixel_values
							__UpperCamelCase				:      List[Any]									=       self.embedder(_UpperCAmelCase      )
							__UpperCamelCase				:      Any									=       tf.pad(_UpperCAmelCase			,  [[0, 0], [1, 1], [1, 1], [0, 0]]      )
							__UpperCamelCase				:      Optional[int]									=       self.pooler(_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase = 2			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      Any									=       tf.keras.layers.ConvaD(
							    _UpperCAmelCase			,  kernel_size=1			,  strides=_UpperCAmelCase			,  use_bias=_UpperCAmelCase			,  name="convolution"      )
							# Use same default momentum and epsilon as PyTorch equivalent
							__UpperCamelCase				:      int									=       tf.keras.layers.BatchNormalization(epsilon=1E-5			,  momentum=0.9			,  name="normalization"      )





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							__UpperCamelCase				:      Any									=       x
							__UpperCamelCase				:      Optional[Any]									=       self.convolution(_UpperCAmelCase      )
							__UpperCamelCase				:      Optional[int]									=       self.normalization(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = "relu"			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      List[Any]									=       in_channels != out_channels or stride != 1
							__UpperCamelCase				:      Tuple									=       TFResNetConvLayer(_UpperCAmelCase			,  stride=_UpperCAmelCase			,  name="layer.0"      )
							__UpperCamelCase				:      Tuple									=       TFResNetConvLayer(_UpperCAmelCase			,  activation=_UpperCAmelCase			,  name="layer.1"      )
							__UpperCamelCase				:      Tuple									=       (
							    TFResNetShortCut(_UpperCAmelCase			,  stride=_UpperCAmelCase			,  name="shortcut"      )
							    if should_apply_shortcut
							    else tf.keras.layers.Activation("linear"			,  name="shortcut"      )
							)
							__UpperCamelCase				:      Union[str, Any]									=       ACTaFN[activation]





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							__UpperCamelCase				:      Optional[int]									=       hidden_state
							__UpperCamelCase				:      Any									=       self.conva(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      Optional[Any]									=       self.conva(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      List[Any]									=       self.shortcut(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							hidden_state += residual
							__UpperCamelCase				:      str									=       self.activation(_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = "relu"			,  _UpperCAmelCase = 4			,  **_UpperCAmelCase			,  )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      List[str]									=       in_channels != out_channels or stride != 1
							__UpperCamelCase				:      Any									=       out_channels // reduction
							__UpperCamelCase				:      Any									=       TFResNetConvLayer(_UpperCAmelCase			,  kernel_size=1			,  name="layer.0"      )
							__UpperCamelCase				:      Optional[int]									=       TFResNetConvLayer(_UpperCAmelCase			,  stride=_UpperCAmelCase			,  name="layer.1"      )
							__UpperCamelCase				:      Union[str, Any]									=       TFResNetConvLayer(_UpperCAmelCase			,  kernel_size=1			,  activation=_UpperCAmelCase			,  name="layer.2"      )
							__UpperCamelCase				:      List[Any]									=       (
							    TFResNetShortCut(_UpperCAmelCase			,  stride=_UpperCAmelCase			,  name="shortcut"      )
							    if should_apply_shortcut
							    else tf.keras.layers.Activation("linear"			,  name="shortcut"      )
							)
							__UpperCamelCase				:      Union[str, Any]									=       ACTaFN[activation]





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							__UpperCamelCase				:      Any									=       hidden_state
							__UpperCamelCase				:      Tuple									=       self.conva(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      int									=       self.conva(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      Union[str, Any]									=       self.conva(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							__UpperCamelCase				:      str									=       self.shortcut(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							hidden_state += residual
							__UpperCamelCase				:      Optional[Any]									=       self.activation(_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = 2			,  _UpperCAmelCase = 2			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )

							__UpperCamelCase				:      Union[str, Any]									=       TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

							__UpperCamelCase				:      str									=       [layer(_UpperCAmelCase			,  _UpperCAmelCase			,  stride=_UpperCAmelCase			,  activation=config.hidden_act			,  name="layers.0"      )]
							layers += [
							    layer(_UpperCAmelCase			,  _UpperCAmelCase			,  activation=config.hidden_act			,  name=f"layers.{i + 1}"      )
							    for i in range(depth - 1      )
							]
							__UpperCamelCase				:      Any									=       layers





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False      )     ->	tf.Tensor:
							for layer in self.stage_layers:
										__UpperCamelCase				:      int									=       layer(_UpperCAmelCase			,  training=_UpperCAmelCase      )
							return hidden_state







class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
							__UpperCamelCase				:      Union[str, Any]									=       [
							    TFResNetStage(
							        _UpperCAmelCase			,  config.embedding_size			,  config.hidden_sizes[0]			,  stride=2 if config.downsample_in_first_stage else 1			,  depth=config.depths[0]			,  name="stages.0"			,  )
							]
							for i, (in_channels, out_channels, depth) in enumerate(
							    zip(config.hidden_sizes			,  config.hidden_sizes[1:]			,  config.depths[1:]      )      ):
										self.stages.append(TFResNetStage(_UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  depth=_UpperCAmelCase			,  name=f"stages.{i + 1}"      )      )





				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = False			,  _UpperCAmelCase = True			,  _UpperCAmelCase = False			,  )     ->	TFBaseModelOutputWithNoAttention:
							__UpperCamelCase				:      Dict									=       () if output_hidden_states else None

							for stage_module in self.stages:
										if output_hidden_states:
													__UpperCamelCase				:      str									=       hidden_states + (hidden_state,)

										__UpperCamelCase				:      Optional[Any]									=       stage_module(_UpperCAmelCase			,  training=_UpperCAmelCase      )

							if output_hidden_states:
										__UpperCamelCase				:      Union[str, Any]									=       hidden_states + (hidden_state,)

							if not return_dict:
										return tuple(v for v in [hidden_state, hidden_states] if v is not None      )

							return TFBaseModelOutputWithNoAttention(last_hidden_state=_UpperCAmelCase			,  hidden_states=_UpperCAmelCase      )







class  A		(			SCREAMING_SNAKE_CASE__		):




				'''simple docstring'''





				A				     =    ResNetConfig
				A				     =    "resnet"
				A				     =    "pixel_values"
				@property
				def 	a_	(self      )     ->	Union[str, Any]:
							return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)			,  dtype=tf.floataa      )}







_lowerCAmelCase				     = R'''
    This model is a TensorFlow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
'''


_lowerCAmelCase				     = R'''
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
'''



@keras_serializable
class  A		(			tf.keras.layers.Layer		):




				'''simple docstring'''





				A				     =    ResNetConfig
				def __init__(self			,  _UpperCAmelCase			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(**_UpperCAmelCase      )
							__UpperCamelCase				:      List[str]									=       config
							__UpperCamelCase				:      Optional[Any]									=       TFResNetEmbeddings(_UpperCAmelCase			,  name="embedder"      )
							__UpperCamelCase				:      Optional[int]									=       TFResNetEncoder(_UpperCAmelCase			,  name="encoder"      )
							__UpperCamelCase				:      Any									=       tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCAmelCase      )





				@unpack_inputs
				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = False			,  )     ->	Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
							__UpperCamelCase				:      Tuple									=       (
							    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
							)
							__UpperCamelCase				:      Optional[Any]									=       return_dict if return_dict is not None else self.config.use_return_dict

							# TF 2.0 image layers can't use NCHW format when running on CPU.
							# We transpose to NHWC format and then transpose back after the full forward pass.
							# (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
							__UpperCamelCase				:      List[str]									=       tf.transpose(_UpperCAmelCase			,  perm=[0, 2, 3, 1]      )
							__UpperCamelCase				:      List[str]									=       self.embedder(_UpperCAmelCase			,  training=_UpperCAmelCase      )

							__UpperCamelCase				:      List[str]									=       self.encoder(
							    _UpperCAmelCase			,  output_hidden_states=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  training=_UpperCAmelCase      )

							__UpperCamelCase				:      Optional[Any]									=       encoder_outputs[0]

							__UpperCamelCase				:      Dict									=       self.pooler(_UpperCAmelCase      )

							# Transpose all the outputs to the NCHW format
							# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
							__UpperCamelCase				:      Optional[int]									=       tf.transpose(_UpperCAmelCase			,  (0, 3, 1, 2)      )
							__UpperCamelCase				:      Dict									=       tf.transpose(_UpperCAmelCase			,  (0, 3, 1, 2)      )
							__UpperCamelCase				:      Union[str, Any]									=       ()
							for hidden_state in encoder_outputs[1:]:
										__UpperCamelCase				:      Optional[int]									=       hidden_states + tuple(tf.transpose(_UpperCAmelCase			,  (0, 3, 1, 2)      ) for h in hidden_state      )

							if not return_dict:
										return (last_hidden_state, pooled_output) + hidden_states

							__UpperCamelCase				:      int									=       hidden_states if output_hidden_states else None

							return TFBaseModelOutputWithPoolingAndNoAttention(
							    last_hidden_state=_UpperCAmelCase			,  pooler_output=_UpperCAmelCase			,  hidden_states=_UpperCAmelCase			,  )







@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."      ,							SCREAMING_SNAKE_CASE__      ,							)
class  A		(			SCREAMING_SNAKE_CASE__		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(_UpperCAmelCase			,  **_UpperCAmelCase      )
							__UpperCamelCase				:      List[str]									=       TFResNetMainLayer(config=_UpperCAmelCase			,  name="resnet"      )





				@add_start_docstrings_to_model_forward(_UpperCAmelCase      )
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC			,  output_type=_UpperCAmelCase			,  config_class=_CONFIG_FOR_DOC			,  modality="vision"			,  expected_output=_EXPECTED_OUTPUT_SHAPE			,  )
				@unpack_inputs
				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = False			,  )     ->	Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
							__UpperCamelCase				:      Union[str, Any]									=       (
							    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
							)
							__UpperCamelCase				:      Optional[Any]									=       return_dict if return_dict is not None else self.config.use_return_dict

							__UpperCamelCase				:      Dict									=       self.resnet(
							    pixel_values=_UpperCAmelCase			,  output_hidden_states=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  training=_UpperCAmelCase			,  )
							return resnet_outputs







@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "      ,							SCREAMING_SNAKE_CASE__      ,							)
class  A		(			SCREAMING_SNAKE_CASE__      ,							SCREAMING_SNAKE_CASE__		):




				'''simple docstring'''





				def __init__(self			,  _UpperCAmelCase			,  **_UpperCAmelCase      )     ->	None:
							super().__init__(_UpperCAmelCase			,  **_UpperCAmelCase      )
							__UpperCamelCase				:      Optional[int]									=       config.num_labels
							__UpperCamelCase				:      Dict									=       TFResNetMainLayer(_UpperCAmelCase			,  name="resnet"      )
							# classification head
							__UpperCamelCase				:      Tuple									=       (
							    tf.keras.layers.Dense(config.num_labels			,  name="classifier.1"      )
							    if config.num_labels > 0
							    else tf.keras.layers.Activation("linear"			,  name="classifier.1"      )
							)
				def 	a_	(self			,  _UpperCAmelCase      )     ->	tf.Tensor:
							__UpperCamelCase				:      Tuple									=       tf.keras.layers.Flatten()(_UpperCAmelCase      )
							__UpperCamelCase				:      Optional[Any]									=       self.classifier_layer(_UpperCAmelCase      )
							return logits





				@add_start_docstrings_to_model_forward(_UpperCAmelCase      )
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT			,  output_type=_UpperCAmelCase			,  config_class=_CONFIG_FOR_DOC			,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT			,  )
				@unpack_inputs
				def 	a_	(self			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = False			,  )     ->	Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
							__UpperCamelCase				:      int									=       return_dict if return_dict is not None else self.config.use_return_dict

							__UpperCamelCase				:      Dict									=       self.resnet(
							    _UpperCAmelCase			,  output_hidden_states=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  training=_UpperCAmelCase      )

							__UpperCamelCase				:      int									=       outputs.pooler_output if return_dict else outputs[1]

							__UpperCamelCase				:      Tuple									=       self.classifier(_UpperCAmelCase      )

							__UpperCamelCase				:      List[str]									=       None if labels is None else self.hf_compute_loss(_UpperCAmelCase			,  _UpperCAmelCase      )

							if not return_dict:
										__UpperCamelCase				:      Optional[Any]									=       (logits,) + outputs[2:]
										return (loss,) + output if loss is not None else output

							return TFImageClassifierOutputWithNoAttention(loss=_UpperCAmelCase			,  logits=_UpperCAmelCase			,  hidden_states=outputs.hidden_states      )









'''simple docstring'''






import math

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

def       __lowerCAmelCase (   snake_case__ = 1 ,				snake_case__ = 1						):
			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				:      Tuple									=       QuantumRegister(2 ,				"qr"						)
			__UpperCamelCase				:      Dict									=       ClassicalRegister(2 ,				"cr"						)

			__UpperCamelCase				:      str									=       QuantumCircuit(snake_case__ ,				snake_case__						)

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

			# send the information
			__UpperCamelCase				:      Optional[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				:      Dict									=       Aer.get_backend("aer_simulator"						)
			__UpperCamelCase				:      Tuple									=       execute(snake_case__ ,				snake_case__ ,				shots=1_000						)

			return job.result().get_counts(snake_case__						)


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



