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 typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __snake_case							      =						{
      """configuration_open_llama""": ["""OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenLlamaConfig"""],
  }
  
  try:
   if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						["""LlamaTokenizer"""]
  
  try:
   if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						["""LlamaTokenizerFast"""]
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __snake_case							      =						[
       """OpenLlamaForCausalLM""",
       """OpenLlamaModel""",
       """OpenLlamaPreTrainedModel""",
       """OpenLlamaForSequenceClassification""",
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig
  
   try:
    if not is_sentencepiece_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from transformers import LlamaTokenizer
  
   try:
    if not is_tokenizers_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from transformers import LlamaTokenizerFast
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_open_llama import (
        OpenLlamaForCausalLM,
        OpenLlamaForSequenceClassification,
        OpenLlamaModel,
        OpenLlamaPreTrainedModel,
    )
  
  
  else:
   import sys
  
   __snake_case							      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
  
  