


'''simple docstring'''






# Imports
import numpy as np




class 						a__							:





							'''simple docstring'''






							def __init__(						self   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None  )			->				List[Any]:
														self.set_matricies(red=lowerCamelCase_   ,       green=lowerCamelCase_   ,       blue=lowerCamelCase_   ,       red_edge=lowerCamelCase_   ,       nir=lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None  )			->				List[str]:
														if red is not None:
																					lowerCAmelCase__			  =      red
														if green is not None:
																					lowerCAmelCase__			  =      green
														if blue is not None:
																					lowerCAmelCase__			  =      blue
														if red_edge is not None:
																					lowerCAmelCase__			  =      red_edge
														if nir is not None:
																					lowerCAmelCase__			  =      nir
														return True







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=""   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None  )			->				Optional[Any]:
														self.set_matricies(red=lowerCamelCase_   ,       green=lowerCamelCase_   ,       blue=lowerCamelCase_   ,       red_edge=lowerCamelCase_   ,       nir=lowerCamelCase_  )
														lowerCAmelCase__			  =      {
														    '''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     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
														    (self.nir - self.red) / (self.nir + self.red)
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return self.nir * (self.red / (self.green**2))







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														return (2 * self.green - self.red - self.blue) / (
														    2 * self.green + self.red + self.blue
														)







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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														return (self.nir - self.blue) / (self.nir + self.blue)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														return (self.redEdge - self.red) / (self.redEdge + self.red)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														return (self.nir - self.green) / (self.nir + self.green)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														return (self.nir - (self.green + self.blue)) / (
														    self.nir + (self.green + self.blue)
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														return (self.nir - (self.green + self.red)) / (
														    self.nir + (self.green + self.red)
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))







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







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=0.08   ,       lowerCamelCase_=1.22   ,       lowerCamelCase_=0.03  )			->				int:
														return a * (
														    (self.nir - a * self.red - b)
														    / (a * self.nir + self.red - a * b + x * (1 + a**2))
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														return (self.nir / self.green) - 1







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														return (self.nir / self.redEdge) - 1







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														return (self.red - self.blue) / self.red







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      self.ndvi()
														return ((ndvi + 0.5) / (abs(ndvi + 0.5  ))) * (abs(ndvi + 0.5  ) ** (1 / 2))







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														return self.nir - self.green







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														return 2.5 * (
														    (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      (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     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=0.16  )			->				Optional[Any]:
														return (self.nir - self.green) / (self.nir + self.green + y)







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=0.5  )			->				Union[str, Any]:
														return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)







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







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_=None   ,       lowerCamelCase_=None  )			->				Any:
														return (self.nir - b) / (a * self.red)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return (self.red + self.green + self.blue) / 30.5







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														return self.nir / self.red







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														return (self.rvi() - 1) / (self.rvi() + 1)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														return (
														    (2 * self.nir + 1)
														    - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
														) / 2







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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return self.nir / (self.nir + self.red + self.green)







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







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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														return (self.red - self.green) / (self.red + self.green)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__			  =      np.max([np.max(self.red  ), np.max(self.green  ), np.max(self.blue  )]  )
														lowerCAmelCase__			  =      np.min([np.min(self.red  ), np.min(self.green  ), np.min(self.blue  )]  )
														return (max_value - min_value) / max_value







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														return (2 * self.red - self.green - self.blue) / (self.green - self.blue)







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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														return (self.ndvi() + 0.5) ** (1 / 2)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														return (self.nir - self.redEdge) / (self.nir + self.redEdge)






'''simple docstring'''




import random



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			num - 1
		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			0

		while s % 2 == 0:
				SCREAMING_SNAKE_CASE :				List[str]		=			s // 2
				t += 1

		for _ in range(5	):
				SCREAMING_SNAKE_CASE :				List[Any]		=			random.randrange(2			,			num - 1	)
				SCREAMING_SNAKE_CASE :				List[Any]		=			pow(lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	)
				if v != 1:
						SCREAMING_SNAKE_CASE :				Tuple		=			0
						while v != (num - 1):
								if i == t - 1:
										return False
								else:
										SCREAMING_SNAKE_CASE :				Any		=			i + 1
										SCREAMING_SNAKE_CASE :				str		=			(v**2) % num
		return True



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		if num < 2:
				return False

		SCREAMING_SNAKE_CASE :				List[str]		=			[
		    2,
		    3,
		    5,
		    7,
		    11,
		    13,
		    17,
		    19,
		    23,
		    29,
		    31,
		    37,
		    41,
		    43,
		    47,
		    53,
		    59,
		    61,
		    67,
		    71,
		    73,
		    79,
		    83,
		    89,
		    97,
		    1_01,
		    1_03,
		    1_07,
		    1_09,
		    1_13,
		    1_27,
		    1_31,
		    1_37,
		    1_39,
		    1_49,
		    1_51,
		    1_57,
		    1_63,
		    1_67,
		    1_73,
		    1_79,
		    1_81,
		    1_91,
		    1_93,
		    1_97,
		    1_99,
		    2_11,
		    2_23,
		    2_27,
		    2_29,
		    2_33,
		    2_39,
		    2_41,
		    2_51,
		    2_57,
		    2_63,
		    2_69,
		    2_71,
		    2_77,
		    2_81,
		    2_83,
		    2_93,
		    3_07,
		    3_11,
		    3_13,
		    3_17,
		    3_31,
		    3_37,
		    3_47,
		    3_49,
		    3_53,
		    3_59,
		    3_67,
		    3_73,
		    3_79,
		    3_83,
		    3_89,
		    3_97,
		    4_01,
		    4_09,
		    4_19,
		    4_21,
		    4_31,
		    4_33,
		    4_39,
		    4_43,
		    4_49,
		    4_57,
		    4_61,
		    4_63,
		    4_67,
		    4_79,
		    4_87,
		    4_91,
		    4_99,
		    5_03,
		    5_09,
		    5_21,
		    5_23,
		    5_41,
		    5_47,
		    5_57,
		    5_63,
		    5_69,
		    5_71,
		    5_77,
		    5_87,
		    5_93,
		    5_99,
		    6_01,
		    6_07,
		    6_13,
		    6_17,
		    6_19,
		    6_31,
		    6_41,
		    6_43,
		    6_47,
		    6_53,
		    6_59,
		    6_61,
		    6_73,
		    6_77,
		    6_83,
		    6_91,
		    7_01,
		    7_09,
		    7_19,
		    7_27,
		    7_33,
		    7_39,
		    7_43,
		    7_51,
		    7_57,
		    7_61,
		    7_69,
		    7_73,
		    7_87,
		    7_97,
		    8_09,
		    8_11,
		    8_21,
		    8_23,
		    8_27,
		    8_29,
		    8_39,
		    8_53,
		    8_57,
		    8_59,
		    8_63,
		    8_77,
		    8_81,
		    8_83,
		    8_87,
		    9_07,
		    9_11,
		    9_19,
		    9_29,
		    9_37,
		    9_41,
		    9_47,
		    9_53,
		    9_67,
		    9_71,
		    9_77,
		    9_83,
		    9_91,
		    9_97,
		]

		if num in low_primes:
				return True

		for prime in low_primes:
				if (num % prime) == 0:
						return False

		return rabin_miller(lowerCamelCase_	)



def 		__A		(  lowerCamelCase_ = 10_24	):


		"""simple docstring"""



		while True:
				SCREAMING_SNAKE_CASE :				Optional[Any]		=			random.randrange(2 ** (keysize - 1)			,			2 ** (keysize)	)
				if is_prime_low_num(lowerCamelCase_	):
						return num


if __name__ == "__main__":
							__UpperCAmelCase            =       generate_large_prime()
							print(("""Prime number:""", num))
							print(("""is_prime_low_num:""", is_prime_low_num(num)))



