code: 
  '''simple docstring'''
  
  from __future__ import annotations
  
  from string import ascii_letters
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
  		_UpperCamelCase       : Union[str, Any]    =      alphabet or ascii_letters
  
  		# The final result string
  		_UpperCamelCase       : str    =      ''''''
  
  		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       : str    =      (alpha.index(UpperCamelCase	) + key) % len(UpperCamelCase	)
  
  						# Append the encoded character to the alphabet
  						result += alpha[new_key]
  
  		return result
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
  		key *= -1
  
  		return encrypt(UpperCamelCase			,UpperCamelCase			,UpperCamelCase	)
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase = None	) ->      dict[int, str]:
  		_UpperCamelCase       : Dict    =      alphabet or ascii_letters
  
  		# To store data on all the combinations
  		_UpperCamelCase       : List[str]    =      {}
  
  		# Cycle through each combination
  		for key in range(1			,len(UpperCamelCase	) + 1	):
  				# Decrypt the message and store the result in the data
  				_UpperCamelCase       : Optional[int]    =      decrypt(UpperCamelCase			,UpperCamelCase			,UpperCamelCase	)
  
  		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
  		_UpperCAmelCase   :      Optional[int] 						=  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":
  			_UpperCAmelCase   :      int 						=  input("""Please enter the string to be encrypted: """)
  			_UpperCAmelCase   :      List[str] 						=  int(input("""Please enter off-set: """).strip())
  
  			print(encrypt(input_string, key))
  		elif choice == "2":
  			_UpperCAmelCase   :      Union[str, Any] 						=  input("""Please enter the string to be decrypted: """)
  			_UpperCAmelCase   :      str 						=  int(input("""Please enter off-set: """).strip())
  
  			print(decrypt(input_string, key))
  		elif choice == "3":
  			_UpperCAmelCase   :      Optional[Any] 						=  input("""Please enter the string to be decrypted: """)
  			_UpperCAmelCase   :      str 						=  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: 
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  _UpperCAmelCase   :      int 						=  {
      """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
      """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
  }
  
  try:
  	if not is_torch_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	_UpperCAmelCase   :      int 						=  [
  	    """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
  	    """GPTSanJapaneseForConditionalGeneration""",
  	    """GPTSanJapaneseModel""",
  	    """GPTSanJapanesePreTrainedModel""",
  	]
  	_UpperCAmelCase   :      str 						=  [
  	    """GPTSanJapaneseTokenizer""",
  	]
  
  
  if TYPE_CHECKING:
  	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
  	try:
  		if not is_torch_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .modeling_gptsan_japanese import (
  		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
  		    GPTSanJapaneseForConditionalGeneration,
  		    GPTSanJapaneseModel,
  		    GPTSanJapanesePreTrainedModel,
  		)
  		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer
  
  
  else:
  	import sys
  
  	_UpperCAmelCase   :      List[str] 						=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
  
  