




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


__SCREAMING_SNAKE_CASE    :   List[str]       =logging.get_logger(__name__)

# General docstring
__SCREAMING_SNAKE_CASE    :   Optional[Any]       ="""ResNetConfig"""

# Base docstring
__SCREAMING_SNAKE_CASE    :   Dict       ="""microsoft/resnet-50"""
__SCREAMING_SNAKE_CASE    :   Tuple       =[1, 2_048, 7, 7]

# Image classification docstring
__SCREAMING_SNAKE_CASE    :   Optional[Any]       ="""microsoft/resnet-50"""
__SCREAMING_SNAKE_CASE    :   List[Any]       ="""tiger cat"""

__SCREAMING_SNAKE_CASE    :   List[str]       =[
    """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  :   Union[str, Any]	,  A__  :   Optional[Any]	,  A__  :   Optional[Any] = 3	,  A__  :   Optional[int] = 1	,  A__  :   str = "relu"	,  **A__  :   List[Any]			)				->       None:
           super().__init__(**__lowerCamelCase			)
           lowerCamelCase__        =				kernel_size // 2
           lowerCamelCase__        =				tf.keras.layers.ConvaD(
               __lowerCamelCase	,  kernel_size=__lowerCamelCase	,  strides=__lowerCamelCase	,  padding='valid'	,  use_bias=__lowerCamelCase	,  name='convolution'			)
           # Use same default momentum and epsilon as PyTorch equivalent
           lowerCamelCase__        =				tf.keras.layers.BatchNormalization(epsilon=1E-5	,  momentum=0.9	,  name='normalization'			)
           lowerCamelCase__        =				ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'			)




     def  __snake_case   (    self  :   Optional[int]	,  A__  :   Optional[Any]			)				->       tf.Tensor:
           # Pad to match that done in the PyTorch Conv2D model
           lowerCamelCase__        =				(self.pad_value, self.pad_value)
           lowerCamelCase__        =				tf.pad(__lowerCamelCase	,  [(0, 0), height_pad, width_pad, (0, 0)]			)
           lowerCamelCase__        =				self.conv(__lowerCamelCase			)
           return hidden_state




     def  __snake_case   (    self  :   List[Any]	,  A__  :   List[Any]	,  A__  :   int = False			)				->       tf.Tensor:
           lowerCamelCase__        =				self.convolution(__lowerCamelCase			)
           lowerCamelCase__        =				self.normalization(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.activation(__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

     def __init__(    self  :   Optional[int]	,  A__  :   Optional[Any]	,  **A__  :   str			)				->       None:
           super().__init__(**__lowerCamelCase			)
           lowerCamelCase__        =				TFResNetConvLayer(
               config.embedding_size	,  kernel_size=7	,  stride=2	,  activation=config.hidden_act	,  name='embedder'	,  )
           lowerCamelCase__        =				tf.keras.layers.MaxPoolaD(pool_size=3	,  strides=2	,  padding='valid'	,  name='pooler'			)
           lowerCamelCase__        =				config.num_channels




     def  __snake_case   (    self  :   Dict	,  A__  :   Optional[Any]	,  A__  :   Tuple = False			)				->       tf.Tensor:
           lowerCamelCase__        =				shape_list(__lowerCamelCase			)
           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.'			)
           lowerCamelCase__        =				pixel_values
           lowerCamelCase__        =				self.embedder(__lowerCamelCase			)
           lowerCamelCase__        =				tf.pad(__lowerCamelCase	,  [[0, 0], [1, 1], [1, 1], [0, 0]]			)
           lowerCamelCase__        =				self.pooler(__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

     def __init__(    self  :   int	,  A__  :   Tuple	,  A__  :   Dict = 2	,  **A__  :   Union[str, Any]			)				->       None:
           super().__init__(**__lowerCamelCase			)
           lowerCamelCase__        =				tf.keras.layers.ConvaD(
               __lowerCamelCase	,  kernel_size=1	,  strides=__lowerCamelCase	,  use_bias=__lowerCamelCase	,  name='convolution'			)
           # Use same default momentum and epsilon as PyTorch equivalent
           lowerCamelCase__        =				tf.keras.layers.BatchNormalization(epsilon=1E-5	,  momentum=0.9	,  name='normalization'			)




     def  __snake_case   (    self  :   Optional[int]	,  A__  :   Optional[Any]	,  A__  :   str = False			)				->       tf.Tensor:
           lowerCamelCase__        =				x
           lowerCamelCase__        =				self.convolution(__lowerCamelCase			)
           lowerCamelCase__        =				self.normalization(__lowerCamelCase	,  training=__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

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




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   Any	,  A__  :   Optional[int] = False			)				->       tf.Tensor:
           lowerCamelCase__        =				hidden_state
           lowerCamelCase__        =				self.conva(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.conva(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.shortcut(__lowerCamelCase	,  training=__lowerCamelCase			)
           hidden_state += residual
           lowerCamelCase__        =				self.activation(__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

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




     def  __snake_case   (    self  :   int	,  A__  :   Any	,  A__  :   int = False			)				->       tf.Tensor:
           lowerCamelCase__        =				hidden_state
           lowerCamelCase__        =				self.conva(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.conva(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.conva(__lowerCamelCase	,  training=__lowerCamelCase			)
           lowerCamelCase__        =				self.shortcut(__lowerCamelCase	,  training=__lowerCamelCase			)
           hidden_state += residual
           lowerCamelCase__        =				self.activation(__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

     def __init__(    self  :   Tuple	,  A__  :   List[str]	,  A__  :   str	,  A__  :   Optional[Any]	,  A__  :   List[Any] = 2	,  A__  :   List[str] = 2	,  **A__  :   int			)				->       None:
           super().__init__(**__lowerCamelCase			)

           lowerCamelCase__        =				TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

           lowerCamelCase__        =				[layer(__lowerCamelCase	,  __lowerCamelCase	,  stride=__lowerCamelCase	,  activation=config.hidden_act	,  name='layers.0'			)]
           layers += [
               layer(__lowerCamelCase	,  __lowerCamelCase	,  activation=config.hidden_act	,  name=F"""layers.{i + 1}"""			)
               for i in range(depth - 1			)
           ]
           lowerCamelCase__        =				layers




     def  __snake_case   (    self  :   Optional[Any]	,  A__  :   Optional[int]	,  A__  :   str = False			)				->       tf.Tensor:
           for layer in self.stage_layers:
                 lowerCamelCase__        =				layer(__lowerCamelCase	,  training=__lowerCamelCase			)
           return hidden_state






class 			A			(		tf.keras.layers.Layer		):
     """simple docstring"""

     def __init__(    self  :   int	,  A__  :   Optional[Any]	,  **A__  :   List[str]			)				->       None:
           super().__init__(**__lowerCamelCase			)
           # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
           lowerCamelCase__        =				[
               TFResNetStage(
                   __lowerCamelCase	,  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(__lowerCamelCase	,  __lowerCamelCase	,  __lowerCamelCase	,  depth=__lowerCamelCase	,  name=F"""stages.{i + 1}"""			)			)




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   str	,  A__  :   Any = False	,  A__  :   List[Any] = True	,  A__  :   Union[str, Any] = False	,  )				->       TFBaseModelOutputWithNoAttention:
           lowerCamelCase__        =				() if output_hidden_states else None

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

                 lowerCamelCase__        =				stage_module(__lowerCamelCase	,  training=__lowerCamelCase			)

           if output_hidden_states:
                 lowerCamelCase__        =				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=__lowerCamelCase	,  hidden_states=__lowerCamelCase			)






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     _snake_case:	Dict     =ResNetConfig
     _snake_case:	str     ="resnet"
     _snake_case:	int     ="pixel_values"




     @property
     def  __snake_case   (    self  :   Dict			)				->       int:
           return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)	,  dtype=tf.floataa			)}
__SCREAMING_SNAKE_CASE    :   Union[str, Any]       =R"""\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"""


__SCREAMING_SNAKE_CASE    :   List[Any]       =R"""\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"""






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

     _snake_case:	Tuple     =ResNetConfig




     def __init__(    self  :   Optional[Any]	,  A__  :   List[str]	,  **A__  :   int			)				->       None:
           super().__init__(**__lowerCamelCase			)
           lowerCamelCase__        =				config
           lowerCamelCase__        =				TFResNetEmbeddings(__lowerCamelCase	,  name='embedder'			)
           lowerCamelCase__        =				TFResNetEncoder(__lowerCamelCase	,  name='encoder'			)
           lowerCamelCase__        =				tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase			)




     @unpack_inputs
     def  __snake_case   (    self  :   str	,  A__  :   int	,  A__  :   List[str] = None	,  A__  :   Tuple = None	,  A__  :   Tuple = False	,  )				->       Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
           lowerCamelCase__        =				(
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowerCamelCase__        =				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)
           lowerCamelCase__        =				tf.transpose(__lowerCamelCase	,  perm=[0, 2, 3, 1]			)
           lowerCamelCase__        =				self.embedder(__lowerCamelCase	,  training=__lowerCamelCase			)

           lowerCamelCase__        =				self.encoder(
               __lowerCamelCase	,  output_hidden_states=__lowerCamelCase	,  return_dict=__lowerCamelCase	,  training=__lowerCamelCase			)

           lowerCamelCase__        =				encoder_outputs[0]

           lowerCamelCase__        =				self.pooler(__lowerCamelCase			)

           # Transpose all the outputs to the NCHW format
           # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
           lowerCamelCase__        =				tf.transpose(__lowerCamelCase	,  (0, 3, 1, 2)			)
           lowerCamelCase__        =				tf.transpose(__lowerCamelCase	,  (0, 3, 1, 2)			)
           lowerCamelCase__        =				()
           for hidden_state in encoder_outputs[1:]:
                 lowerCamelCase__        =				hidden_states + tuple(tf.transpose(__lowerCamelCase	,  (0, 3, 1, 2)			) for h in hidden_state			)

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

           lowerCamelCase__        =				hidden_states if output_hidden_states else None

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






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

     def __init__(    self  :   Optional[int]	,  A__  :   Optional[Any]	,  **A__  :   Dict			)				->       None:
           super().__init__(__lowerCamelCase	,  **__lowerCamelCase			)
           lowerCamelCase__        =				TFResNetMainLayer(config=__lowerCamelCase	,  name='resnet'			)




     @add_start_docstrings_to_model_forward(__lowerCamelCase			)
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC	,  output_type=__lowerCamelCase	,  config_class=_CONFIG_FOR_DOC	,  modality='vision'	,  expected_output=_EXPECTED_OUTPUT_SHAPE	,  )
     @unpack_inputs
     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   Tuple	,  A__  :   str = None	,  A__  :   int = None	,  A__  :   int = False	,  )				->       Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
           lowerCamelCase__        =				(
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowerCamelCase__        =				return_dict if return_dict is not None else self.config.use_return_dict

           lowerCamelCase__        =				self.resnet(
               pixel_values=__lowerCamelCase	,  output_hidden_states=__lowerCamelCase	,  return_dict=__lowerCamelCase	,  training=__lowerCamelCase	,  )
           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    "			,						_lowerCAmelCase			,						)
class 			A			(		_lowerCAmelCase			,						_lowerCAmelCase		):
     """simple docstring"""

     def __init__(    self  :   Optional[Any]	,  A__  :   Any	,  **A__  :   Tuple			)				->       None:
           super().__init__(__lowerCamelCase	,  **__lowerCamelCase			)
           lowerCamelCase__        =				config.num_labels
           lowerCamelCase__        =				TFResNetMainLayer(__lowerCamelCase	,  name='resnet'			)
           # classification head
           lowerCamelCase__        =				(
               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  __snake_case   (    self  :   int	,  A__  :   Dict			)				->       tf.Tensor:
           lowerCamelCase__        =				tf.keras.layers.Flatten()(__lowerCamelCase			)
           lowerCamelCase__        =				self.classifier_layer(__lowerCamelCase			)
           return logits




     @add_start_docstrings_to_model_forward(__lowerCamelCase			)
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT	,  output_type=__lowerCamelCase	,  config_class=_CONFIG_FOR_DOC	,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT	,  )
     @unpack_inputs
     def  __snake_case   (    self  :   str	,  A__  :   Any = None	,  A__  :   Tuple = None	,  A__  :   int = None	,  A__  :   Union[str, Any] = None	,  A__  :   List[str] = False	,  )				->       Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
           lowerCamelCase__        =				return_dict if return_dict is not None else self.config.use_return_dict

           lowerCamelCase__        =				self.resnet(
               __lowerCamelCase	,  output_hidden_states=__lowerCamelCase	,  return_dict=__lowerCamelCase	,  training=__lowerCamelCase			)

           lowerCamelCase__        =				outputs.pooler_output if return_dict else outputs[1]

           lowerCamelCase__        =				self.classifier(__lowerCamelCase			)

           lowerCamelCase__        =				None if labels is None else self.hf_compute_loss(__lowerCamelCase	,  __lowerCamelCase			)

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

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





import importlib.metadata
import sys

from transformers.testing_utils import TestCasePlus
from transformers.utils.versions import require_version, require_version_core


__SCREAMING_SNAKE_CASE    :   int       =importlib.metadata.version("""numpy""")
__SCREAMING_SNAKE_CASE    :   Optional[int]       =""".""".join([str(x) for x in sys.version_info[:3]])






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     def  __snake_case   (    self  :   List[Any]			)				->       Optional[int]:
           # lt + different version strings
           require_version_core('numpy<1000.4.5'			)
           require_version_core('numpy<1000.4'			)
           require_version_core('numpy<1000'			)

           # le
           require_version_core('numpy<=1000.4.5'			)
           require_version_core(F"""numpy<={numpy_ver}"""			)

           # eq
           require_version_core(F"""numpy=={numpy_ver}"""			)

           # ne
           require_version_core('numpy!=1000.4.5'			)

           # ge
           require_version_core('numpy>=1.0'			)
           require_version_core('numpy>=1.0.0'			)
           require_version_core(F"""numpy>={numpy_ver}"""			)

           # gt
           require_version_core('numpy>1.0.0'			)

           # mix
           require_version_core('numpy>1.0.0,<1000'			)

           # requirement w/o version
           require_version_core('numpy'			)

           # unmet requirements due to version conflict
           for req in ["numpy==1.0.0", "numpy>=1000.0.0", F"""numpy<{numpy_ver}"""]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn('but found'	,  str(A__			)			)

        # unmet requirements due to missing module
           for req in ["numpipypie>1", "numpipypie2"]:
                 try:
                       require_version_core(A__			)
                 except importlib.metadata.PackageNotFoundError as e:
                       self.assertIn(F"""The '{req}' distribution was not found and is required by this application"""	,  str(A__			)			)
                       self.assertIn('Try: pip install transformers -U'	,  str(A__			)			)

        # bogus requirements formats:
        # 1. whole thing
           for req in ["numpy??1.0.0", "numpy1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('requirement needs to be in the pip package format'	,  str(A__			)			)
        # 2. only operators
           for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('need one of '	,  str(A__			)			)




     def  __snake_case   (    self  :   str			)				->       Optional[int]:
           # matching requirement
           require_version('python>=3.6.0'			)

           # not matching requirements
           for req in ["python>9.9.9", "python<3.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn(F"""but found python=={python_ver}"""	,  str(A__			)			)