code: '''simple docstring'''
  
  __lowercase:		Any							=     {
      "A": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
      "B": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
      "C": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
      "D": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
      "E": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
      "F": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
      "G": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
      "H": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
      "I": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
      "J": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
      "K": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
      "L": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
      "M": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
      "N": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
      "O": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
      "P": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
      "Q": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
      "R": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
      "S": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
      "T": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
      "U": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
      "V": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
      "W": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
      "X": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
      "Y": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
      "Z": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
  }
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				str   )		->					list[tuple[str, str]]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     return [alphabet[char] for char in key.upper()]
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				str    ,		_UpperCamelCase      :				str   )		->					str:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						""
     UpperCamelCase__ 						=						0
     UpperCamelCase__ 						=						generate_table(_UpperCamelCase   )
     for char in words.upper():
        cipher += get_opponent(table[count]    ,		_UpperCamelCase   )
        UpperCamelCase__ 						=						(count + 1) % len(_UpperCamelCase   )
     return cipher
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				str    ,		_UpperCamelCase      :				str   )		->					str:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     return encrypt(_UpperCamelCase    ,		_UpperCamelCase   )
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				tuple[str, str]    ,		_UpperCamelCase      :				str   )		->					tuple[int, int]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						0 if char in table[0] else 1
     UpperCamelCase__ 						=						table[row].index(_UpperCamelCase   )
     return row, col
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				tuple[str, str]    ,		_UpperCamelCase      :				str   )		->					str:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						get_position(_UpperCamelCase    ,		char.upper()   )
     if row == 1:
        return table[0][col]
     else:
        return table[1][col] if row == 0 else char
  
  
  if __name__ == "__main__":
         import doctest
  
         doctest.testmod()  # Fist ensure that all our tests are passing...
         __lowercase:		str							=     input("Enter key: ").strip()
         __lowercase:		str							=     input("Enter text to encrypt: ").strip()
         __lowercase:		Optional[Any]							=     encrypt(key, text)
  
         print(F"""Encrypted: {cipher_text}""")
         print(F"""Decrypted with key: {decrypt(key, cipher_text)}""")
style_context: 
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __lowercase:		int							=     {
      "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
  }
  
  try:
         if not is_sentencepiece_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		str							=     ["LlamaTokenizer"]
  
  try:
         if not is_tokenizers_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		List[Any]							=     ["LlamaTokenizerFast"]
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		Union[str, Any]							=     [
             "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
  
         __lowercase:		Tuple							=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)