
"""simple docstring"""





from functools import lru_cache



def 		_lowerCAmelCase							(							UpperCamelCase_							):
		__SCREAMING_SNAKE_CASE				=					2
		__SCREAMING_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 		_lowerCAmelCase							(							UpperCamelCase_							):
		return len(unique_prime_factors(UpperCamelCase_							)							)



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



def 		_lowerCAmelCase							(							UpperCamelCase_							):
		__SCREAMING_SNAKE_CASE				=					2

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

				# Run elements through out unique_prime_factors function
				# Append our target number to the end.
				__SCREAMING_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 		_lowerCAmelCase							(							UpperCamelCase_ = 4							):
		__SCREAMING_SNAKE_CASE				=					run(UpperCamelCase_							)
		return results[0] if len(UpperCamelCase_							) else None


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












"""simple docstring"""
class _lowerCAmelCase						:







						def __init__(    self   ,				lowerCAmelCase_							)		->							None:
										_SCREAMING_SNAKE_CASE   :		Dict       		=    size
										_SCREAMING_SNAKE_CASE   :		str       		=    [0] * size
										_SCREAMING_SNAKE_CASE   :		Any       		=    [0] * size







						@staticmethod
						def 			A      (    lowerCAmelCase_							)		->							int:
										return index | (index + 1)







						@staticmethod
						def 			A      (    lowerCAmelCase_							)		->							int:
										return (index & (index + 1)) - 1







						def 			A      (    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							None:
										_SCREAMING_SNAKE_CASE   :		str       		=    value
										while index < self.size:
														_SCREAMING_SNAKE_CASE   :		List[str]       		=    self.get_prev(lowerCAmelCase_							) + 1
														if current_left_border == index:
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    value
														else:
																		_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    max(lowerCAmelCase_   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)
														_SCREAMING_SNAKE_CASE   :		str       		=    self.get_next(lowerCAmelCase_							)







						def 			A      (    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							int:
										right -= 1  # Because of right is exclusive
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    0
										while left <= right:
														_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    self.get_prev(lowerCAmelCase_							)
														if left <= current_left:
																		_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    max(lowerCAmelCase_   ,				self.tree[right]							)
																		_SCREAMING_SNAKE_CASE   :		List[Any]       		=    current_left
														else:
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    max(lowerCAmelCase_   ,				self.arr[right]							)
																		right -= 1
										return result


if __name__ == "__main__":
			import doctest

			doctest.testmod()

