


def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
       __snake_case	:    str											=     len(__lowerCamelCase			) + 1
       __snake_case	:    Union[str, Any]											=     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.
       __snake_case	:    Union[str, Any]											=     [[0 for i in range(__lowerCamelCase			)] for j in range(__lowerCamelCase			)]

       # since string of zero length match pattern of zero length
       __snake_case	:    Optional[int]											=     1

       # since pattern of zero length will never match with string of non-zero length
       for i in range(1							,			__lowerCamelCase			):
              __snake_case	:    List[Any]											=     0

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

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

   _snake_case  :	Tuple			      =       "aab"
   _snake_case  :	List[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}''')





from maths.prime_check import is_prime







def        lowerCAmelCase_  (      __lowerCamelCase			):
							if not isinstance(__lowerCamelCase							,			__lowerCamelCase			):
														__snake_case	:    List[str]											=     F'Input value of [number={number}] must be an integer'
														raise TypeError(__lowerCamelCase			)
							if is_prime(__lowerCamelCase			) and is_prime(number + 2			):
														return number + 2
							else:
														return -1


if __name__ == "__main__":
			import doctest

			doctest.testmod()

