code: 
  
  
  """simple docstring"""
  import json
  import os
  from functools import lru_cache
  from typing import TYPE_CHECKING, List, Optional, Tuple
  
  import regex as re
  
  from ...tokenization_utils import AddedToken, PreTrainedTokenizer
  from ...utils import logging
  
  
  if TYPE_CHECKING:
   from transformers.pipelines.conversational import Conversation
  
  UpperCAmelCase   =	logging.get_logger(__name__)
  
  UpperCAmelCase   =	{
      """vocab_file""": """vocab.json""",
      """merges_file""": """merges.txt""",
  }
  
  UpperCAmelCase   =	{
      """vocab_file""": {
          """gpt2""": """https://huggingface.co/gpt2/resolve/main/vocab.json""",
          """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/vocab.json""",
          """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/vocab.json""",
          """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/vocab.json""",
          """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/vocab.json""",
      },
      """merges_file""": {
          """gpt2""": """https://huggingface.co/gpt2/resolve/main/merges.txt""",
          """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/merges.txt""",
          """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/merges.txt""",
          """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/merges.txt""",
          """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/merges.txt""",
      },
  }
  
  UpperCAmelCase   =	{
      """gpt2""": 1024,
      """gpt2-medium""": 1024,
      """gpt2-large""": 1024,
      """gpt2-xl""": 1024,
      """distilgpt2""": 1024,
  }
  
  @lru_cache()
  def 							_snake_case			(      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				Dict      =		(
         list(range(ord("""!"""      )	,   ord("""~"""      ) + 1      )      ) + list(range(ord("""¡"""      )	,   ord("""¬"""      ) + 1      )      ) + list(range(ord("""®"""      )	,   ord("""ÿ"""      ) + 1      )      )
     )
     _lowerCamelCase  :				Union[str, Any]      =		bs[:]
     _lowerCamelCase  :				Optional[Any]      =		0
     for b in range(2**8      ):
        if b not in bs:
           bs.append(__snake_case      )
           cs.append(2**8 + n      )
           n += 1
     _lowerCamelCase  :				Any      =		[chr(__snake_case      ) for n in cs]
     return dict(zip(__snake_case	,   __snake_case      )      )
  
  def 							_snake_case			(      __snake_case       :			Optional[int]      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				Optional[Any]      =		set()
     _lowerCamelCase  :				List[Any]      =		word[0]
     for char in word[1:]:
        pairs.add((prev_char, char)      )
        _lowerCamelCase  :				Dict      =		char
     return pairs
  
  
  
  
  
  class   lowercase__							(				A_							):
     __UpperCAmelCase       					=				VOCAB_FILES_NAMES
     __UpperCAmelCase       					=				PRETRAINED_VOCAB_FILES_MAP
     __UpperCAmelCase       					=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __UpperCAmelCase       					=				['''input_ids''', '''attention_mask''']
  
  
  
  
  
     def __init__(       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE="replace"			,      SCREAMING_SNAKE_CASE="<|endoftext|>"			,      SCREAMING_SNAKE_CASE="<|endoftext|>"			,      SCREAMING_SNAKE_CASE="<|endoftext|>"			,      SCREAMING_SNAKE_CASE=None			,      SCREAMING_SNAKE_CASE=False			,      SCREAMING_SNAKE_CASE=False			,      **SCREAMING_SNAKE_CASE			,      )     ->     Optional[int]:
        _lowerCamelCase  :				List[str]      =		AddedToken(SCREAMING_SNAKE_CASE			,      lstrip=SCREAMING_SNAKE_CASE			,      rstrip=SCREAMING_SNAKE_CASE) if isinstance(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE) else bos_token
        _lowerCamelCase  :				int      =		AddedToken(SCREAMING_SNAKE_CASE			,      lstrip=SCREAMING_SNAKE_CASE			,      rstrip=SCREAMING_SNAKE_CASE) if isinstance(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE) else eos_token
        _lowerCamelCase  :				Union[str, Any]      =		AddedToken(SCREAMING_SNAKE_CASE			,      lstrip=SCREAMING_SNAKE_CASE			,      rstrip=SCREAMING_SNAKE_CASE) if isinstance(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE) else unk_token
        _lowerCamelCase  :				Optional[int]      =		AddedToken(SCREAMING_SNAKE_CASE			,      lstrip=SCREAMING_SNAKE_CASE			,      rstrip=SCREAMING_SNAKE_CASE) if isinstance(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE) else pad_token
        super().__init__(
            errors=SCREAMING_SNAKE_CASE			,      unk_token=SCREAMING_SNAKE_CASE			,      bos_token=SCREAMING_SNAKE_CASE			,      eos_token=SCREAMING_SNAKE_CASE			,      pad_token=SCREAMING_SNAKE_CASE			,      add_prefix_space=SCREAMING_SNAKE_CASE			,      add_bos_token=SCREAMING_SNAKE_CASE			,      **SCREAMING_SNAKE_CASE			,      )
        _lowerCamelCase  :				Any      =		add_bos_token
  
        with open(SCREAMING_SNAKE_CASE			,      encoding="""utf-8""") as vocab_handle:
           _lowerCamelCase  :				int      =		json.load(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				Dict      =		{v: k for k, v in self.encoder.items()}
        _lowerCamelCase  :				Optional[int]      =		errors  # how to handle errors in decoding
        _lowerCamelCase  :				Union[str, Any]      =		bytes_to_unicode()
        _lowerCamelCase  :				int      =		{v: k for k, v in self.byte_encoder.items()}
        with open(SCREAMING_SNAKE_CASE			,      encoding="""utf-8""") as merges_handle:
           _lowerCamelCase  :				List[str]      =		merges_handle.read().split("""\n""")[1:-1]
        _lowerCamelCase  :				str      =		[tuple(merge.split()) for merge in bpe_merges]
        _lowerCamelCase  :				Any      =		dict(zip(SCREAMING_SNAKE_CASE			,      range(len(SCREAMING_SNAKE_CASE))))
        _lowerCamelCase  :				Tuple      =		{}
        _lowerCamelCase  :				Dict      =		add_prefix_space
  
        # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
        _lowerCamelCase  :				str      =		re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")
  
  
  
  
  
     @property
     def 		UpperCamelCase_     (       self)     ->     Tuple:
        return len(self.encoder)
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     Any:
        return dict(self.encoder			,      **self.added_tokens_encoder)
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     str:
        if token in self.cache:
           return self.cache[token]
        _lowerCamelCase  :				Optional[Any]      =		tuple(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				List[Any]      =		get_pairs(SCREAMING_SNAKE_CASE)
  
        if not pairs:
           return token
  
        while True:
           _lowerCamelCase  :				List[Any]      =		min(SCREAMING_SNAKE_CASE			,      key=lambda SCREAMING_SNAKE_CASE: self.bpe_ranks.get(SCREAMING_SNAKE_CASE			,      float("""inf""")))
           if bigram not in self.bpe_ranks:
              break
           _lowerCamelCase      ,						_lowerCamelCase  :				Union[str, Any]      =		bigram
           _lowerCamelCase  :				Tuple      =		[]
           _lowerCamelCase  :				Optional[Any]      =		0
           while i < len(SCREAMING_SNAKE_CASE):
              try:
                 _lowerCamelCase  :				Optional[int]      =		word.index(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE)
              except ValueError:
                 new_word.extend(word[i:])
                 break
              else:
                 new_word.extend(word[i:j])
                 _lowerCamelCase  :				str      =		j
  
              if word[i] == first and i < len(SCREAMING_SNAKE_CASE) - 1 and word[i + 1] == second:
                 new_word.append(first + second)
                 i += 2
              else:
                 new_word.append(word[i])
                 i += 1
           _lowerCamelCase  :				Optional[Any]      =		tuple(SCREAMING_SNAKE_CASE)
           _lowerCamelCase  :				Optional[Any]      =		new_word
           if len(SCREAMING_SNAKE_CASE) == 1:
              break
           else:
              _lowerCamelCase  :				Dict      =		get_pairs(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				Union[str, Any]      =		""" """.join(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				Optional[int]      =		word
        return word
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE=None)     ->     Union[str, Any]:
        if self.add_bos_token:
           _lowerCamelCase  :				str      =		[self.bos_token_id]
        else:
           _lowerCamelCase  :				Union[str, Any]      =		[]
  
        _lowerCamelCase  :				Optional[Any]      =		bos_token_ids + token_ids_a
  
        if token_ids_a is None:
           return output
  
        return output + bos_token_ids + token_ids_a
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE = None			,      SCREAMING_SNAKE_CASE = False)     ->     List[int]:
        if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=SCREAMING_SNAKE_CASE			,      token_ids_a=SCREAMING_SNAKE_CASE			,      already_has_special_tokens=SCREAMING_SNAKE_CASE)
  
        if not self.add_bos_token:
           return super().get_special_tokens_mask(
               token_ids_a=SCREAMING_SNAKE_CASE			,      token_ids_a=SCREAMING_SNAKE_CASE			,      already_has_special_tokens=SCREAMING_SNAKE_CASE)
  
        if token_ids_a is None:
           return [1] + ([0] * len(SCREAMING_SNAKE_CASE))
        return [1] + ([0] * len(SCREAMING_SNAKE_CASE)) + [1] + ([0] * len(SCREAMING_SNAKE_CASE))
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     Optional[int]:
        _lowerCamelCase  :				Optional[int]      =		[]
        for token in re.findall(self.pat			,      SCREAMING_SNAKE_CASE):
           _lowerCamelCase  :				Optional[Any]      =		"""""".join(
               self.byte_encoder[b] for b in token.encode("""utf-8"""))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
           bpe_tokens.extend(bpe_token for bpe_token in self.bpe(SCREAMING_SNAKE_CASE).split(""" """))
        return bpe_tokens
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     int:
        return self.encoder.get(SCREAMING_SNAKE_CASE			,      self.encoder.get(self.unk_token))
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     List[str]:
        return self.decoder.get(SCREAMING_SNAKE_CASE)
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     int:
        _lowerCamelCase  :				int      =		"""""".join(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				str      =		bytearray([self.byte_decoder[c] for c in text]).decode("""utf-8"""			,      errors=self.errors)
        return text
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE = None)     ->     Tuple[str]:
        if not os.path.isdir(SCREAMING_SNAKE_CASE):
           logger.error(F'Vocabulary path ({save_directory}) should be a directory')
           return
        _lowerCamelCase  :				str      =		os.path.join(
            SCREAMING_SNAKE_CASE			,      (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""])
        _lowerCamelCase  :				List[Any]      =		os.path.join(
            SCREAMING_SNAKE_CASE			,      (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""])
  
        with open(SCREAMING_SNAKE_CASE			,      """w"""			,      encoding="""utf-8""") as f:
           f.write(json.dumps(self.encoder			,      indent=2			,      sort_keys=SCREAMING_SNAKE_CASE			,      ensure_ascii=SCREAMING_SNAKE_CASE) + """\n""")
  
        _lowerCamelCase  :				Tuple      =		0
        with open(SCREAMING_SNAKE_CASE			,      """w"""			,      encoding="""utf-8""") as writer:
           writer.write("""#version: 0.2\n""")
           for bpe_tokens, token_index in sorted(self.bpe_ranks.items()			,      key=lambda SCREAMING_SNAKE_CASE: kv[1]):
              if index != token_index:
                 logger.warning(
                     F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
                     """ Please check that the tokenizer is not corrupted!""")
                 _lowerCamelCase  :				Dict      =		token_index
              writer.write(""" """.join(SCREAMING_SNAKE_CASE) + """\n""")
              index += 1
  
        return vocab_file, merge_file
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE=False			,      **SCREAMING_SNAKE_CASE)     ->     List[Any]:
        _lowerCamelCase  :				List[str]      =		kwargs.pop("""add_prefix_space"""			,      self.add_prefix_space)
        if is_split_into_words or add_prefix_space:
           _lowerCamelCase  :				str      =		""" """ + text
        return (text, kwargs)
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     List[int]:
        _lowerCamelCase  :				Tuple      =		[]
        for is_user, text in conversation.iter_texts():
           input_ids.extend(self.encode(SCREAMING_SNAKE_CASE			,      add_special_tokens=SCREAMING_SNAKE_CASE) + [self.eos_token_id])
        if len(SCREAMING_SNAKE_CASE) > self.model_max_length:
           _lowerCamelCase  :				Optional[int]      =		input_ids[-self.model_max_length :]
        return input_ids
  
  
style_context: 
  
  
  """simple docstring"""
  import subprocess
  from argparse import ArgumentParser
  from typing import List, Union
  
  from huggingface_hub.hf_api import HfFolder, create_repo, whoami
  from requests.exceptions import HTTPError
  
  from . import BaseTransformersCLICommand
  
  
  
  
  class   lowercase__							(				A_							):
  
  
  
  
  
     @staticmethod
     def 		UpperCamelCase_     (       SCREAMING_SNAKE_CASE)     ->     Dict:
        _lowerCamelCase  :				Optional[Any]      =		parser.add_parser("""login"""			,      help="""Log in using the same credentials as on huggingface.co""")
        login_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: LoginCommand(SCREAMING_SNAKE_CASE))
        _lowerCamelCase  :				Any      =		parser.add_parser("""whoami"""			,      help="""Find out which huggingface.co account you are logged in as.""")
        whoami_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: WhoamiCommand(SCREAMING_SNAKE_CASE))
        _lowerCamelCase  :				Optional[int]      =		parser.add_parser("""logout"""			,      help="""Log out""")
        logout_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: LogoutCommand(SCREAMING_SNAKE_CASE))
  
        # new system: git-based repo system
        _lowerCamelCase  :				Optional[int]      =		parser.add_parser(
            """repo"""			,      help="""Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos."""			,      )
        _lowerCamelCase  :				Optional[Any]      =		repo_parser.add_subparsers(
            help="""Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands""")
        _lowerCamelCase  :				Dict      =		repo_subparsers.add_parser(
            """create"""			,      help="""Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co""")
        repo_create_parser.add_argument(
            """name"""			,      type=SCREAMING_SNAKE_CASE			,      help="""Name for your model's repo. Will be namespaced under your username to build the model id."""			,      )
        repo_create_parser.add_argument("""--organization"""			,      type=SCREAMING_SNAKE_CASE			,      help="""Optional: organization namespace.""")
        repo_create_parser.add_argument("""-y"""			,      """--yes"""			,      action="""store_true"""			,      help="""Optional: answer Yes to the prompt""")
        repo_create_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: RepoCreateCommand(SCREAMING_SNAKE_CASE))
  
  
  
  
  
  
  
  class   lowercase__							:
     __UpperCAmelCase       					=				'''\u001b[1m'''
     __UpperCAmelCase       					=				'''\u001b[31m'''
     __UpperCAmelCase       					=				'''\u001b[90m'''
     __UpperCAmelCase       					=				'''\u001b[0m'''
  
  
  
  
  
     @classmethod
     def 		UpperCamelCase_     (       cls			,      SCREAMING_SNAKE_CASE)     ->     Dict:
        return F'{cls._bold}{s}{cls._reset}'
  
  
  
  
  
     @classmethod
     def 		UpperCamelCase_     (       cls			,      SCREAMING_SNAKE_CASE)     ->     Union[str, Any]:
        return F'{cls._bold}{cls._red}{s}{cls._reset}'
  
  
  
  
  
     @classmethod
     def 		UpperCamelCase_     (       cls			,      SCREAMING_SNAKE_CASE)     ->     Tuple:
        return F'{cls._gray}{s}{cls._reset}'
  
  
  
  
  
  
  
  def 							_snake_case			(      __snake_case       :			List[List[Union[str, int]]]	,   __snake_case       :			List[str]      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				str      =		[max(len(str(__snake_case      )      ) for x in col      ) for col in zip(*__snake_case	,   __snake_case      )]
     _lowerCamelCase  :				Any      =		("""{{:{}}} """ * len(__snake_case      )).format(*__snake_case      )
     _lowerCamelCase  :				Optional[Any]      =		[]
     lines.append(row_format.format(*__snake_case      )      )
     lines.append(row_format.format(*["""-""" * w for w in col_widths]      )      )
     for row in rows:
        lines.append(row_format.format(*__snake_case      )      )
     return "\n".join(__snake_case      )
  
  
  
  
  class   lowercase__							:
  
  
  
  
  
     def __init__(       self			,      SCREAMING_SNAKE_CASE)     ->     List[str]:
        _lowerCamelCase  :				Any      =		args
  
  
  
  
  
  
  
  class   lowercase__							(				A_							):
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     int:
        print(
            ANSI.red(
                """ERROR! `huggingface-cli login` uses an outdated login mechanism """
                """that is not compatible with the Hugging Face Hub backend anymore. """
                """Please use `huggingface-cli login instead."""))
  
  
  
  
  
  
  
  class   lowercase__							(				A_							):
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     Tuple:
        print(
            ANSI.red(
                """WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use """
                """`huggingface-cli whoami` instead."""))
        _lowerCamelCase  :				Tuple      =		HfFolder.get_token()
        if token is None:
           print("""Not logged in""")
           exit()
        try:
           _lowerCamelCase      ,						_lowerCamelCase  :				int      =		whoami(SCREAMING_SNAKE_CASE)
           print(SCREAMING_SNAKE_CASE)
           if orgs:
              print(ANSI.bold("""orgs: """)			,      """,""".join(SCREAMING_SNAKE_CASE))
        except HTTPError as e:
           print(SCREAMING_SNAKE_CASE)
           print(ANSI.red(e.response.text))
           exit(1)
  
  
  
  
  
  
  
  class   lowercase__							(				A_							):
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     Union[str, Any]:
        print(
            ANSI.red(
                """ERROR! `transformers-cli logout` uses an outdated logout mechanism """
                """that is not compatible with the Hugging Face Hub backend anymore. """
                """Please use `huggingface-cli logout instead."""))
  
  
  
  
  
  
  
  class   lowercase__							(				A_							):
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     List[Any]:
        print(
            ANSI.red(
                """WARNING! Managing repositories through transformers-cli is deprecated. """
                """Please use `huggingface-cli` instead."""))
        _lowerCamelCase  :				Union[str, Any]      =		HfFolder.get_token()
        if token is None:
           print("""Not logged in""")
           exit(1)
        try:
           _lowerCamelCase  :				Union[str, Any]      =		subprocess.check_output(["""git""", """--version"""]).decode("""utf-8""")
           print(ANSI.gray(stdout.strip()))
        except FileNotFoundError:
           print("""Looks like you do not have git installed, please install.""")
  
        try:
           _lowerCamelCase  :				List[str]      =		subprocess.check_output(["""git-lfs""", """--version"""]).decode("""utf-8""")
           print(ANSI.gray(stdout.strip()))
        except FileNotFoundError:
           print(
               ANSI.red(
                   """Looks like you do not have git-lfs installed, please install."""
                   """ You can install from https://git-lfs.github.com/."""
                   """ Then run `git lfs install` (you only have to do this once)."""))
        print("""""")
  
        _lowerCamelCase      ,						_lowerCamelCase  :				str      =		whoami(SCREAMING_SNAKE_CASE)
        _lowerCamelCase  :				str      =		self.args.organization if self.args.organization is not None else user
        _lowerCamelCase  :				Union[str, Any]      =		F'{namespace}/{self.args.name}'
        print(F'You are about to create {ANSI.bold(SCREAMING_SNAKE_CASE)}')
  
        if not self.args.yes:
           _lowerCamelCase  :				Tuple      =		input("""Proceed? [Y/n] """).lower()
           if not (choice == "" or choice == "y" or choice == "yes"):
              print("""Abort""")
              exit()
        try:
           _lowerCamelCase  :				int      =		create_repo(SCREAMING_SNAKE_CASE			,      name=self.args.name			,      organization=self.args.organization)
        except HTTPError as e:
           print(SCREAMING_SNAKE_CASE)
           print(ANSI.red(e.response.text))
           exit(1)
        print("""\nYour repo now lives at:""")
        print(F'  {ANSI.bold(SCREAMING_SNAKE_CASE)}')
        print("""\nYou can clone it locally with the command below, and commit/push as usual.""")
        print(F'\n  git clone {url}')
        print("""""")
  
  