


from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

SCREAMING_SNAKE_CASE__     					=			TypeVar("T")



class 						_UpperCAmelCase      (     Generic[T]							):






		def __init__(						self				:     Optional[int]   ,  UpperCAmelCase				:     T):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						data
				SCREAMING_SNAKE_CASE_				:Node[T] | None				     =						None







		def __str__(						self				:     int):
				return F"{self.data}"




class 						_UpperCAmelCase      (     Generic[T]							):






		def __init__(						self				:     List[Any]):
				SCREAMING_SNAKE_CASE_				:Node[T] | None				     =						None






		def __iter__(						self				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:str				     =						self.top
				while node:
						yield node.data
						SCREAMING_SNAKE_CASE_				:Tuple				     =						node.next






		def __str__(						self				:     Dict):
				return "->".join([str(UpperCAmelCase) for item in self])






		def __len__(						self				:     str):
				return len(tuple(iter(self)))






		def _snake_case		(						self				:     int):
				return self.top is None






		def _snake_case		(						self				:     Any   ,  UpperCAmelCase				:     T):
				SCREAMING_SNAKE_CASE_				:Tuple				     =						Node(UpperCAmelCase)
				if not self.is_empty():
						SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.top
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						node






		def _snake_case		(						self				:     int):
				if self.is_empty():
						raise IndexError("pop from empty stack")
				assert isinstance(self.top   ,  UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:Tuple				     =						self.top
				SCREAMING_SNAKE_CASE_				:int				     =						self.top.next
				return pop_node.data






		def _snake_case		(						self				:     Union[str, Any]):
				if self.is_empty():
						raise IndexError("peek from empty stack")

				assert self.top is not None
				return self.top.data







		def _snake_case		(						self				:     int):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						None


if __name__ == "__main__":
		from doctest import testmod

		testmod()










from __future__ import annotations

import math


def     lowercase	(    a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:List[Any]				     =						u
		for i in range(1     , a ):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						temp * (u - i)
		return temp


def     lowercase	(    ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						int(input("enter the numbers of values: " ) )
		SCREAMING_SNAKE_CASE_				:list[list[float]]				     =						[]
		for _ in range(a ):
				y.append([] )
		for i in range(a ):
				for j in range(a ):
						y[i].append(a )
						SCREAMING_SNAKE_CASE_				:Any				     =						0

		print("enter the values of parameters in a list: " )
		SCREAMING_SNAKE_CASE_				:Dict				     =						list(map(a     , input().split() ) )

		print("enter the values of corresponding parameters: " )
		for i in range(a ):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						float(input() )

		SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						int(input("enter the value to interpolate: " ) )
		SCREAMING_SNAKE_CASE_				:str				     =						(value - x[0]) / (x[1] - x[0])

		# for calculating forward difference table

		for i in range(1     , a ):
				for j in range(n - i ):
						SCREAMING_SNAKE_CASE_				:List[str]				     =						y[j + 1][i - 1] - y[j][i - 1]

		SCREAMING_SNAKE_CASE_				:Tuple				     =						y[0][0]
		for i in range(1     , a ):
				summ += (ucal(a     , a ) * y[0][i]) / math.factorial(a )

		print(F"the value at {value} is {summ}" )


if __name__ == "__main__":
		main()






