





from functools import lru_cache







def        __lowerCamelCase (							__a       :int   )		->    set:






		"""simple docstring"""

		A__  				=       2
		A__  				=       set()
		while i * i <= n:
				if n % i:
						i += 1
				else:
						n //= i
						factors.add(__lowerCAmelCase   )
		if n > 1:
				factors.add(__lowerCAmelCase   )
		return factors







@lru_cache
def        __lowerCamelCase (							__a       :Optional[int]   )		->    int:






		"""simple docstring"""

		return len(unique_prime_factors(__lowerCAmelCase   )   )







def        __lowerCamelCase (							__a       :Optional[Any]   )		->    bool:






		"""simple docstring"""

		return len(set(__lowerCAmelCase   )   ) in (0, 1)







def        __lowerCamelCase (							__a       :Optional[int]   )		->    list:






		"""simple docstring"""

		A__  				=       2

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

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

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

				# Increment our base variable by 1
				base += 1







def        __lowerCamelCase (							__a       :List[str] = 4   )		->    int:






		"""simple docstring"""

		A__  				=       run(__lowerCAmelCase   )
		return results[0] if len(__lowerCAmelCase   ) else None


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










import math







def        __lowerCamelCase (							)		->    None:






		"""simple docstring"""

		A__  				=       input("""Enter message: """   )
		A__  				=       int(input(F'Enter key [2-{len(__a   ) - 1}]: '   )   )
		A__  				=       input("""Encryption/Decryption [e/d]: """   )

		if mode.lower().startswith("""e"""   ):
				A__  				=       encrypt_message(__a   ,					__a   )
		elif mode.lower().startswith("""d"""   ):
				A__  				=       decrypt_message(__a   ,					__a   )

		# Append pipe symbol (vertical bar) to identify spaces at the end.
		print(F'Output:\n{text + "|"}'   )







def        __lowerCamelCase (							__a       :int   ,					__a       :str   )		->    str:






		"""simple docstring"""

		A__  				=       [""""""] * key
		for col in range(__a   ):
				A__  				=       col
				while pointer < len(__a   ):
						cipher_text[col] += message[pointer]
						pointer += key
		return "".join(__a   )







def        __lowerCamelCase (							__a       :int   ,					__a       :str   )		->    str:






		"""simple docstring"""

		A__  				=       math.ceil(len(__a   ) / key   )
		A__  				=       key
		A__  				=       (num_cols * num_rows) - len(__a   )
		A__  				=       [""""""] * num_cols
		A__  				=       0
		A__  				=       0

		for symbol in message:
				plain_text[col] += symbol
				col += 1

				if (
				    (col == num_cols)
				    or (col == num_cols - 1)
				    and (row >= num_rows - num_shaded_boxes)
				):
						A__  				=       0
						row += 1

		return "".join(__a   )


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()



