



'''simple docstring'''

from ..utils import DummyObject, requires_backends






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Union[str, Any]        =				["""flax"""]


							def __init__(				self   :						Any      ,						*a_   :						int      ,						**a_   :						Dict			)			->					Optional[int]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Optional[int]      ,						*a_   :						Optional[Any]      ,						**a_   :						List[str]			)			->					Optional[Any]:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Dict      ,						*a_   :						Dict      ,						**a_   :						Tuple			)			->					List[str]:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Tuple        =				["""flax"""]


							def __init__(				self   :						str      ,						*a_   :						Optional[int]      ,						**a_   :						int			)			->					Tuple:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Tuple      ,						*a_   :						str      ,						**a_   :						Tuple			)			->					Optional[Any]:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Dict      ,						*a_   :						Optional[Any]      ,						**a_   :						int			)			->					Optional[Any]:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Tuple        =				["""flax"""]


							def __init__(				self   :						List[Any]      ,						*a_   :						Tuple      ,						**a_   :						Any			)			->					int:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Union[str, Any]      ,						*a_   :						Dict      ,						**a_   :						Union[str, Any]			)			->					Union[str, Any]:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Optional[int]      ,						*a_   :						int      ,						**a_   :						str			)			->					str:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Optional[Any]        =				["""flax"""]


							def __init__(				self   :						Dict      ,						*a_   :						str      ,						**a_   :						Dict			)			->					List[str]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						str      ,						*a_   :						int      ,						**a_   :						List[Any]			)			->					str:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						List[str]      ,						*a_   :						Any      ,						**a_   :						Optional[Any]			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		List[str]        =				["""flax"""]


							def __init__(				self   :						List[Any]      ,						*a_   :						str      ,						**a_   :						Dict			)			->					str:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						int      ,						*a_   :						List[Any]      ,						**a_   :						List[str]			)			->					int:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						int      ,						*a_   :						Optional[Any]      ,						**a_   :						Any			)			->					List[Any]:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Optional[Any]        =				["""flax"""]


							def __init__(				self   :						Optional[int]      ,						*a_   :						Any      ,						**a_   :						str			)			->					Optional[Any]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						List[Any]      ,						*a_   :						Union[str, Any]      ,						**a_   :						Union[str, Any]			)			->					Any:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Tuple      ,						*a_   :						str      ,						**a_   :						int			)			->					List[Any]:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		List[Any]        =				["""flax"""]


							def __init__(				self   :						Optional[int]      ,						*a_   :						Optional[int]      ,						**a_   :						List[str]			)			->					Optional[Any]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						int      ,						*a_   :						Tuple      ,						**a_   :						Optional[int]			)			->					Dict:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						List[Any]      ,						*a_   :						Union[str, Any]      ,						**a_   :						List[Any]			)			->					Union[str, Any]:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		List[Any]        =				["""flax"""]


							def __init__(				self   :						Optional[int]      ,						*a_   :						List[str]      ,						**a_   :						List[str]			)			->					Union[str, Any]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Dict      ,						*a_   :						Optional[int]      ,						**a_   :						List[str]			)			->					Any:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Any      ,						*a_   :						Optional[Any]      ,						**a_   :						Optional[Any]			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Tuple        =				["""flax"""]


							def __init__(				self   :						Optional[Any]      ,						*a_   :						List[Any]      ,						**a_   :						Any			)			->					int:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						int      ,						*a_   :						Optional[Any]      ,						**a_   :						Optional[Any]			)			->					Union[str, Any]:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						List[Any]      ,						*a_   :						Optional[Any]      ,						**a_   :						Optional[int]			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		int        =				["""flax"""]


							def __init__(				self   :						Union[str, Any]      ,						*a_   :						str      ,						**a_   :						int			)			->					List[Any]:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						str      ,						*a_   :						str      ,						**a_   :						Union[str, Any]			)			->					int:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Dict      ,						*a_   :						str      ,						**a_   :						List[str]			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Tuple        =				["""flax"""]


							def __init__(				self   :						Optional[Any]      ,						*a_   :						Union[str, Any]      ,						**a_   :						str			)			->					Tuple:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Any      ,						*a_   :						int      ,						**a_   :						Optional[int]			)			->					Tuple:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Any      ,						*a_   :						Union[str, Any]      ,						**a_   :						Tuple			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		Tuple        =				["""flax"""]


							def __init__(				self   :						List[Any]      ,						*a_   :						List[Any]      ,						**a_   :						Optional[int]			)			->					int:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Dict      ,						*a_   :						Union[str, Any]      ,						**a_   :						Union[str, Any]			)			->					Optional[Any]:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Union[str, Any]      ,						*a_   :						Dict      ,						**a_   :						Union[str, Any]			)			->					int:
										requires_backends(cls      ,						['flax']			)






class 						a_		(     metaclass=snake_case    ):
							UpperCAmelCase			:		str        =				["""flax"""]


							def __init__(				self   :						Optional[Any]      ,						*a_   :						Optional[Any]      ,						**a_   :						Any			)			->					str:
										requires_backends(self      ,						['flax']			)


							@classmethod
							def    UpperCamelCase     (				cls   :						Optional[int]      ,						*a_   :						Tuple      ,						**a_   :						List[Any]			)			->					Tuple:
										requires_backends(cls      ,						['flax']			)




							@classmethod
							def    UpperCamelCase     (				cls   :						Union[str, Any]      ,						*a_   :						List[Any]      ,						**a_   :						List[str]			)			->					Optional[int]:
										requires_backends(cls      ,						['flax']			)









'''simple docstring'''

def a_     (    __UpperCAmelCase				,							__UpperCAmelCase				,							__UpperCAmelCase					)				->					list:





			"""simple docstring"""







			snake_case:    Optional[int]      							=len(__UpperCAmelCase					)
			snake_case:    Optional[int]      							=[[0] * n for i in range(__UpperCAmelCase					)]
			for i in range(__UpperCAmelCase					):
						snake_case:    Optional[int]      							=y_points[i]

			for i in range(2				,							__UpperCAmelCase					):
						for j in range(__UpperCAmelCase				,							__UpperCAmelCase					):
									snake_case:    List[str]      							=(
									    (xa - x_points[j - i + 1]) * q[j][i - 1]
									    - (xa - x_points[j]) * q[j - 1][i - 1]
									) / (x_points[j] - x_points[j - i + 1])

			return [q[n - 1][n - 1], q]


if __name__ == "__main__":
	import doctest

	doctest.testmod()




