


import sys

UpperCamelCase__    							= (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)




def        lowerCAmelCase_			(					__A							)					->    Dict:







      '''simple docstring'''


      UpperCAmelCase__								=  1
      for digit in s:
            product *= int(SCREAMING_SNAKE_CASE_							)
      return product




def        lowerCAmelCase_			(					__A = N							)					->    Tuple:







      '''simple docstring'''


      UpperCAmelCase__								=  -sys.maxsize - 1
      UpperCAmelCase__								=  n[:13]
      UpperCAmelCase__								=  13
      while cur_index < len(SCREAMING_SNAKE_CASE_							) - 13:
            if int(n[cur_index]							) >= int(substr[0]							):
                  UpperCAmelCase__								=  substr[1:] + n[cur_index]
                  cur_index += 1
            else:
                  UpperCAmelCase__								=  max(SCREAMING_SNAKE_CASE_,  str_eval(SCREAMING_SNAKE_CASE_							)							)
                  UpperCAmelCase__								=  n[cur_index : cur_index + 13]
                  cur_index += 13
      return largest_product


if __name__ == "__main__":
      print(f'''{solution() = }''')




from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml





class 					A							(    yaml.SafeLoader					):


   def       lowercase_				(self					:						Tuple	,  __UpperCAmelCase					:						str		)						->    Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  [self.constructed_objects[key_node] for key_node, _ in node.value]
         UpperCAmelCase__								=  [tuple(__UpperCAmelCase		) if isinstance(__UpperCAmelCase	,  __UpperCAmelCase		) else key for key in keys]
         UpperCAmelCase__								=  Counter(__UpperCAmelCase		)
         UpperCAmelCase__								=  [key for key in counter if counter[key] > 1]
         if duplicate_keys:
               raise TypeError(f"""Got duplicate yaml keys: {duplicate_keys}"""		)





   def       lowercase_				(self					:						Dict	,  __UpperCAmelCase					:						Dict	,  __UpperCAmelCase					:						Any=False		)						->    Union[str, Any]:
         """simple docstring"""



         UpperCAmelCase__								=  super().construct_mapping(__UpperCAmelCase	,  deep=__UpperCAmelCase		)
         self._check_no_duplicates_on_constructed_node(__UpperCAmelCase		)
         return mapping




def        lowerCAmelCase_			(					__A							)					->    Tuple[Optional[str], str]:







      '''simple docstring'''


      UpperCAmelCase__								=  list(readme_content.splitlines()							)
      if full_content and full_content[0] == "---" and "---" in full_content[1:]:
            UpperCAmelCase__								=  full_content[1:].index("---"							) + 1
            UpperCAmelCase__								=  "\n".join(full_content[1:sep_idx]							)
            return yamlblock, "\n".join(full_content[sep_idx + 1 :]							)

      return None, "\n".join(__A							)





class 					A							(    UpperCAmelCase_					):
   # class attributes
   __UpperCAmelCase			:			Optional[Any]              =      {'train_eval_index'}  # train-eval-index in the YAML metadata


   @classmethod
   def       lowercase_				(cls					:						List[str]	,  __UpperCAmelCase					:						Path		)						->    "DatasetMetadata":
         """simple docstring"""



         with open(__UpperCAmelCase	,  encoding="utf-8"		) as readme_file:
               UpperCAmelCase__		,				UpperCAmelCase__								=  _split_yaml_from_readme(readme_file.read()		)
         if yaml_string is not None:
               return cls.from_yaml_string(__UpperCAmelCase		)
         else:
               return cls()


   def       lowercase_				(self					:						int	,  __UpperCAmelCase					:						Path		)						->    str:
         """simple docstring"""



         if path.exists():
               with open(__UpperCAmelCase	,  encoding="utf-8"		) as readme_file:
                     UpperCAmelCase__								=  readme_file.read()
         else:
               UpperCAmelCase__								=  None
         UpperCAmelCase__								=  self._to_readme(__UpperCAmelCase		)
         with open(__UpperCAmelCase	,  "w"	,  encoding="utf-8"		) as readme_file:
               readme_file.write(__UpperCAmelCase		)


   def       lowercase_				(self					:						str	,  __UpperCAmelCase					:						Optional[str] = None		)						->    str:
         """simple docstring"""



         if readme_content is not None:
               UpperCAmelCase__		,				UpperCAmelCase__								=  _split_yaml_from_readme(__UpperCAmelCase		)
               UpperCAmelCase__								=  "---\n" + self.to_yaml_string() + "---\n" + content
         else:
               UpperCAmelCase__								=  "---\n" + self.to_yaml_string() + "---\n"
         return full_content


   @classmethod
   def       lowercase_				(cls					:						Optional[int]	,  __UpperCAmelCase					:						str		)						->    "DatasetMetadata":
         """simple docstring"""



         UpperCAmelCase__								=  yaml.load(__UpperCAmelCase	,  Loader=_NoDuplicateSafeLoader		) or {}

         # Convert the YAML keys to DatasetMetadata fields
         UpperCAmelCase__								=  {
             (key.replace("-"	,  "_"		) if key.replace("-"	,  "_"		) in cls._FIELDS_WITH_DASHES else key): value
             for key, value in metadata_dict.items()
         }
         return cls(**__UpperCAmelCase		)





   def       lowercase_				(self					:						List[str]		)						->    str:
         """simple docstring"""



         return yaml.safe_dump(
             {
                 (key.replace("_"	,  "-"		) if key in self._FIELDS_WITH_DASHES else key): value
                 for key, value in self.items()
             }	,  sort_keys=__UpperCAmelCase	,  allow_unicode=__UpperCAmelCase	,  encoding="utf-8"	,  ).decode("utf-8"		)




UpperCamelCase__    							= {
    'image-classification': [],
    'translation': [],
    'image-segmentation': [],
    'fill-mask': [],
    'automatic-speech-recognition': [],
    'token-classification': [],
    'sentence-similarity': [],
    'audio-classification': [],
    'question-answering': [],
    'summarization': [],
    'zero-shot-classification': [],
    'table-to-text': [],
    'feature-extraction': [],
    'other': [],
    'multiple-choice': [],
    'text-classification': [],
    'text-to-image': [],
    'text2text-generation': [],
    'zero-shot-image-classification': [],
    'tabular-classification': [],
    'tabular-regression': [],
    'image-to-image': [],
    'tabular-to-text': [],
    'unconditional-image-generation': [],
    'text-retrieval': [],
    'text-to-speech': [],
    'object-detection': [],
    'audio-to-audio': [],
    'text-generation': [],
    'conversational': [],
    'table-question-answering': [],
    'visual-question-answering': [],
    'image-to-text': [],
    'reinforcement-learning': [],
    'voice-activity-detection': [],
    'time-series-forecasting': [],
    'document-question-answering': [],
}


if __name__ == "__main__":
      from argparse import ArgumentParser

      UpperCamelCase__    							= ArgumentParser(usage='Validate the yaml metadata block of a README.md file.')
      ap.add_argument('readme_filepath')
      UpperCamelCase__    							= ap.parse_args()

      UpperCamelCase__    							= Path(args.readme_filepath)
      UpperCamelCase__    							= DatasetMetadata.from_readme(readme_filepath)
      print(dataset_metadata)
      dataset_metadata.to_readme(readme_filepath)



