code: 
  
  
  from __future__ import annotations
  
  from string import ascii_letters
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: List[Any] = None      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Union[str, Any]			=	alphabet or ascii_letters
  
  							# The final result string
  							a_       :   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
  																					a_       :   str			=	(alpha.index(SCREAMING_SNAKE_CASE_      ) + key) % len(SCREAMING_SNAKE_CASE_      )
  
  																					# Append the encoded character to the alphabet
  																					result += alpha[new_key]
  
  							return result
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: Union[str, Any]	,	SCREAMING_SNAKE_CASE_				: str = None      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							key *= -1
  
  							return encrypt(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )
  
  
  
  
  
  def 						_lowerCamelCase	(							SCREAMING_SNAKE_CASE_				: Optional[Any]	,	SCREAMING_SNAKE_CASE_				: Tuple = None      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Dict			=	alphabet or ascii_letters
  
  							# To store data on all the combinations
  							a_       :   List[str]			=	{}
  
  							# Cycle through each combination
  							for key in range(1	,	len(SCREAMING_SNAKE_CASE_      ) + 1      ):
  														# Decrypt the message and store the result in the data
  														a_       :   Optional[int]			=	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
  		SCREAMING_SNAKE_CASE : 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":
  			SCREAMING_SNAKE_CASE : int          =    input("Please enter the string to be encrypted: ")
  			SCREAMING_SNAKE_CASE : List[str]          =    int(input("Please enter off-set: ").strip())
  
  			print(encrypt(input_string, key))
  		elif choice == "2":
  			SCREAMING_SNAKE_CASE : Union[str, Any]          =    input("Please enter the string to be decrypted: ")
  			SCREAMING_SNAKE_CASE : str          =    int(input("Please enter off-set: ").strip())
  
  			print(decrypt(input_string, key))
  		elif choice == "3":
  			SCREAMING_SNAKE_CASE : Optional[Any]          =    input("Please enter the string to be decrypted: ")
  			SCREAMING_SNAKE_CASE : 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: 
  
  
  import copy
  from typing import Dict, Optional
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  from ..auto import CONFIG_MAPPING
  
  
  SCREAMING_SNAKE_CASE : List[str]          =    logging.get_logger(__name__)
  
  SCREAMING_SNAKE_CASE : List[Any]          =    {
      "shi-labs/oneformer_ade20k_swin_tiny": (
          "https://huggingface.co/shi-labs/oneformer_ade20k_swin_tiny/blob/main/config.json"
      ),
      # See all OneFormer models at https://huggingface.co/models?filter=oneformer
  }
  
  
  
  
  
  class 					snake_case__  ( __A       ):
  	UpperCAmelCase   :							Tuple         = """oneformer"""
  	UpperCAmelCase   :							Union[str, Any]         = {"""hidden_size""": """hidden_dim"""}
  
  
  
  
  
  	def __init__(  self				,    UpperCamelCase_ = None				,    UpperCamelCase_ = 255				,    UpperCamelCase_ = 150				,    UpperCamelCase_ = 0.1				,    UpperCamelCase_ = 2.0				,    UpperCamelCase_ = 5.0				,    UpperCamelCase_ = 5.0				,    UpperCamelCase_ = 0.5				,    UpperCamelCase_ = 0.07				,    UpperCamelCase_ = 12544				,    UpperCamelCase_ = 3.0				,    UpperCamelCase_ = 0.75				,    UpperCamelCase_ = 0.02				,    UpperCamelCase_ = 1.0				,    UpperCamelCase_ = 1e-05				,    UpperCamelCase_ = False				,    UpperCamelCase_ = True				,    UpperCamelCase_ = True				,    UpperCamelCase_ = [4, 8, 16, 32]				,    UpperCamelCase_ = 77				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 77				,    UpperCamelCase_ = 6				,    UpperCamelCase_ = 49408				,    UpperCamelCase_ = 2				,    UpperCamelCase_ = 16				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 256				,    UpperCamelCase_ = 1024				,    UpperCamelCase_ = "GN"				,    UpperCamelCase_ = 6				,    UpperCamelCase_ = 10				,    UpperCamelCase_ = True				,    UpperCamelCase_ = 8				,    UpperCamelCase_ = 0.1				,    UpperCamelCase_ = 2048				,    UpperCamelCase_ = False				,    UpperCamelCase_ = False				,    UpperCamelCase_ = 2				,    UpperCamelCase_ = 4				,    **UpperCamelCase_				,    )		->			List[Any]:
  								"""simple docstring"""
  
  
  
  
  
  
  								if backbone_config is None:
  															logger.info("""`backbone_config` is unset. Initializing the config with the default `Swin` backbone."""							)
  															a_       :   Tuple			=	CONFIG_MAPPING["""swin"""](
  															    image_size=224				,    in_channels=3				,    patch_size=4				,    embed_dim=96				,    depths=[2, 2, 6, 2]				,    num_heads=[3, 6, 12, 24]				,    window_size=7				,    drop_path_rate=0.3				,    use_absolute_embeddings=UpperCamelCase_				,    out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]				,    )
  								elif isinstance(UpperCamelCase_				,    UpperCamelCase_							):
  															a_       :   str			=	backbone_config.get("""model_type"""							)
  															a_       :   Optional[Any]			=	CONFIG_MAPPING[backbone_model_type]
  															a_       :   List[Any]			=	config_class.from_dict(UpperCamelCase_							)
  
  								a_       :   str			=	backbone_config
  
  								a_       :   List[str]			=	ignore_value
  								a_       :   Optional[int]			=	num_queries
  								a_       :   Optional[Any]			=	no_object_weight
  								a_       :   List[Any]			=	class_weight
  								a_       :   Union[str, Any]			=	mask_weight
  								a_       :   Union[str, Any]			=	dice_weight
  								a_       :   Optional[Any]			=	contrastive_weight
  								a_       :   Any			=	contrastive_temperature
  								a_       :   Optional[int]			=	train_num_points
  								a_       :   Tuple			=	oversample_ratio
  								a_       :   str			=	importance_sample_ratio
  								a_       :   List[Any]			=	init_std
  								a_       :   int			=	init_xavier_std
  								a_       :   List[Any]			=	layer_norm_eps
  								a_       :   Optional[int]			=	is_training
  								a_       :   List[Any]			=	use_auxiliary_loss
  								a_       :   str			=	output_auxiliary_logits
  								a_       :   Dict			=	strides
  								a_       :   List[Any]			=	task_seq_len
  								a_       :   int			=	text_encoder_width
  								a_       :   List[Any]			=	text_encoder_context_length
  								a_       :   List[str]			=	text_encoder_num_layers
  								a_       :   Union[str, Any]			=	text_encoder_vocab_size
  								a_       :   Optional[Any]			=	text_encoder_proj_layers
  								a_       :   Optional[int]			=	text_encoder_n_ctx
  								a_       :   Optional[Any]			=	conv_dim
  								a_       :   str			=	mask_dim
  								a_       :   Optional[Any]			=	hidden_dim
  								a_       :   Any			=	encoder_feedforward_dim
  								a_       :   Dict			=	norm
  								a_       :   List[Any]			=	encoder_layers
  								a_       :   int			=	decoder_layers
  								a_       :   Any			=	use_task_norm
  								a_       :   Union[str, Any]			=	num_attention_heads
  								a_       :   List[str]			=	dropout
  								a_       :   List[Any]			=	dim_feedforward
  								a_       :   Union[str, Any]			=	pre_norm
  								a_       :   Dict			=	enforce_input_proj
  								a_       :   Tuple			=	query_dec_layers
  								a_       :   Any			=	common_stride
  								a_       :   List[str]			=	decoder_layers
  
  								super().__init__(**UpperCamelCase_							)
  
  
  
  
  
  	def     A				(  self							)		->			Dict[str, any]:
  								"""simple docstring"""
  
  
  
  
  
  
  								a_       :   Dict			=	copy.deepcopy(self.__dict__							)
  								a_       :   Any			=	self.backbone_config.to_dict()
  								a_       :   Union[str, Any]			=	self.__class__.model_type
  								return output
  
  
  