
'''simple docstring'''

from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


UpperCAmelCase__ :			Tuple											=		logging.get_logger(__name__)

# General docstring
UpperCAmelCase__ :			int											=		"RegNetConfig"

# Base docstring
UpperCAmelCase__ :			Optional[int]											=		"facebook/regnet-y-040"
UpperCAmelCase__ :			Optional[int]											=		[1, 10_88, 7, 7]

# Image classification docstring
UpperCAmelCase__ :			Tuple											=		"facebook/regnet-y-040"
UpperCAmelCase__ :			Optional[Any]											=		"tabby, tabby cat"

UpperCAmelCase__ :			int											=		[
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]






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





	def __init__(       self      :							str   ,				__magic_name__      :							int   ,				__magic_name__      :							int = 3   ,				__magic_name__      :							int = 1   ,				__magic_name__      :							int = 1   ,				__magic_name__      :							Optional[str] = "relu"   ,				**__magic_name__      :							int   ,				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				# The padding and conv has been verified in
				# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
				lowerCAmelCase__										=				tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2				)
				lowerCAmelCase__										=				tf.keras.layers.ConvaD(
				    filters=__magic_name__   ,				kernel_size=__magic_name__   ,				strides=__magic_name__   ,				padding="VALID"   ,				groups=__magic_name__   ,				use_bias=__magic_name__   ,				name="convolution"   ,				)
				lowerCAmelCase__										=				tf.keras.layers.BatchNormalization(epsilon=1E-5   ,				momentum=0.9   ,				name="normalization"				)
				lowerCAmelCase__										=				ACTaFN[activation] if activation is not None else tf.identity







	def 				__SCREAMING_SNAKE_CASE	(       self      :							Any   ,				__magic_name__      :							str				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.convolution(self.padding(__magic_name__				)				)
				lowerCAmelCase__										=				self.normalization(__magic_name__				)
				lowerCAmelCase__										=				self.activation(__magic_name__				)
				return hidden_state






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





	def __init__(       self      :							List[Any]   ,				__magic_name__      :							RegNetConfig   ,				**__magic_name__      :							str				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				config.num_channels
				lowerCAmelCase__										=				TFRegNetConvLayer(
				    out_channels=config.embedding_size   ,				kernel_size=3   ,				stride=2   ,				activation=config.hidden_act   ,				name="embedder"   ,				)







	def 				__SCREAMING_SNAKE_CASE	(       self      :							Dict   ,				__magic_name__      :							List[Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				shape_list(__magic_name__				)[1]
				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."				)

				# When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
				# So change the input format from `NCHW` to `NHWC`.
				# shape = (batch_size, in_height, in_width, in_channels=num_channels)
				lowerCAmelCase__										=				tf.transpose(__magic_name__   ,				perm=(0, 2, 3, 1)				)
				lowerCAmelCase__										=				self.embedder(__magic_name__				)
				return hidden_state






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





	def __init__(       self      :							Any   ,				__magic_name__      :							int   ,				__magic_name__      :							int = 2   ,				**__magic_name__      :							Optional[Any]				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				tf.keras.layers.ConvaD(
				    filters=__magic_name__   ,				kernel_size=1   ,				strides=__magic_name__   ,				use_bias=__magic_name__   ,				name="convolution"				)
				lowerCAmelCase__										=				tf.keras.layers.BatchNormalization(epsilon=1E-5   ,				momentum=0.9   ,				name="normalization"				)







	def 				__SCREAMING_SNAKE_CASE	(       self      :							str   ,				__magic_name__      :							tf.Tensor   ,				__magic_name__      :							bool = False				):


				"""simple docstring"""

				return self.normalization(self.convolution(__magic_name__				)   ,				training=__magic_name__				)






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





	def __init__(       self      :							Union[str, Any]   ,				__magic_name__      :							int   ,				__magic_name__      :							int   ,				**__magic_name__      :							List[Any]				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=__magic_name__   ,				name="pooler"				)
				lowerCAmelCase__										=				[
				    tf.keras.layers.ConvaD(filters=__magic_name__   ,				kernel_size=1   ,				activation="relu"   ,				name="attention.0"				),
				    tf.keras.layers.ConvaD(filters=__magic_name__   ,				kernel_size=1   ,				activation="sigmoid"   ,				name="attention.2"				),
				]







	def 				__SCREAMING_SNAKE_CASE	(       self      :							List[Any]   ,				__magic_name__      :							Union[str, Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.pooler(__magic_name__				)
				for layer_module in self.attention:
							lowerCAmelCase__										=				layer_module(__magic_name__				)
				lowerCAmelCase__										=				hidden_state * pooled
				return hidden_state






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





	def __init__(       self      :							int   ,				__magic_name__      :							RegNetConfig   ,				__magic_name__      :							int   ,				__magic_name__      :							int   ,				__magic_name__      :							int = 1   ,				**__magic_name__      :							str				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				in_channels != out_channels or stride != 1
				lowerCAmelCase__										=				max(1   ,				out_channels // config.groups_width				)
				lowerCAmelCase__										=				(
				    TFRegNetShortCut(__magic_name__   ,				stride=__magic_name__   ,				name="shortcut"				)
				    if should_apply_shortcut
				    else tf.keras.layers.Activation("linear"   ,				name="shortcut"				)
				)
				# `self.layers` instead of `self.layer` because that is a reserved argument.
				lowerCAmelCase__										=				[
				    TFRegNetConvLayer(__magic_name__   ,				kernel_size=1   ,				activation=config.hidden_act   ,				name="layer.0"				),
				    TFRegNetConvLayer(
				        __magic_name__   ,				stride=__magic_name__   ,				groups=__magic_name__   ,				activation=config.hidden_act   ,				name="layer.1"				),
				    TFRegNetConvLayer(__magic_name__   ,				kernel_size=1   ,				activation=__magic_name__   ,				name="layer.2"				),
				]
				lowerCAmelCase__										=				ACTaFN[config.hidden_act]







	def 				__SCREAMING_SNAKE_CASE	(       self      :							Dict   ,				__magic_name__      :							Any				):


				"""simple docstring"""

				lowerCAmelCase__										=				hidden_state
				for layer_module in self.layers:
							lowerCAmelCase__										=				layer_module(__magic_name__				)
				lowerCAmelCase__										=				self.shortcut(__magic_name__				)
				hidden_state += residual
				lowerCAmelCase__										=				self.activation(__magic_name__				)
				return hidden_state






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





	def __init__(       self      :							int   ,				__magic_name__      :							RegNetConfig   ,				__magic_name__      :							int   ,				__magic_name__      :							int   ,				__magic_name__      :							int = 1   ,				**__magic_name__      :							str				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				in_channels != out_channels or stride != 1
				lowerCAmelCase__										=				max(1   ,				out_channels // config.groups_width				)
				lowerCAmelCase__										=				(
				    TFRegNetShortCut(__magic_name__   ,				stride=__magic_name__   ,				name="shortcut"				)
				    if should_apply_shortcut
				    else tf.keras.layers.Activation("linear"   ,				name="shortcut"				)
				)
				lowerCAmelCase__										=				[
				    TFRegNetConvLayer(__magic_name__   ,				kernel_size=1   ,				activation=config.hidden_act   ,				name="layer.0"				),
				    TFRegNetConvLayer(
				        __magic_name__   ,				stride=__magic_name__   ,				groups=__magic_name__   ,				activation=config.hidden_act   ,				name="layer.1"				),
				    TFRegNetSELayer(__magic_name__   ,				reduced_channels=int(round(in_channels / 4				)				)   ,				name="layer.2"				),
				    TFRegNetConvLayer(__magic_name__   ,				kernel_size=1   ,				activation=__magic_name__   ,				name="layer.3"				),
				]
				lowerCAmelCase__										=				ACTaFN[config.hidden_act]







	def 				__SCREAMING_SNAKE_CASE	(       self      :							Optional[int]   ,				__magic_name__      :							Any				):


				"""simple docstring"""

				lowerCAmelCase__										=				hidden_state
				for layer_module in self.layers:
							lowerCAmelCase__										=				layer_module(__magic_name__				)
				lowerCAmelCase__										=				self.shortcut(__magic_name__				)
				hidden_state += residual
				lowerCAmelCase__										=				self.activation(__magic_name__				)
				return hidden_state






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





	def __init__(       self      :							Union[str, Any]   ,				__magic_name__      :							RegNetConfig   ,				__magic_name__      :							int   ,				__magic_name__      :							int   ,				__magic_name__      :							int = 2   ,				__magic_name__      :							int = 2   ,				**__magic_name__      :							Optional[int]				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)

				lowerCAmelCase__										=				TFRegNetXLayer if config.layer_type == "x" else TFRegNetYLayer
				lowerCAmelCase__										=				[
				    # downsampling is done in the first layer with stride of 2
				    layer(__magic_name__   ,				__magic_name__   ,				__magic_name__   ,				stride=__magic_name__   ,				name="layers.0"				),
				    *[layer(__magic_name__   ,				__magic_name__   ,				__magic_name__   ,				name=f"""layers.{i+1}"""				) for i in range(depth - 1				)],
				]







	def 				__SCREAMING_SNAKE_CASE	(       self      :							str   ,				__magic_name__      :							List[str]				):


				"""simple docstring"""

				for layer_module in self.layers:
							lowerCAmelCase__										=				layer_module(__magic_name__				)
				return hidden_state






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





	def __init__(       self      :							Tuple   ,				__magic_name__      :							RegNetConfig   ,				**__magic_name__      :							Union[str, Any]				):


				"""simple docstring"""

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







	def 				__SCREAMING_SNAKE_CASE	(       self      :							List[str]   ,				__magic_name__      :							tf.Tensor   ,				__magic_name__      :							bool = False   ,				__magic_name__      :							bool = True				):


				"""simple docstring"""

				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(__magic_name__				)

				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=__magic_name__   ,				hidden_states=__magic_name__				)






@keras_serializable
class  A  (						tf.keras.layers.Layer     ):
	snake_case__   :List[Any]   =  RegNetConfig





	def __init__(       self      :							str   ,				__magic_name__      :							Union[str, Any]   ,				**__magic_name__      :							Union[str, Any]				):


				"""simple docstring"""

				super().__init__(**__magic_name__				)
				lowerCAmelCase__										=				config
				lowerCAmelCase__										=				TFRegNetEmbeddings(__magic_name__   ,				name="embedder"				)
				lowerCAmelCase__										=				TFRegNetEncoder(__magic_name__   ,				name="encoder"				)
				lowerCAmelCase__										=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=__magic_name__   ,				name="pooler"				)







	@unpack_inputs
	def 				__SCREAMING_SNAKE_CASE	(       self      :							List[Any]   ,				__magic_name__      :							tf.Tensor   ,				__magic_name__      :							Optional[bool] = None   ,				__magic_name__      :							Optional[bool] = None   ,				__magic_name__      :							bool = False   ,				):


				"""simple docstring"""

				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.embedder(__magic_name__   ,				training=__magic_name__				)

				lowerCAmelCase__										=				self.encoder(
				    __magic_name__   ,				output_hidden_states=__magic_name__   ,				return_dict=__magic_name__   ,				training=__magic_name__				)

				lowerCAmelCase__										=				encoder_outputs[0]
				lowerCAmelCase__										=				self.pooler(__magic_name__				)

				# Change to NCHW output format have uniformity in the modules
				lowerCAmelCase__										=				tf.transpose(__magic_name__   ,				perm=(0, 3, 1, 2)				)
				lowerCAmelCase__										=				tf.transpose(__magic_name__   ,				perm=(0, 3, 1, 2)				)

				# Change the other hidden state outputs to NCHW as well
				if output_hidden_states:
							lowerCAmelCase__										=				tuple([tf.transpose(__magic_name__   ,				perm=(0, 3, 1, 2)				) for h in encoder_outputs[1]]				)

				if not return_dict:
							return (last_hidden_state, pooled_output) + encoder_outputs[1:]

				return TFBaseModelOutputWithPoolingAndNoAttention(
				    last_hidden_state=__magic_name__   ,				pooler_output=__magic_name__   ,				hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states   ,				)






class  A  (						SCREAMING_SNAKE_CASE__     ):
	snake_case__   :str   =  RegNetConfig
	snake_case__   :Optional[Any]   =  'regnet'
	snake_case__   :Tuple   =  'pixel_values'





	@property
	def 				__SCREAMING_SNAKE_CASE	(       self      :							Union[str, Any]				):


				"""simple docstring"""

				return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)   ,				dtype=tf.floataa				)}

UpperCAmelCase__ :			List[str]											=		R"\n    Parameters:\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        config ([`RegNetConfig`]): 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"

UpperCAmelCase__ :			Tuple											=		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            [`ConveNextImageProcessor.__call__`] for details.\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"






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





	def __init__(       self      :							Any   ,				__magic_name__      :							RegNetConfig   ,				*__magic_name__      :							Optional[int]   ,				**__magic_name__      :							Union[str, Any]				):


				"""simple docstring"""

				super().__init__(__magic_name__   ,				*__magic_name__   ,				**__magic_name__				)
				lowerCAmelCase__										=				TFRegNetMainLayer(__magic_name__   ,				name="regnet"				)







	@unpack_inputs
	@add_start_docstrings_to_model_forward(__magic_name__				)
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC   ,				output_type=__magic_name__   ,				config_class=_CONFIG_FOR_DOC   ,				modality="vision"   ,				expected_output=_EXPECTED_OUTPUT_SHAPE   ,				)
	def 				__SCREAMING_SNAKE_CASE	(       self      :							str   ,				__magic_name__      :							tf.Tensor   ,				__magic_name__      :							Optional[bool] = None   ,				__magic_name__      :							Optional[bool] = None   ,				__magic_name__      :							int=False   ,				):


				"""simple docstring"""

				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.regnet(
				    pixel_values=__magic_name__   ,				output_hidden_states=__magic_name__   ,				return_dict=__magic_name__   ,				training=__magic_name__   ,				)
				if not return_dict:
							return (outputs[0],) + outputs[1:]

				return TFBaseModelOutputWithPoolingAndNoAttention(
				    last_hidden_state=outputs.last_hidden_state   ,				pooler_output=outputs.pooler_output   ,				hidden_states=outputs.hidden_states   ,				)






@add_start_docstrings(
    '\n    RegNet 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__     ):





	def __init__(       self      :							Tuple   ,				__magic_name__      :							RegNetConfig   ,				*__magic_name__      :							Tuple   ,				**__magic_name__      :							Optional[int]				):


				"""simple docstring"""

				super().__init__(__magic_name__   ,				*__magic_name__   ,				**__magic_name__				)
				lowerCAmelCase__										=				config.num_labels
				lowerCAmelCase__										=				TFRegNetMainLayer(__magic_name__   ,				name="regnet"				)
				# classification head
				lowerCAmelCase__										=				[
				    tf.keras.layers.Flatten(),
				    tf.keras.layers.Dense(config.num_labels   ,				name="classifier.1"				) if config.num_labels > 0 else tf.identity,
				]







	@unpack_inputs
	@add_start_docstrings_to_model_forward(__magic_name__				)
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT   ,				output_type=__magic_name__   ,				config_class=_CONFIG_FOR_DOC   ,				expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   ,				)
	def 				__SCREAMING_SNAKE_CASE	(       self      :							int   ,				__magic_name__      :							tf.Tensor = None   ,				__magic_name__      :							tf.Tensor = None   ,				__magic_name__      :							bool = None   ,				__magic_name__      :							bool = None   ,				__magic_name__      :							Dict=False   ,				):


				"""simple docstring"""

				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.regnet(
				    __magic_name__   ,				output_hidden_states=__magic_name__   ,				return_dict=__magic_name__   ,				training=__magic_name__				)

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

				lowerCAmelCase__										=				self.classifier[0](__magic_name__				)
				lowerCAmelCase__										=				self.classifier[1](__magic_name__				)

				lowerCAmelCase__										=				None if labels is None else self.hf_compute_loss(labels=__magic_name__   ,				logits=__magic_name__				)

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

				return TFSequenceClassifierOutput(loss=__magic_name__   ,				logits=__magic_name__   ,				hidden_states=outputs.hidden_states				)











'''simple docstring'''
def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		bool:
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1

			# dp is a 2d matrix where dp[i][j] denotes whether prefix string of
			# length i of input_string matches with prefix string of length j of
			# given pattern.
			# "dp" stands for dynamic programming.
			A_									= [[0 for i in range(SCREAMING_SNAKE_CASE_     )] for j in range(SCREAMING_SNAKE_CASE_     )]

			# since string of zero length match pattern of zero length
			A_									= 1

			# since pattern of zero length will never match with string of non-zero length
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= 0

			# since string of zero length will match with pattern where there
			# is at least one * alternatively
			for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= dp[0][j - 2] if pattern[j - 1] == '*' else 0

			# now using bottom-up approach to find for all remaining lengths
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
									if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
												A_									= dp[i - 1][j - 1]

									elif pattern[j - 1] == "*":
												if dp[i][j - 2] == 1:
															A_									= 1
												elif pattern[j - 2] in (input_string[i - 1], "."):
															A_									= dp[i - 1][j]
												else:
															A_									= 0
									else:
												A_									= 0

			return bool(dp[-1][-1]     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							# inputing the strings
							# input_string = input("input a string :")
							# pattern = input("input a pattern :")

							_SCREAMING_SNAKE_CASE			=						"aab"
							_SCREAMING_SNAKE_CASE			=						"c*a*b"

							# using function to check whether given string matches the given pattern
							if match_pattern(input_string, pattern):
														print(f"""{input_string} matches the given pattern {pattern}""")
							else:
														print(f"""{input_string} does not match with the given pattern {pattern}""")




