code: 
  import os
  import unittest
  
  from transformers import RealmTokenizerFast
  from transformers.models.bert.tokenization_bert import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      WordpieceTokenizer,
      _is_control,
      _is_punctuation,
      _is_whitespace,
  )
  from transformers.models.realm.tokenization_realm import RealmTokenizer
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
  
  
  
  
  
  @require_tokenizers
  class 						lowerCamelCase			(					__lowerCamelCase   ,		unittest.TestCase				):
   UpperCamelCase_     :				Dict								=  RealmTokenizer
   UpperCamelCase_     :				Optional[Any]								=  RealmTokenizerFast
   UpperCamelCase_     :				Dict								=  True
   UpperCamelCase_     :				int								=  True
   UpperCamelCase_     :				str								=  filter_non_english
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Tuple )		->			Any:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      super().setUp()
  
      SCREAMING_SNAKE_CASE    	=   [
          '''[UNK]''',
          '''[CLS]''',
          '''[SEP]''',
          '''[PAD]''',
          '''[MASK]''',
          '''want''',
          '''##want''',
          '''##ed''',
          '''wa''',
          '''un''',
          '''runn''',
          '''##ing''',
          ''',''',
          '''low''',
          '''lowest''',
      ]
      SCREAMING_SNAKE_CASE    	=   os.path.join(self.tmpdirname      ,    VOCAB_FILES_NAMES['''vocab_file'''] )
      with open(self.vocab_file      ,    '''w'''      ,    encoding='''utf-8''' ) as vocab_writer:
         vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Union[str, Any]      ,    lowercase			:Optional[Any] )		->			Dict:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   '''UNwant\u00E9d,running'''
      SCREAMING_SNAKE_CASE    	=   '''unwanted, running'''
      return input_text, output_text
  
  
  
  
  
  
  
   def    snake_case__    (    self			:List[Any] )		->			str:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   self.tokenizer_class(self.vocab_file )
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.tokenize('''UNwant\u00E9d,running''' )
      self.assertListEqual(lowercase      ,    ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] )
      self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase )      ,    [9, 6, 7, 1_2, 1_0, 1_1] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:str )		->			int:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      if not self.test_rust_tokenizer:
         return
  
      SCREAMING_SNAKE_CASE    	=   self.get_tokenizer()
      SCREAMING_SNAKE_CASE    	=   self.get_rust_tokenizer()
  
      SCREAMING_SNAKE_CASE    	=   '''UNwant\u00E9d,running'''
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.tokenize(lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.tokenize(lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
      SCREAMING_SNAKE_CASE    	=   self.get_rust_tokenizer()
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.encode(lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
      # With lower casing
      SCREAMING_SNAKE_CASE    	=   self.get_tokenizer(do_lower_case=lowercase )
      SCREAMING_SNAKE_CASE    	=   self.get_rust_tokenizer(do_lower_case=lowercase )
  
      SCREAMING_SNAKE_CASE    	=   '''UNwant\u00E9d,running'''
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.tokenize(lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.tokenize(lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
      SCREAMING_SNAKE_CASE    	=   self.get_rust_tokenizer()
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase )
      SCREAMING_SNAKE_CASE    	=   rust_tokenizer.encode(lowercase )
      self.assertListEqual(lowercase      ,    lowercase )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Optional[int] )		->			str:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer()
  
      self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz''' )      ,    ['''ah''', '''\u535A''', '''\u63A8''', '''zz'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:str )		->			Any:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''' )      ,    ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
      self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )      ,    ['''hello'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Optional[int] )		->			Union[str, Any]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase      ,    strip_accents=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )      ,    ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
      self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )      ,    ['''h\u00E9llo'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Union[str, Any] )		->			int:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase      ,    strip_accents=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )      ,    ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
      self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )      ,    ['''hello'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Union[str, Any] )		->			List[str]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )      ,    ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
      self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )      ,    ['''hello'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:List[str] )		->			str:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''' )      ,    ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Union[str, Any] )		->			Optional[Any]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase      ,    strip_accents=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )      ,    ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Any )		->			List[Any]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase      ,    strip_accents=lowercase )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )      ,    ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:List[str] )		->			Optional[int]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   BasicTokenizer(do_lower_case=lowercase      ,    never_split=['''[UNK]'''] )
  
      self.assertListEqual(
          tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]''' )      ,    ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Optional[Any] )		->			List[Any]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']
  
      SCREAMING_SNAKE_CASE    	=   {}
      for i, token in enumerate(lowercase ):
         SCREAMING_SNAKE_CASE    	=   i
      SCREAMING_SNAKE_CASE    	=   WordpieceTokenizer(vocab=lowercase      ,    unk_token='''[UNK]''' )
  
      self.assertListEqual(tokenizer.tokenize('''''' )      ,    [] )
  
      self.assertListEqual(tokenizer.tokenize('''unwanted running''' )      ,    ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing'''] )
  
      self.assertListEqual(tokenizer.tokenize('''unwantedX running''' )      ,    ['''[UNK]''', '''runn''', '''##ing'''] )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Union[str, Any] )		->			Dict:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      self.assertTrue(_is_whitespace(''' ''' ) )
      self.assertTrue(_is_whitespace('''\t''' ) )
      self.assertTrue(_is_whitespace('''\r''' ) )
      self.assertTrue(_is_whitespace('''\n''' ) )
      self.assertTrue(_is_whitespace('''\u00A0''' ) )
  
      self.assertFalse(_is_whitespace('''A''' ) )
      self.assertFalse(_is_whitespace('''-''' ) )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Any )		->			int:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      self.assertTrue(_is_control('''\u0005''' ) )
  
      self.assertFalse(_is_control('''A''' ) )
      self.assertFalse(_is_control(''' ''' ) )
      self.assertFalse(_is_control('''\t''' ) )
      self.assertFalse(_is_control('''\r''' ) )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Optional[int] )		->			Dict:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      self.assertTrue(_is_punctuation('''-''' ) )
      self.assertTrue(_is_punctuation('''$''' ) )
      self.assertTrue(_is_punctuation('''`''' ) )
      self.assertTrue(_is_punctuation('''.''' ) )
  
      self.assertFalse(_is_punctuation('''A''' ) )
      self.assertFalse(_is_punctuation(''' ''' ) )
  
  
  
  
  
  
  
   def    snake_case__    (    self			:int )		->			Any:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   self.get_tokenizer()
  
      # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
      self.assertListEqual([tokenizer.tokenize(lowercase ) for t in ['''Test''', '''\xad''', '''test''']]      ,    [['''[UNK]'''], [], ['''[UNK]''']] )
  
      if self.test_rust_tokenizer:
         SCREAMING_SNAKE_CASE    	=   self.get_rust_tokenizer()
         self.assertListEqual(
             [rust_tokenizer.tokenize(lowercase ) for t in ['''Test''', '''\xad''', '''test''']]      ,    [['''[UNK]'''], [], ['''[UNK]''']] )
  
  
  
  
  
  
  
   @slow
   def    snake_case__    (    self			:Optional[Any] )		->			Optional[int]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      SCREAMING_SNAKE_CASE    	=   self.tokenizer_class.from_pretrained('''bert-base-uncased''' )
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''sequence builders'''      ,    add_special_tokens=lowercase )
      SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''multi-sequence build'''      ,    add_special_tokens=lowercase )
  
      SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase )
      SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase      ,    lowercase )
  
      assert encoded_sentence == [1_0_1] + text + [1_0_2]
      assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]
  
  
  
  
  
  
  
   def    snake_case__    (    self			:Any )		->			Optional[int]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
            SCREAMING_SNAKE_CASE    	=   self.rust_tokenizer_class.from_pretrained(lowercase      ,    **lowercase )
  
            SCREAMING_SNAKE_CASE    	=   f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
            SCREAMING_SNAKE_CASE    	=   tokenizer_r.encode_plus(
                lowercase      ,    return_attention_mask=lowercase      ,    return_token_type_ids=lowercase      ,    return_offsets_mapping=lowercase      ,    add_special_tokens=lowercase      ,    )
  
            SCREAMING_SNAKE_CASE    	=   tokenizer_r.do_lower_case if hasattr(lowercase      ,    '''do_lower_case''' ) else False
            SCREAMING_SNAKE_CASE    	=   (
                [
                    ((0, 0), tokenizer_r.cls_token),
                    ((0, 1), '''A'''),
                    ((1, 2), ''','''),
                    ((3, 5), '''na'''),
                    ((5, 6), '''##ï'''),
                    ((6, 8), '''##ve'''),
                    ((9, 1_5), tokenizer_r.mask_token),
                    ((1_6, 2_1), '''Allen'''),
                    ((2_1, 2_3), '''##NL'''),
                    ((2_3, 2_4), '''##P'''),
                    ((2_5, 3_3), '''sentence'''),
                    ((3_3, 3_4), '''.'''),
                    ((0, 0), tokenizer_r.sep_token),
                ]
                if not do_lower_case
                else [
                    ((0, 0), tokenizer_r.cls_token),
                    ((0, 1), '''a'''),
                    ((1, 2), ''','''),
                    ((3, 8), '''naive'''),
                    ((9, 1_5), tokenizer_r.mask_token),
                    ((1_6, 2_1), '''allen'''),
                    ((2_1, 2_3), '''##nl'''),
                    ((2_3, 2_4), '''##p'''),
                    ((2_5, 3_3), '''sentence'''),
                    ((3_3, 3_4), '''.'''),
                    ((0, 0), tokenizer_r.sep_token),
                ]
            )
  
            self.assertEqual(
                [e[1] for e in expected_results]      ,    tokenizer_r.convert_ids_to_tokens(tokens['''input_ids'''] ) )
            self.assertEqual([e[0] for e in expected_results]      ,    tokens['''offset_mapping'''] )
  
  
  
  
  
  
  
   @slow
   def    snake_case__    (    self			:Any )		->			Optional[int]:
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
            SCREAMING_SNAKE_CASE    	=   self.rust_tokenizer_class.from_pretrained(lowercase      ,    **lowercase )
            SCREAMING_SNAKE_CASE    	=   self.tokenizer_class.from_pretrained(lowercase      ,    **lowercase )
            SCREAMING_SNAKE_CASE    	=   [['''Hello world!''', '''Nice to meet you!'''], ['''The cute cat.''', '''The adorable dog.''']]
  
            SCREAMING_SNAKE_CASE    	=   tokenizer_r.batch_encode_candidates(lowercase      ,    max_length=1_0      ,    return_tensors='''np''' )
            SCREAMING_SNAKE_CASE    	=   tokenizer_p.batch_encode_candidates(lowercase      ,    max_length=1_0      ,    return_tensors='''np''' )
  
            SCREAMING_SNAKE_CASE    	=   (2, 2, 1_0)
  
            self.assertEqual(encoded_sentence_r['''input_ids'''].shape      ,    lowercase )
            self.assertEqual(encoded_sentence_r['''attention_mask'''].shape      ,    lowercase )
            self.assertEqual(encoded_sentence_r['''token_type_ids'''].shape      ,    lowercase )
  
            self.assertEqual(encoded_sentence_p['''input_ids'''].shape      ,    lowercase )
            self.assertEqual(encoded_sentence_p['''attention_mask'''].shape      ,    lowercase )
            self.assertEqual(encoded_sentence_p['''token_type_ids'''].shape      ,    lowercase )
style_context: 
  from __future__ import annotations
  
  
  def       a			(   a		,	a  )    ->str:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   '''''', '''''', ''''''
  			SCREAMING_SNAKE_CASE    	=   []
  
  			for character in message_part:
  						tmp.append(character_to_number[character]  )
  
  			for each in tmp:
  						one += each[0]
  						two += each[1]
  						three += each[2]
  
  			return one + two + three
  
  
  def       a			(   a		,	a  )    ->tuple[str, str, str]:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   '''''', ''''''
  			SCREAMING_SNAKE_CASE    	=   []
  
  			for character in message_part:
  						this_part += character_to_number[character]
  
  			for digit in this_part:
  						tmp += digit
  						if len(a  ) == len(a  ):
  									result.append(a  )
  									SCREAMING_SNAKE_CASE    	=   ''''''
  
  			return result[0], result[1], result[2]
  
  
  def       a			(   a		,	a  )    ->tuple[str, str, dict[str, str], dict[str, str]]:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE    	=   alphabet.replace(''' '''		,	''''''  ).upper()
  			SCREAMING_SNAKE_CASE    	=   message.replace(''' '''		,	''''''  ).upper()
  
  			# Check length and characters
  			if len(a  ) != 27:
  						raise KeyError('''Length of alphabet has to be 27.'''  )
  			for each in message:
  						if each not in alphabet:
  									raise ValueError('''Each message character has to be included in alphabet!'''  )
  
      # Generate dictionares
  			SCREAMING_SNAKE_CASE    	=   (
  			    '''111''',
  			    '''112''',
  			    '''113''',
  			    '''121''',
  			    '''122''',
  			    '''123''',
  			    '''131''',
  			    '''132''',
  			    '''133''',
  			    '''211''',
  			    '''212''',
  			    '''213''',
  			    '''221''',
  			    '''222''',
  			    '''223''',
  			    '''231''',
  			    '''232''',
  			    '''233''',
  			    '''311''',
  			    '''312''',
  			    '''313''',
  			    '''321''',
  			    '''322''',
  			    '''323''',
  			    '''331''',
  			    '''332''',
  			    '''333''',
  			)
  			SCREAMING_SNAKE_CASE    	=   {}
  			SCREAMING_SNAKE_CASE    	=   {}
  			for letter, number in zip(a		,	a  ):
  						SCREAMING_SNAKE_CASE    	=   number
  						SCREAMING_SNAKE_CASE    	=   letter
  
  			return message, alphabet, character_to_number, number_to_character
  
  
  def       a			(   a		,	a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."		,	a = 5  )    ->str:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   __prepare(
  			    a		,	a  )
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   '''''', ''''''
  
  			for i in range(0		,	len(a  ) + 1		,	a  ):
  						encrypted_numeric += __encrypt_part(
  						    message[i : i + period]		,	a  )
  
  			for i in range(0		,	len(a  )		,	3  ):
  						encrypted += number_to_character[encrypted_numeric[i : i + 3]]
  
  			return encrypted
  
  
  def       a			(   a		,	a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."		,	a = 5  )    ->str:
  
  
  
  
  			'''simple docstring'''
  
  
  			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   __prepare(
  			    a		,	a  )
  			SCREAMING_SNAKE_CASE    	=   []
  			SCREAMING_SNAKE_CASE    	=   ''''''
  
  			for i in range(0		,	len(a  ) + 1		,	a  ):
  						SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   __decrypt_part(message[i : i + period]		,	a  )
  
  						for j in range(0		,	len(a  )  ):
  									decrypted_numeric.append(a[j] + b[j] + c[j]  )
  
  			for each in decrypted_numeric:
  						decrypted += number_to_character[each]
  
  			return decrypted
  
  
  if __name__ == "__main__":
  							__lowerCAmelCase				      =					'DEFEND THE EAST WALL OF THE CASTLE.'
  							__lowerCAmelCase				      =					encrypt_message(msg, 'EPSDUCVWYM.ZLKXNBTFGORIJHAQ')
  							__lowerCAmelCase				      =					decrypt_message(encrypted, 'EPSDUCVWYM.ZLKXNBTFGORIJHAQ')
  							print(F'''Encrypted: {encrypted}\nDecrypted: {decrypted}''')