code: 
  
  from __future__ import annotations
  
  from string import ascii_letters
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			str | None = None ):
      UpperCamelCase :List[str]										=     alphabet or ascii_letters
  
      # The final result string
      UpperCamelCase :List[Any]										=     ''''''
  
      for character in input_string:
          if character not in alpha:
              # Append without encryption if character is not in the alphabet
              result += character
          else:
              # Get the index of the new key and make sure it isn't too large
              UpperCamelCase :int										=     (alpha.index(SCREAMING_SNAKE_CASE__ ) + key) % len(SCREAMING_SNAKE_CASE__ )
  
              # Append the encoded character to the alphabet
              result += alpha[new_key]
  
      return result
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			str | None = None ):
      key *= -1
  
      return encrypt(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			str | None = None ):
      UpperCamelCase :Optional[int]										=     alphabet or ascii_letters
  
      # To store data on all the combinations
      UpperCamelCase :Tuple										=     {}
  
      # Cycle through each combination
      for key in range(1  ,						len(SCREAMING_SNAKE_CASE__ ) + 1 ):
          # Decrypt the message and store the result in the data
          UpperCamelCase :Dict										=     decrypt(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
      return brute_force_data
  
  
  if __name__ == "__main__":
   while True:
    print(f'''\n{"-" * 10}\n Menu\n{"-" * 10}''')
    print(*["""1.Encrypt""", """2.Decrypt""", """3.BruteForce""", """4.Quit"""], sep="""\n""")
  
    # get user input
    __snake_case							      =						input("""\nWhat would you like to do?: """).strip() or """4"""
  
    # run functions based on what the user chose
    if choice not in ("1", "2", "3", "4"):
     print("""Invalid choice, please enter a valid choice""")
    elif choice == "1":
     __snake_case							      =						input("""Please enter the string to be encrypted: """)
     __snake_case							      =						int(input("""Please enter off-set: """).strip())
  
     print(encrypt(input_string, key))
    elif choice == "2":
     __snake_case							      =						input("""Please enter the string to be decrypted: """)
     __snake_case							      =						int(input("""Please enter off-set: """).strip())
  
     print(decrypt(input_string, key))
    elif choice == "3":
     __snake_case							      =						input("""Please enter the string to be decrypted: """)
     __snake_case							      =						brute_force(input_string)
  
     for key, value in brute_force_data.items():
      print(f'''Key: {key} | Message: {value}''')
  
    elif choice == "4":
     print("""Goodbye.""")
     break
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int ):
      UpperCamelCase :int										=     {1}
      UpperCamelCase :Optional[int]										=     [1]
      for _ in range(2  ,						depth + 1 ):
          UpperCamelCase :Union[str, Any]										=     [*previous_coefficients, 0]
          UpperCamelCase :List[str]										=     [0, *previous_coefficients]
          UpperCamelCase :List[str]										=     []
          for x, y in zip(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ ):
              coefficients.add(x + y )
              previous_coefficients.append(x + y )
      return coefficients
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			set[int] ):
      UpperCamelCase :Union[str, Any]										=     set()
      for number in unique_coefficients:
          UpperCamelCase :Optional[int]										=     2
          UpperCamelCase :List[Any]										=     number
          while divisor**2 <= copy_number:
              UpperCamelCase :List[Any]										=     0
              while copy_number % divisor == 0:
                  copy_number //= divisor
                  multiplicity += 1
              if multiplicity >= 2:
                  non_squarefrees.add(SCREAMING_SNAKE_CASE__ )
                  break
              divisor += 1
  
      return unique_coefficients.difference(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int = 51 ):
      UpperCamelCase :Any										=     get_pascal_triangle_unique_coefficients(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :str										=     get_squarefrees(SCREAMING_SNAKE_CASE__ )
      return sum(SCREAMING_SNAKE_CASE__ )
  
  
  if __name__ == "__main__":
   print(f'''{solution() = }''')
  
  
  
  
  
  