import os
import re
import shutil
from argparse import ArgumentParser, Namespace

from datasets.commands import BaseDatasetsCLICommand
from datasets.utils.logging import get_logger


A     :  Dict					     =       "<<<<<<< This should probably be modified because it mentions: "

A     :  Any					     =       "=======\n>>>>>>>\n"

A     :  Tuple					     =       [
    "TextEncoderConfig",
    "ByteTextEncoder",
    "SubwordTextEncoder",
    "encoder_config",
    "maybe_build_from_corpus",
    "manual_dir",
]

A     :  int					     =       [
    # (pattern, replacement)
    # Order is important here for some replacements
    (r"tfds\.core", r"datasets"),
    (r"tf\.io\.gfile\.GFile", r"open"),
    (r"tf\.([\w\d]+)", r"datasets.Value(\'\1\')"),
    (r"tfds\.features\.Text\(\)", r"datasets.Value(\'string\')"),
    (r"tfds\.features\.Text\(", r"datasets.Value(\'string\'),"),
    (r"features\s*=\s*tfds.features.FeaturesDict\(", r"features=datasets.Features("),
    (r"tfds\.features\.FeaturesDict\(", r"dict("),
    (r"The TensorFlow Datasets Authors", r"The TensorFlow Datasets Authors and the HuggingFace Datasets Authors"),
    (r"tfds\.", r"datasets."),
    (r"dl_manager\.manual_dir", r"self.config.data_dir"),
    (r"self\.builder_config", r"self.config"),
]

def      a__ (		__UpperCamelCase				):
      return ConvertCommand(args.tfds_path     ,      args.datasets_directory				)





class   lowerCamelCase					(__a					):
  """simple docstring"""







  @staticmethod
  def    __A     (							__magic_name__ :       int   )  ->	Dict:
        SCREAMING_SNAKE_CASE_          =  parser.add_parser(
            "convert"  ,     help="Convert a TensorFlow Datasets dataset to a HuggingFace Datasets dataset."  ,     )
        train_parser.add_argument(
            "--tfds_path"  ,     type=lowerCAmelCase_  ,     required=lowerCAmelCase_  ,     help="Path to a TensorFlow Datasets folder to convert or a single tfds file to convert."  ,     )
        train_parser.add_argument(
            "--datasets_directory"  ,     type=lowerCAmelCase_  ,     required=lowerCAmelCase_  ,     help="Path to the HuggingFace Datasets folder."   )
        train_parser.set_defaults(func=lowerCAmelCase_   )







  def __init__(							self :       int  ,     __magic_name__ :       List[Any]  ,     __magic_name__ :       Tuple  ,     *__magic_name__ :       Optional[int]   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  get_logger("datasets-cli/converting"   )

        SCREAMING_SNAKE_CASE_          =  tfds_path
        SCREAMING_SNAKE_CASE_          =  datasets_directory







  def    __A     (							self :       List[Any]   )  ->	List[str]:







        if os.path.isdir(self._tfds_path   ):
              SCREAMING_SNAKE_CASE_          =  os.path.abspath(self._tfds_path   )
        elif os.path.isfile(self._tfds_path   ):
              SCREAMING_SNAKE_CASE_          =  os.path.dirname(self._tfds_path   )
        else:
              raise ValueError("--tfds_path is neither a directory nor a file. Please check path."   )

        SCREAMING_SNAKE_CASE_          =  os.path.abspath(self._datasets_directory   )

        self._logger.info(F'''Converting datasets from {abs_tfds_path} to {abs_datasets_path}'''   )

        SCREAMING_SNAKE_CASE_          =  []
        SCREAMING_SNAKE_CASE_          =  []
        SCREAMING_SNAKE_CASE_          =  {}

        if os.path.isdir(self._tfds_path   ):
              SCREAMING_SNAKE_CASE_          =  os.listdir(lowerCAmelCase_   )
        else:
              SCREAMING_SNAKE_CASE_          =  [os.path.basename(self._tfds_path   )]

        for f_name in file_names:
              self._logger.info(F'''Looking at file {f_name}'''   )
              SCREAMING_SNAKE_CASE_          =  os.path.join(lowerCAmelCase_  ,     lowerCAmelCase_   )
              SCREAMING_SNAKE_CASE_          =  os.path.join(lowerCAmelCase_  ,     lowerCAmelCase_   )

              if not os.path.isfile(lowerCAmelCase_   ) or "__init__" in f_name or "_test" in f_name or ".py" not in f_name:
                    self._logger.info("Skipping file"   )
                    continue

              with open(lowerCAmelCase_  ,     encoding="utf-8"   ) as f:
                    SCREAMING_SNAKE_CASE_          =  f.readlines()

              SCREAMING_SNAKE_CASE_          =  []
              SCREAMING_SNAKE_CASE_          =  False
              SCREAMING_SNAKE_CASE_          =  False
              SCREAMING_SNAKE_CASE_          =  []
              for line in lines:
                    SCREAMING_SNAKE_CASE_          =  line

                    # Convert imports
                    if "import tensorflow.compat.v2 as tf" in out_line:
                          continue
                    elif "@tfds.core" in out_line:
                          continue
                    elif "builder=self" in out_line:
                          continue
                    elif "import tensorflow_datasets.public_api as tfds" in out_line:
                          SCREAMING_SNAKE_CASE_          =  "import datasets\n"
                    elif "import tensorflow" in out_line:
                          # order is important here
                          SCREAMING_SNAKE_CASE_          =  ""
                          continue
                    elif "from absl import logging" in out_line:
                          SCREAMING_SNAKE_CASE_          =  "from datasets import logging\n"
                    elif "getLogger" in out_line:
                          SCREAMING_SNAKE_CASE_          =  out_line.replace("getLogger"  ,     "get_logger"   )
                    elif any(expression in out_line for expression in TO_HIGHLIGHT   ):
                          SCREAMING_SNAKE_CASE_          =  True
                          SCREAMING_SNAKE_CASE_          =  list(filter(lambda __magic_name__   : e in out_line  ,     lowerCAmelCase_   )   )
                          out_lines.append(HIGHLIGHT_MESSAGE_PRE + str(lowerCAmelCase_   ) + "\n"   )
                          out_lines.append(lowerCAmelCase_   )
                          out_lines.append(lowerCAmelCase_   )
                          continue
                    else:
                          for pattern, replacement in TO_CONVERT:
                                SCREAMING_SNAKE_CASE_          =  re.sub(lowerCAmelCase_  ,     lowerCAmelCase_  ,     lowerCAmelCase_   )

                # Take care of saving utilities (to later move them together with main script)
                    if "tensorflow_datasets" in out_line:
                          SCREAMING_SNAKE_CASE_          =  re.match(r"from\stensorflow_datasets.*import\s([^\.\r\n]+)"  ,     lowerCAmelCase_   )
                          tfds_imports.extend(imp.strip() for imp in match.group(1   ).split(","   )   )
                          SCREAMING_SNAKE_CASE_          =  "from . import " + match.group(1   )

                    # Check we have not forget anything
                    if "tf." in out_line or "tfds." in out_line or "tensorflow_datasets" in out_line:
                          raise ValueError(F'''Error converting {out_line.strip()}'''   )

                    if "GeneratorBasedBuilder" in out_line or "BeamBasedBuilder" in out_line:
                          SCREAMING_SNAKE_CASE_          =  True
                    out_lines.append(lowerCAmelCase_   )

              if is_builder or "wmt" in f_name:
                    # We create a new directory for each dataset
                    SCREAMING_SNAKE_CASE_          =  f_name.replace(".py"  ,     ""   )
                    SCREAMING_SNAKE_CASE_          =  os.path.join(lowerCAmelCase_  ,     lowerCAmelCase_   )
                    SCREAMING_SNAKE_CASE_          =  os.path.join(lowerCAmelCase_  ,     lowerCAmelCase_   )
                    os.makedirs(lowerCAmelCase_  ,     exist_ok=lowerCAmelCase_   )
                    self._logger.info(F'''Adding directory {output_dir}'''   )
                    imports_to_builder_map.update({imp: output_dir for imp in tfds_imports}   )
              else:
                    # Utilities will be moved at the end
                    utils_files.append(lowerCAmelCase_   )

              if needs_manual_update:
                    with_manual_update.append(lowerCAmelCase_   )

              with open(lowerCAmelCase_  ,     "w"  ,     encoding="utf-8"   ) as f:
                    f.writelines(lowerCAmelCase_   )
              self._logger.info(F'''Converted in {output_file}'''   )

        for utils_file in utils_files:
              try:
                    SCREAMING_SNAKE_CASE_          =  os.path.basename(lowerCAmelCase_   )
                    SCREAMING_SNAKE_CASE_          =  imports_to_builder_map[f_name.replace(".py"  ,     ""   )]
                    self._logger.info(F'''Moving {dest_folder} to {utils_file}'''   )
                    shutil.copy(lowerCAmelCase_  ,     lowerCAmelCase_   )
              except KeyError:
                    self._logger.error(F'''Cannot find destination folder for {utils_file}. Please copy manually.'''   )

        if with_manual_update:
              for file_path in with_manual_update:
                    self._logger.warning(
                        F'''You need to manually update file {file_path} to remove configurations using \'TextEncoderConfig\'.'''   )



from math import factorial


def      a__ (		__UpperCamelCase = 1_0_0				):
      return sum(int(__UpperCamelCase				) for x in str(factorial(__UpperCamelCase				)				)				)


if __name__ == "__main__":
      print(solution(int(input("Enter the Number: ").strip())))


