






'''simple docstring'''





_UpperCamelCase						:						List[str]  =					tuple[float, float, float]
_UpperCamelCase						:						str  =					tuple[float, float, float]
def __UpperCAmelCase   (					A					:			Tuple			,       A					:			List[str]		)    ->   List[str]:
			UpperCAmelCase_      :       Optional[Any]          =       end_pointa[0] - end_pointa[0]
			UpperCAmelCase_      :       Optional[int]          =       end_pointa[1] - end_pointa[1]
			UpperCAmelCase_      :       Union[str, Any]          =       end_pointa[2] - end_pointa[2]
			return (x, y, z)
def __UpperCAmelCase   (					A					:			Union[str, Any]			,       A					:			str		)    ->   List[Any]:
			UpperCAmelCase_      :       str          =       ab[1] * ac[2] - ab[2] * ac[1]  # *i
			UpperCAmelCase_      :       Optional[Any]          =       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
			UpperCAmelCase_      :       Dict          =       ab[0] * ac[1] - ab[1] * ac[0]  # *k
			return (x, y, z)
def __UpperCAmelCase   (					A					:			Union[str, Any]			,       A					:			Union[str, Any]		)    ->   str:
			return tuple(round(UpperCamelCase_			,       UpperCamelCase_		) for x in vector		) == (0, 0, 0)







def __UpperCAmelCase   (					A					:			Dict			,       A					:			int			,       A					:			int			,       A					:			Any = 1_0		)    ->   Tuple:
			UpperCAmelCase_      :       List[str]          =       create_vector(UpperCamelCase_			,       UpperCamelCase_		)
			UpperCAmelCase_      :       Union[str, Any]          =       create_vector(UpperCamelCase_			,       UpperCamelCase_		)
			return is_zero_vector(get_ad_vectors_cross(UpperCamelCase_			,       UpperCamelCase_		)			,       UpperCamelCase_		)






from functools import lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2
     snake_case											=							set()
     while i * i <= n:
          if n % i:
               i += 1
          else:
               n //= i
               factors.add(UpperCamelCase_							)
     if n > 1:
          factors.add(UpperCamelCase_							)
     return factors
@lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(unique_prime_factors(UpperCamelCase_							)							)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(set(UpperCamelCase_							)							) in (0, 1)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2

     while True:
          # Increment each value of a generated range
          snake_case											=							[base + i for i in range(UpperCamelCase_							)]

          # Run elements through out unique_prime_factors function
          # Append our target number to the end.
          snake_case											=							[upf_len(UpperCamelCase_							) for x in group]
          checker.append(UpperCamelCase_							)

          # If all numbers in the list are equal, return the group variable.
          if equality(UpperCamelCase_							):
               return group

          # Increment our base variable by 1
          base += 1
def      UpperCAmelCase__		(UpperCamelCase_ = 4							):



     """simple docstring"""






     snake_case											=							run(UpperCamelCase_							)
     return results[0] if len(UpperCamelCase_							) else None


if __name__ == "__main__":
 print(solution())




