




'''simple docstring'''

# Imports
import numpy as np



class 		SCREAMING_SNAKE_CASE__  :





			def __init__(      self						:    List[str]      ,		a_						:    str=None      ,		a_						:    Tuple=None      ,		a_						:    Optional[Any]=None      ,		a_						:    Union[str, Any]=None      ,		a_						:    List[Any]=None							):



						"""simple docstring"""




						self.set_matricies(red=a_      ,		green=a_      ,		blue=a_      ,		red_edge=a_      ,		nir=a_							)





			def 							A (      self						:    List[Any]      ,		a_						:    List[str]=None      ,		a_						:    Optional[Any]=None      ,		a_						:    Tuple=None      ,		a_						:    Any=None      ,		a_						:    List[Any]=None							):



						"""simple docstring"""




						if red is not None:
									__snake_case			=		red
						if green is not None:
									__snake_case			=		green
						if blue is not None:
									__snake_case			=		blue
						if red_edge is not None:
									__snake_case			=		red_edge
						if nir is not None:
									__snake_case			=		nir
						return True





			def 							A (      self						:    int      ,		a_						:    List[str]=""      ,		a_						:    List[Any]=None      ,		a_						:    Union[str, Any]=None      ,		a_						:    int=None      ,		a_						:    int=None      ,		a_						:    int=None							):



						"""simple docstring"""




						self.set_matricies(red=a_      ,		green=a_      ,		blue=a_      ,		red_edge=a_      ,		nir=a_							)
						__snake_case			=		{
						    "ARVI2": self.arvaa,
						    "CCCI": self.ccci,
						    "CVI": self.cvi,
						    "GLI": self.gli,
						    "NDVI": self.ndvi,
						    "BNDVI": self.bndvi,
						    "redEdgeNDVI": self.red_edge_ndvi,
						    "GNDVI": self.gndvi,
						    "GBNDVI": self.gbndvi,
						    "GRNDVI": self.grndvi,
						    "RBNDVI": self.rbndvi,
						    "PNDVI": self.pndvi,
						    "ATSAVI": self.atsavi,
						    "BWDRVI": self.bwdrvi,
						    "CIgreen": self.ci_green,
						    "CIrededge": self.ci_rededge,
						    "CI": self.ci,
						    "CTVI": self.ctvi,
						    "GDVI": self.gdvi,
						    "EVI": self.evi,
						    "GEMI": self.gemi,
						    "GOSAVI": self.gosavi,
						    "GSAVI": self.gsavi,
						    "Hue": self.hue,
						    "IVI": self.ivi,
						    "IPVI": self.ipvi,
						    "I": self.i,
						    "RVI": self.rvi,
						    "MRVI": self.mrvi,
						    "MSAVI": self.m_savi,
						    "NormG": self.norm_g,
						    "NormNIR": self.norm_nir,
						    "NormR": self.norm_r,
						    "NGRDI": self.ngrdi,
						    "RI": self.ri,
						    "S": self.s,
						    "IF": self._if,
						    "DVI": self.dvi,
						    "TVI": self.tvi,
						    "NDRE": self.ndre,
						}

						try:
									return funcs[index]()
						except KeyError:
									print("Index not in the list!"							)
									return False





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
						    (self.nir - self.red) / (self.nir + self.red)
						)





			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						return self.nir * (self.red / (self.green**2))





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return (2 * self.green - self.red - self.blue) / (
						    2 * self.green + self.red + self.blue
						)





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						return (self.nir - self.red) / (self.nir + self.red)





			def 							A (      self						:    str							):



						"""simple docstring"""




						return (self.nir - self.blue) / (self.nir + self.blue)





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return (self.redEdge - self.red) / (self.redEdge + self.red)





			def 							A (      self						:    int							):



						"""simple docstring"""




						return (self.nir - self.green) / (self.nir + self.green)





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return (self.nir - (self.green + self.blue)) / (
						    self.nir + (self.green + self.blue)
						)





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return (self.nir - (self.green + self.red)) / (
						    self.nir + (self.green + self.red)
						)





			def 							A (      self						:    Any							):



						"""simple docstring"""




						return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))





			def 							A (      self						:    Any							):



						"""simple docstring"""




						return (self.nir - (self.green + self.red + self.blue)) / (
						    self.nir + (self.green + self.red + self.blue)
						)





			def 							A (      self						:    Any      ,		a_						:    Tuple=0.08      ,		a_						:    Tuple=1.22      ,		a_						:    Any=0.03							):



						"""simple docstring"""




						return a * (
						    (self.nir - a * self.red - b)
						    / (a * self.nir + self.red - a * b + x * (1 + a**2))
						)





			def 							A (      self						:    Dict							):



						"""simple docstring"""




						return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						return (self.nir / self.green) - 1





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return (self.nir / self.redEdge) - 1





			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						return (self.red - self.blue) / self.red





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						__snake_case			=		self.ndvi()
						return ((ndvi + 0.5) / (abs(ndvi + 0.5							))) * (abs(ndvi + 0.5							) ** (1 / 2))





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return self.nir - self.green





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return 2.5 * (
						    (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
						)





			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						__snake_case			=		(2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
						    self.nir + self.red + 0.5
						)
						return n * (1 - 0.25 * n) - (self.red - 0.125) / (1 - self.red)





			def 							A (      self						:    Tuple      ,		a_						:    Optional[int]=0.16							):



						"""simple docstring"""




						return (self.nir - self.green) / (self.nir + self.green + y)





			def 							A (      self						:    int      ,		a_						:    List[Any]=0.5							):



						"""simple docstring"""




						return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return np.arctan(
						    ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue)							)





			def 							A (      self						:    Union[str, Any]      ,		a_						:    Optional[int]=None      ,		a_						:    List[Any]=None							):



						"""simple docstring"""




						return (self.nir - b) / (a * self.red)





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)





			def 							A (      self						:    Dict							):



						"""simple docstring"""




						return (self.red + self.green + self.blue) / 30.5





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return self.nir / self.red





			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						return (self.rvi() - 1) / (self.rvi() + 1)





			def 							A (      self						:    Dict							):



						"""simple docstring"""




						return (
						    (2 * self.nir + 1)
						    - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
						) / 2





			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						return self.green / (self.nir + self.red + self.green)





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return self.nir / (self.nir + self.red + self.green)





			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						return self.red / (self.nir + self.red + self.green)





			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




						return (self.green - self.red) / (self.green + self.red)





			def 							A (      self						:    str							):



						"""simple docstring"""




						return (self.red - self.green) / (self.red + self.green)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						__snake_case			=		np.max([np.max(self.red							), np.max(self.green							), np.max(self.blue							)]							)
						__snake_case			=		np.min([np.min(self.red							), np.min(self.green							), np.min(self.blue							)]							)
						return (max_value - min_value) / max_value





			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						return (2 * self.red - self.green - self.blue) / (self.green - self.blue)





			def 							A (      self						:    Any							):



						"""simple docstring"""




						return self.nir / self.red





			def 							A (      self						:    Any							):



						"""simple docstring"""




						return (self.ndvi() + 0.5) ** (1 / 2)






			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						return (self.nir - self.redEdge) / (self.nir + self.redEdge)







'''simple docstring'''



import functools


def A (__lowerCamelCase :list[int]					,      __lowerCamelCase :list[int]						):

						# Validation
						if not isinstance(__lowerCamelCase					,      __lowerCamelCase						) or not all(isinstance(__lowerCamelCase					,      __lowerCamelCase						) for day in days						):
												raise ValueError("""The parameter days should be a list of integers"""						)

						if len(__lowerCamelCase						) != 3 or not all(isinstance(__lowerCamelCase					,      __lowerCamelCase						) for cost in costs						):
												raise ValueError("""The parameter costs should be a list of three integers"""						)

						if len(__lowerCamelCase						) == 0:
												return 0

						if min(__lowerCamelCase						) <= 0:
												raise ValueError("""All days elements should be greater than 0"""						)

						if max(__lowerCamelCase						) >= 366:
												raise ValueError("""All days elements should be less than 366"""						)

						_lowerCAmelCase    		=					set(__lowerCamelCase						)

						@functools.cache
						def dynamic_programming(__lowerCamelCase :int						) -> int:
												if index > 365:
																		return 0

												if index not in days_set:
																		return dynamic_programming(index + 1						)

												return min(
												    costs[0] + dynamic_programming(index + 1						)					,      costs[1] + dynamic_programming(index + 7						)					,      costs[2] + dynamic_programming(index + 30						)					,      )

						return dynamic_programming(1						)


if __name__ == "__main__":
						import doctest

						doctest.testmod()
