






def 					snake_case	(  lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	__lowercase   							=	len(lowerCamelCase       ) + 1
	__lowercase   							=	len(lowerCamelCase       ) + 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.
	__lowercase   							=	[[0 for i in range(lowerCamelCase       )] for j in range(lowerCamelCase       )]

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

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

	# since string of zero length will match with pattern where there
	# is at least one * alternatively
	for j in range(1					,	lowerCamelCase       ):
		__lowercase   							=	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					,	lowerCamelCase       ):
		for j in range(1					,	lowerCamelCase       ):
			if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
				__lowercase   							=	dp[i - 1][j - 1]

			elif pattern[j - 1] == "*":
				if dp[i][j - 2] == 1:
					__lowercase   							=	1
				elif pattern[j - 2] in (input_string[i - 1], "."):
					__lowercase   							=	dp[i - 1][j]
				else:
					__lowercase   							=	0
			else:
				__lowercase   							=	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 :")

						__UpperCamelCase   :   Any      =    """aab"""
						__UpperCamelCase   :   Optional[Any]      =    """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}''')





'''simple docstring'''
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCAmelCase_			:  int										=   logging.get_logger(__name__)

UpperCAmelCase_			:  List[Any]										=   {
    'facebook/deit-base-distilled-patch16-224': (
        'https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json'
    ),
    # See all DeiT models at https://huggingface.co/models?filter=deit
}

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		Union[str, Any]     				=    '''deit'''


 def __init__(   self   ,   __lowercase=768   ,   __lowercase=12   ,   __lowercase=12   ,   __lowercase=3_072   ,   __lowercase="gelu"   ,   __lowercase=0.0   ,   __lowercase=0.0   ,   __lowercase=0.0_2   ,   __lowercase=1E-12   ,   __lowercase=224   ,   __lowercase=16   ,   __lowercase=3   ,   __lowercase=True   ,   __lowercase=16   ,   **__lowercase   ,   ):

  """simple docstring"""







  super().__init__(**__lowercase    )

  __A	:		Union[str, Any]	  =      hidden_size
  __A	:		int	  =      num_hidden_layers
  __A	:		str	  =      num_attention_heads
  __A	:		Optional[int]	  =      intermediate_size
  __A	:		List[str]	  =      hidden_act
  __A	:		str	  =      hidden_dropout_prob
  __A	:		str	  =      attention_probs_dropout_prob
  __A	:		int	  =      initializer_range
  __A	:		Tuple	  =      layer_norm_eps
  __A	:		List[Any]	  =      image_size
  __A	:		Dict	  =      patch_size
  __A	:		Optional[Any]	  =      num_channels
  __A	:		List[Any]	  =      qkv_bias
  __A	:		str	  =      encoder_stride


class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		Optional[int]     				=    version.parse('''1.11'''					)


 @property
 def 			snake_case__ (   self    ):

  """simple docstring"""







  return OrderedDict(
      [
          ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
      ]    )







 @property
 def 			snake_case__ (   self    ):

  """simple docstring"""







  return 1E-4






