


'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


if is_sentencepiece_available():
  from ..ta.tokenization_ta import TaTokenizer
else:
  from ...utils.dummy_sentencepiece_objects import TaTokenizer

a__  :					Optional[Any]        =       TaTokenizer

if is_tokenizers_available():
  from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
  from ...utils.dummy_tokenizers_objects import TaTokenizerFast

a__  :					int        =       TaTokenizerFast

a__  :					List[Any]        =       {'configuration_mt5': ['MT5Config', 'MT5OnnxConfig']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  :					str        =       [
      'MT5EncoderModel',
      'MT5ForConditionalGeneration',
      'MT5ForQuestionAnswering',
      'MT5Model',
      'MT5PreTrainedModel',
      'MT5Stack',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  :					int        =       ['TFMT5EncoderModel', 'TFMT5ForConditionalGeneration', 'TFMT5Model']

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  :					Dict        =       ['FlaxMT5EncoderModel', 'FlaxMT5ForConditionalGeneration', 'FlaxMT5Model']


if TYPE_CHECKING:
  from .configuration_mta import MTaConfig, MTaOnnxConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mta import (
        MTaEncoderModel,
        MTaForConditionalGeneration,
        MTaForQuestionAnswering,
        MTaModel,
        MTaPreTrainedModel,
        MTaStack,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
  import sys

  a__  :					List[Any]        =       _LazyModule(
      __name__,
      globals()['__file__'],
      _import_structure,
      extra_objects={'MT5Tokenizer': MTaTokenizer, 'MT5TokenizerFast': MTaTokenizerFast},
      module_spec=__spec__,
  )








import string

def 						UpperCamelCase					(lowercase_: str					)     ->      None:
	for key in range(len(string.ascii_uppercase					)					):
		A__							:    Dict        =		""""""
		for symbol in message:
			if symbol in string.ascii_uppercase:
				A__							:    Dict        =		string.ascii_uppercase.find(lowercase_					)
				A__							:    Optional[int]        =		num - key
				if num < 0:
					A__							:    Optional[int]        =		num + len(string.ascii_uppercase					)
				A__							:    Any        =		translated + string.ascii_uppercase[num]
			else:
				A__							:    Optional[Any]        =		translated + symbol
		print(f"""Decryption using Key #{key}: {translated}"""					)

def 						UpperCamelCase					()     ->      None:
	A__							:    Optional[Any]        =		input("""Encrypted message: """					)
	A__							:    Optional[Any]        =		message.upper()
	decrypt(lowercase_					)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()



