




'''simple docstring'''

from __future__ import annotations

from collections.abc import MutableSequence






class 						a				:


				def __init__(		self    :					Union[str, Any]       ,				lowercase_    :					int       ,				lowercase_    :					MutableSequence[float]					):
									if len(lowercase_					) != degree + 1:
														raise ValueError(
														    '''The number of coefficients should be equal to the degree + 1.'''					)

									snake_case_									=				list(lowercase_					)
									snake_case_									=				degree


				def __add__(		self    :					int       ,				lowercase_    :					Polynomial					):

									if self.degree > polynomial_a.degree:
														snake_case_									=				self.coefficients[:]
														for i in range(polynomial_a.degree + 1					):
																			coefficients[i] += polynomial_a.coefficients[i]
														return Polynomial(self.degree       ,				lowercase_					)
									else:
														snake_case_									=				polynomial_a.coefficients[:]
														for i in range(self.degree + 1					):
																			coefficients[i] += self.coefficients[i]
														return Polynomial(polynomial_a.degree       ,				lowercase_					)


				def __sub__(		self    :					str       ,				lowercase_    :					Polynomial					):
									return self + polynomial_a * Polynomial(0       ,				[-1]					)


				def __neg__(		self    :					Dict					):
									return Polynomial(self.degree       ,				[-c for c in self.coefficients]					)


				def __mul__(		self    :					Optional[Any]       ,				lowercase_    :					Polynomial					):
									snake_case_									=				[0] * (self.degree + polynomial_a.degree + 1)
									for i in range(self.degree + 1					):
														for j in range(polynomial_a.degree + 1					):
																			coefficients[i + j] += (
																			    self.coefficients[i] * polynomial_a.coefficients[j]
																			)

									return Polynomial(self.degree + polynomial_a.degree       ,				lowercase_					)


				def   A_ (		self    :					List[str]       ,				lowercase_    :					int | float					):
									snake_case_									=				0
									for i in range(self.degree + 1					):
														result += self.coefficients[i] * (substitution**i)
									return result


				def __str__(		self    :					Optional[int]					):
									snake_case_									=				''''''
									for i in range(self.degree       ,				-1       ,				-1					):
														if self.coefficients[i] == 0:
																			continue
														elif self.coefficients[i] > 0:
																			if polynomial:
																								polynomial += " + "
														else:
																			polynomial += " - "

														if i == 0:
																			polynomial += str(abs(self.coefficients[i]					)					)
														elif i == 1:
																			polynomial += str(abs(self.coefficients[i]					)					) + "x"
														else:
																			polynomial += str(abs(self.coefficients[i]					)					) + "x^" + str(lowercase_					)

									return polynomial


				def __repr__(		self    :					Tuple					):
									return self.__str__()


				def   A_ (		self    :					int					):
									snake_case_									=				[0] * self.degree
									for i in range(self.degree					):
														snake_case_									=				self.coefficients[i + 1] * (i + 1)
									return Polynomial(self.degree - 1       ,				lowercase_					)


				def   A_ (		self    :					List[str]       ,				lowercase_    :					int | float = 0					):
									snake_case_									=				[0] * (self.degree + 2)
									snake_case_									=				constant
									for i in range(self.degree + 1					):
														snake_case_									=				self.coefficients[i] / (i + 1)
									return Polynomial(self.degree + 1       ,				lowercase_					)


				def __eq__(		self    :					Union[str, Any]       ,				lowercase_    :					object					):
									if not isinstance(lowercase_       ,				lowercase_					):
														return False

									if self.degree != polynomial_a.degree:
														return False

									for i in range(self.degree + 1					):
														if self.coefficients[i] != polynomial_a.coefficients[i]:
																			return False

									return True


				def __ne__(		self    :					Optional[Any]       ,				lowercase_    :					object					):
									return not self.__eq__(lowercase_					)







'''simple docstring'''

import re


def 		__magic_name__    (	__UpperCAmelCase	)		->					bool:

					'''simple docstring'''

					snake_case_									=				re.compile(
					    r'''^(?:0|94|\+94|0{2}94)''' r'''7(0|1|2|4|5|6|7|8)''' r'''(-| |)''' r'''\d{7}$'''	)

					return bool(re.search(__UpperCAmelCase,      __UpperCAmelCase	)	)


if __name__ == "__main__":
							a  :				Any									=  '0094702343221'

							print(is_sri_lankan_phone_number(phone))

