





"""simple docstring"""
from string import ascii_uppercase



def   __lowerCamelCase     (							a_  :	str				,     a_  :	str				,     a_  :	bool = False				,     a_  :	str = ascii_uppercase							)    ->   str:
						__SCREAMING_SNAKE_CASE     :List[Any]	       =						keyword.upper()
						__SCREAMING_SNAKE_CASE     :List[str]	       =						plaintext.upper()
						__SCREAMING_SNAKE_CASE     :str	       =						set(a_							)

						# create a list of unique characters in the keyword - their order matters
						# it determines how we will map plaintext characters to the ciphertext
						__SCREAMING_SNAKE_CASE     :List[Any]	       =						[]
						for char in keyword:
												if char in alphabet_set and char not in unique_chars:
																		unique_chars.append(a_							)
    # the number of those unique characters will determine the number of rows
						__SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						len(a_							)

						# create a shifted version of the alphabet
						__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						unique_chars + [
						    char for char in alphabet if char not in unique_chars
						]

						# create a modified alphabet by splitting the shifted alphabet into rows
						__SCREAMING_SNAKE_CASE     :Dict	       =						[
						    shifted_alphabet[k : k + num_unique_chars_in_keyword]
						    for k in range(0				,     26				,     a_							)
						]

						# map the alphabet characters to the modified alphabet characters
						# going 'vertically' through the modified alphabet - consider columns first
						__SCREAMING_SNAKE_CASE     :int	       =						{}
						__SCREAMING_SNAKE_CASE     :Any	       =						0
						for column in range(a_							):
												for row in modified_alphabet:
																		# if current row (the last one) is too short, break out of loop
																		if len(a_							) <= column:
																								break

																		# map current letter to letter in modified alphabet
																		__SCREAMING_SNAKE_CASE     :int	       =						row[column]
																		letter_index += 1

						if verbose:
												print(a_							)
						# create the encrypted text by mapping the plaintext to the modified alphabet
						return "".join(mapping[char] if char in mapping else char for char in plaintext							)


if __name__ == "__main__":
		# example use
		print(mixed_keyword("college", "UNIVERSITY"))






"""simple docstring"""
def   __lowerCamelCase     (							a_  :	int = 10**6							)    ->   int:

      if n <= 0:
            raise ValueError('''Please enter an integer greater than 0'''							)

      __SCREAMING_SNAKE_CASE     :Tuple	       =						list(range(n + 1							)							)
      for number in range(2				,     n + 1							):
            if phi[number] == number:
                  phi[number] -= 1
                  for multiple in range(number * 2				,     n + 1				,     a_							):
                        __SCREAMING_SNAKE_CASE     :List[Any]	       =						(phi[multiple] // number) * (number - 1)

      __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						1
      for number in range(1				,     n + 1							):
            if (answer / phi[answer]) < (number / phi[number]):
                  __SCREAMING_SNAKE_CASE     :str	       =						number

      return answer


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