





'''simple docstring'''

from string import ascii_uppercase




def  _a     (				lowerCAmelCase_      ,   lowerCAmelCase_      ,   lowerCAmelCase_ = False      ,   lowerCAmelCase_ = ascii_uppercase						):





      """simple docstring"""



      _snake_case		:						List[str]         =  keyword.upper()
      _snake_case		:						Any         =  plaintext.upper()
      _snake_case		:						Optional[int]         =  set(lowerCAmelCase_						)

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

      # create a shifted version of the alphabet
      _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
      _snake_case		:						Dict         =  [
          shifted_alphabet[k : k + num_unique_chars_in_keyword]
          for k in range(0      ,   26      ,   lowerCAmelCase_						)
      ]

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

                  # map current letter to letter in modified alphabet
                  _snake_case		:						Union[str, Any]         =  row[column]
                  letter_index += 1

      if verbose:
            print(lowerCAmelCase_						)
      # 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'''

import math




def  _a     (				lowerCAmelCase_						):





      """simple docstring"""



      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5      ,   int(math.sqrt(lowerCAmelCase_						) + 1						)      ,   6						):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True




def  _a     (				lowerCAmelCase_ = 2_000_000						):





      """simple docstring"""



      return sum(num for num in range(3      ,   lowerCAmelCase_      ,   2						) if is_prime(lowerCAmelCase_						)						) + 2 if n > 2 else 0


if __name__ == "__main__":
   print(F"""{solution() = }""")


