


'''simple docstring'''



import numpy as np



class 			a       :


     """simple docstring"""






     def __init__(       self  :	List[str]							,				snake_case  :	Dict=None							,				snake_case  :	str=None							,				snake_case  :	str=None							,				snake_case  :	List[str]=None							,				snake_case  :	Optional[Any]=None    )		->							Union[str, Any]:
          self.set_matricies(red=__UpperCamelCase							,				green=__UpperCamelCase							,				blue=__UpperCamelCase							,				red_edge=__UpperCamelCase							,				nir=__UpperCamelCase    )

     def 				lowerCamelCase__				(       self  :	str							,				snake_case  :	Dict=None							,				snake_case  :	List[Any]=None							,				snake_case  :	List[Any]=None							,				snake_case  :	str=None							,				snake_case  :	int=None    )		->							Any:






          if red is not None:
               __UpperCAmelCase			:				Optional[int]													=    red
          if green is not None:
               __UpperCAmelCase			:				Optional[Any]													=    green
          if blue is not None:
               __UpperCAmelCase			:				Union[str, Any]													=    blue
          if red_edge is not None:
               __UpperCAmelCase			:				str													=    red_edge
          if nir is not None:
               __UpperCAmelCase			:				int													=    nir
          return True

     def 				lowerCamelCase__				(       self  :	Tuple							,				snake_case  :	List[str]=""							,				snake_case  :	Union[str, Any]=None							,				snake_case  :	List[Any]=None							,				snake_case  :	Optional[int]=None							,				snake_case  :	Optional[int]=None							,				snake_case  :	Dict=None    )		->							Optional[Any]:
          self.set_matricies(red=__UpperCamelCase							,				green=__UpperCamelCase							,				blue=__UpperCamelCase							,				red_edge=__UpperCamelCase							,				nir=__UpperCamelCase    )
          __UpperCAmelCase			:				List[Any]													=    {
              '''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 				lowerCamelCase__				(       self  :	Any    )		->							Union[str, Any]:
          return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Optional[int]:
          return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
              (self.nir - self.red) / (self.nir + self.red)
          )

     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Dict:
          return self.nir * (self.red / (self.green**2))

     def 				lowerCamelCase__				(       self  :	int    )		->							str:
          return (2 * self.green - self.red - self.blue) / (
              2 * self.green + self.red + self.blue
          )

     def 				lowerCamelCase__				(       self  :	Dict    )		->							str:
          return (self.nir - self.red) / (self.nir + self.red)

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							str:
          return (self.nir - self.blue) / (self.nir + self.blue)

     def 				lowerCamelCase__				(       self  :	Dict    )		->							Any:
          return (self.redEdge - self.red) / (self.redEdge + self.red)

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Any:
          return (self.nir - self.green) / (self.nir + self.green)

     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Any:
          return (self.nir - (self.green + self.blue)) / (
              self.nir + (self.green + self.blue)
          )

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Any:
          return (self.nir - (self.green + self.red)) / (
              self.nir + (self.green + self.red)
          )

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Tuple:
          return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))

     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Any:
          return (self.nir - (self.green + self.red + self.blue)) / (
              self.nir + (self.green + self.red + self.blue)
          )

     def 				lowerCamelCase__				(       self  :	Optional[Any]							,				snake_case  :	List[str]=0.08							,				snake_case  :	Any=1.22							,				snake_case  :	Optional[int]=0.03    )		->							str:
          return a * (
              (self.nir - a * self.red - b)
              / (a * self.nir + self.red - a * b + x * (1 + a**2))
          )

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Dict:
          return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							List[str]:
          return (self.nir / self.green) - 1

     def 				lowerCamelCase__				(       self  :	Any    )		->							Dict:
          return (self.nir / self.redEdge) - 1

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Tuple:
          return (self.red - self.blue) / self.red

     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Optional[int]:
          __UpperCAmelCase			:				Tuple													=    self.ndvi()
          return ((ndvi + 0.5) / (abs(ndvi + 0.5    ))) * (abs(ndvi + 0.5    ) ** (1 / 2))

     def 				lowerCamelCase__				(       self  :	Dict    )		->							List[Any]:
          return self.nir - self.green

     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Union[str, Any]:
          return 2.5 * (
              (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
          )

     def 				lowerCamelCase__				(       self  :	int    )		->							Dict:
          __UpperCAmelCase			:				Optional[int]													=    (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 				lowerCamelCase__				(       self  :	Dict							,				snake_case  :	Union[str, Any]=0.16    )		->							Optional[int]:
          return (self.nir - self.green) / (self.nir + self.green + y)

     def 				lowerCamelCase__				(       self  :	Optional[Any]							,				snake_case  :	Optional[int]=0.5    )		->							Any:
          return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Union[str, Any]:
          return np.arctan(
              ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue)    )

     def 				lowerCamelCase__				(       self  :	Dict							,				snake_case  :	int=None							,				snake_case  :	Dict=None    )		->							int:
          return (self.nir - b) / (a * self.red)

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Tuple:
          return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							Dict:
          return (self.red + self.green + self.blue) / 30.5

     def 				lowerCamelCase__				(       self  :	int    )		->							int:
          return self.nir / self.red

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							str:
          return (self.rvi() - 1) / (self.rvi() + 1)

     def 				lowerCamelCase__				(       self  :	Dict    )		->							int:
          return (
              (2 * self.nir + 1)
              - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
          ) / 2

     def 				lowerCamelCase__				(       self  :	str    )		->							Optional[int]:
          return self.green / (self.nir + self.red + self.green)

     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Optional[int]:
          return self.nir / (self.nir + self.red + self.green)

     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							Optional[int]:
          return self.red / (self.nir + self.red + self.green)

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Any:
          return (self.green - self.red) / (self.green + self.red)

     def 				lowerCamelCase__				(       self  :	str    )		->							str:
          return (self.red - self.green) / (self.red + self.green)

     def 				lowerCamelCase__				(       self  :	int    )		->							List[str]:
          __UpperCAmelCase			:				Union[str, Any]													=    np.max([np.max(self.red    ), np.max(self.green    ), np.max(self.blue    )]    )
          __UpperCAmelCase			:				List[Any]													=    np.min([np.min(self.red    ), np.min(self.green    ), np.min(self.blue    )]    )
          return (max_value - min_value) / max_value

     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Dict:
          return (2 * self.red - self.green - self.blue) / (self.green - self.blue)

     def 				lowerCamelCase__				(       self  :	Dict    )		->							str:
          return self.nir / self.red

     def 				lowerCamelCase__				(       self  :	Dict    )		->							int:
          return (self.ndvi() + 0.5) ** (1 / 2)






     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Any:
          return (self.nir - self.redEdge) / (self.nir + self.redEdge)



'''simple docstring'''



def 			_a			(		_lowercase      :			int = 4000000						):





     '''simple docstring'''






     __UpperCAmelCase			:				Tuple													=    []
     __UpperCAmelCase							,     __UpperCAmelCase			:				int													=    0, 1
     while b <= n:
          if b % 2 == 0:
               even_fibs.append(_lowercase						)
          __UpperCAmelCase							,     __UpperCAmelCase			:				Dict													=    b, a + b
     return sum(_lowercase						)


if __name__ == "__main__":
      print(f"""{solution() = }""")