"""simple docstring"""



# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


__lowercase		:		Tuple														=							re.compile(r"^(?P<major>\d+)" r"\.(?P<minor>\d+)" r"\.(?P<patch>\d+)$")



@total_ordering
@dataclass
class      _A	:




    """simple docstring"""




    UpperCamelCase_	:					str
    UpperCamelCase_	:					Optional[str]							=					None
    UpperCamelCase_	:					Optional[Union[str, int]]							=					None
    UpperCamelCase_	:					Optional[Union[str, int]]							=					None
    UpperCamelCase_	:					Optional[Union[str, int]]							=					None
    def  lowercase					(		self							:     List[Any]    )    ->       Optional[Any]:
         __snake_case		,	__snake_case		,	__snake_case				=							_str_to_version_tuple(self.version_str    )
    def __repr__(		self							:     int    )    ->       Dict:
         return f"{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"
    @property
    def  lowercase					(		self							:     Tuple    )    ->       Tuple:
         return self.major, self.minor, self.patch
    def  lowercase					(		self							:     Optional[int]	,      A_							:     Dict    )    ->       Optional[int]:
         if isinstance(A_	,      A_    ):
              return Version(A_    )
         elif isinstance(A_	,      A_    ):
              return other
         raise TypeError(f"{other} (type {type(A_    )}) cannot be compared to version."    )
    def __eq__(		self							:     str	,      A_							:     Union[str, Any]    )    ->       int:
         try:
              __snake_case				=							self._validate_operand(A_    )
         except (TypeError, ValueError):
              return False
         else:
              return self.tuple == other.tuple
    def __lt__(		self							:     List[str]	,      A_							:     Any    )    ->       Union[str, Any]:
         __snake_case				=							self._validate_operand(A_    )
         return self.tuple < other.tuple
    def __hash__(		self							:     List[str]    )    ->       List[str]:
         return hash(_version_tuple_to_str(self.tuple    )    )
    @classmethod
    def  lowercase					(		cls							:     List[str]	,      A_							:     int    )    ->       int:
         __snake_case				=							{f.name for f in dataclasses.fields(cls    )}
         return cls(**{k: v for k, v in dic.items() if k in field_names}    )







    def  lowercase					(		self							:     str    )    ->       str:
         return self.version_str






def    SCREAMING_SNAKE_CASE       (     snake_case):
     __snake_case				=							_VERSION_REG.match(snake_case)
     if not res:
          raise ValueError(f"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits.")
     return tuple(int(snake_case) for v in [res.group('''major'''), res.group('''minor'''), res.group('''patch''')])





def    SCREAMING_SNAKE_CASE       (     snake_case):
     return ".".join(str(snake_case) for v in version_tuple)
"""simple docstring"""



import re





def    SCREAMING_SNAKE_CASE       (     snake_case):
     __snake_case				=							re.compile(R'''^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$''')
     if match := re.search(snake_case,      snake_case):
          return match.string == phone
     return False


if __name__ == "__main__":
       print(indian_phone_validator("+918827897895"))