




import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets


@contextmanager
def 		_lowerCamelCase				(					)			->		Union[str, Any]:





  """simple docstring"""





  def filter_log(UpperCamelCase							):
    return False if "This IS expected if you are initializing" in record.msg else True

  _lowercase: List[str]						     =    datasets.utils.logging.get_logger('transformers.modeling_utils'							)
  logger.addFilter(lowercase__							)
  try:
    yield
  finally:
    logger.removeFilter(lowercase__							)


UpperCAmelCase__						:       Optional[Any]							=    '\\n@inproceedings{bert-score,\n  title={BERTScore: Evaluating Text Generation with BERT},\n  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},\n  booktitle={International Conference on Learning Representations},\n  year={2020},\n  url={https://openreview.net/forum?id=SkeHuCVFDr}\n}\n'

UpperCAmelCase__						:       Optional[int]							=    '\\nBERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference\nsentences by cosine similarity.\nIt has been shown to correlate with human judgment on sentence-level and system-level evaluation.\nMoreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language\ngeneration tasks.\n\nSee the project\'s README at https://github.com/Tiiiger/bert_score#readme for more information.\n'

UpperCAmelCase__						:       Optional[int]							=    '\nBERTScore Metrics with the hashcode from a source against one or more references.\n\nArgs:\n    predictions (list of str): Prediction/candidate sentences.\n    references (list of str or list of list of str): Reference sentences.\n    lang (str): Language of the sentences; required (e.g. \'en\').\n    model_type (str): Bert specification, default using the suggested\n        model for the target language; has to specify at least one of\n        `model_type` or `lang`.\n    num_layers (int): The layer of representation to use,\n        default using the number of layers tuned on WMT16 correlation data.\n    verbose (bool): Turn on intermediate status update.\n    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.\n    device (str): On which the contextual embedding model will be allocated on.\n        If this argument is None, the model lives on cuda:0 if cuda is available.\n    nthreads (int): Number of threads.\n    batch_size (int): Bert score processing batch size,\n        at least one of `model_type` or `lang`. `lang` needs to be\n        specified when `rescale_with_baseline` is True.\n    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.\n    baseline_path (str): Customized baseline file.\n    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.\n\nReturns:\n    precision: Precision.\n    recall: Recall.\n    f1: F1 score.\n    hashcode: Hashcode of the library.\n\nExamples:\n\n    >>> predictions = [\"hello there\", \"general kenobi\"]\n    >>> references = [\"hello there\", \"general kenobi\"]\n    >>> bertscore = datasets.load_metric(\"bertscore\")\n    >>> results = bertscore.compute(predictions=predictions, references=references, lang=\"en\")\n    >>> print([round(v, 2) for v in results[\"f1\"]])\n    [1.0, 1.0]\n'





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,					_KWARGS_DESCRIPTION   )
class      UpperCAmelCase						(			datasets.Metric   ):






   def  _a						(	self   :       Tuple     )->			Tuple:
     return datasets.MetricInfo(
         description=_DESCRIPTION						,					citation=_CITATION						,					homepage='https://github.com/Tiiiger/bert_score'						,					inputs_description=_KWARGS_DESCRIPTION						,					features=datasets.Features(
             {
                 'predictions': datasets.Value('string'						,					id='sequence'     ),
                 'references': datasets.Sequence(datasets.Value('string'						,					id='sequence'     )						,					id='references'     ),
             }     )						,					codebase_urls=['https://github.com/Tiiiger/bert_score']						,					reference_urls=[
             'https://github.com/Tiiiger/bert_score',
             'https://arxiv.org/abs/1904.09675',
         ]						,					)






   def  _a						(	self   :       Any						,					UpperCamelCase_   :       Tuple						,					UpperCamelCase_   :       Dict						,					UpperCamelCase_   :       List[str]=None						,					UpperCamelCase_   :       Optional[int]=None						,					UpperCamelCase_   :       List[Any]=None						,					UpperCamelCase_   :       int=False						,					UpperCamelCase_   :       Optional[int]=False						,					UpperCamelCase_   :       Tuple=None						,					UpperCamelCase_   :       Dict=64						,					UpperCamelCase_   :       List[str]=4						,					UpperCamelCase_   :       str=False						,					UpperCamelCase_   :       Tuple=False						,					UpperCamelCase_   :       int=None						,					UpperCamelCase_   :       Any=False						,					)->			Optional[int]:
     _lowercase: Any						     =    bert_score.utils.get_hash
     _lowercase: List[str]						     =    bert_score.BERTScorer

     if version.parse(bert_score.__version__     ) >= version.parse('0.3.10'     ):
       _lowercase: List[str]						     =    functools.partial(UpperCamelCase_						,					use_fast_tokenizer=UpperCamelCase_     )
       _lowercase: List[str]						     =    functools.partial(UpperCamelCase_						,					use_fast_tokenizer=UpperCamelCase_     )
     elif use_fast_tokenizer:
       raise ImportWarning(
           'To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn\'t match this condition.\n'
           'You can install it with `pip install \"bert-score>=0.3.10\"`.'     )

     if model_type is None:
       assert lang is not None, "either lang or model_type should be specified"
       _lowercase: Optional[Any]						     =    bert_score.utils.langamodel[lang.lower()]

     if num_layers is None:
       _lowercase: List[str]						     =    bert_score.utils.modelalayers[model_type]

     _lowercase: List[Any]						     =    get_hash(
         model=UpperCamelCase_						,					num_layers=UpperCamelCase_						,					idf=UpperCamelCase_						,					rescale_with_baseline=UpperCamelCase_						,					use_custom_baseline=baseline_path is not None						,					)

     with filter_logging_context():
       if not hasattr(self						,					'cached_bertscorer'     ) or self.cached_bertscorer.hash != hashcode:
         _lowercase: Union[str, Any]						     =    scorer(
             model_type=UpperCamelCase_						,					num_layers=UpperCamelCase_						,					batch_size=UpperCamelCase_						,					nthreads=UpperCamelCase_						,					all_layers=UpperCamelCase_						,					idf=UpperCamelCase_						,					device=UpperCamelCase_						,					lang=UpperCamelCase_						,					rescale_with_baseline=UpperCamelCase_						,					baseline_path=UpperCamelCase_						,					)

     (_lowercase): Dict						     =    self.cached_bertscorer.score(
         cands=UpperCamelCase_						,					refs=UpperCamelCase_						,					verbose=UpperCamelCase_						,					batch_size=UpperCamelCase_						,					)
     _lowercase: Tuple						     =    {
         "precision": P.tolist(),
         "recall": R.tolist(),
         "f1": F.tolist(),
         "hashcode": hashcode,
     }
     return output_dict






   def  _a						(	self   :       Union[str, Any]						,					UpperCamelCase_   :       Optional[int]=None						,					UpperCamelCase_   :       Union[str, Any]=None						,					**UpperCamelCase_   :       Any     )->			Optional[Any]:







     if references is not None:
       _lowercase: List[Any]						     =    [[ref] if isinstance(UpperCamelCase_						,					UpperCamelCase_     ) else ref for ref in references]
     super().add_batch(predictions=UpperCamelCase_						,					references=UpperCamelCase_						,					**UpperCamelCase_     )






   def  _a						(	self   :       int						,					UpperCamelCase_   :       Optional[int]=None						,					UpperCamelCase_   :       str=None						,					**UpperCamelCase_   :       int     )->			Tuple:







     if isinstance(UpperCamelCase_						,					UpperCamelCase_     ):
       _lowercase: Tuple						     =    [reference]
     super().add(prediction=UpperCamelCase_						,					reference=UpperCamelCase_						,					**UpperCamelCase_     )






import math


def 		_lowerCamelCase				(					UpperCamelCase							)			->		int:





  """simple docstring"""





  return sum(int(UpperCamelCase							) for digit in str(UpperCamelCase							)							)


def 		_lowerCamelCase				(					UpperCamelCase = 30							)			->		int:





  """simple docstring"""





  _lowercase: int						     =    []
  for digit in range(2					,     100							):
    for power in range(2					,     100							):
      _lowercase: int						     =    int(math.pow(UpperCamelCase					,     UpperCamelCase							)							)
      if digit == digit_sum(UpperCamelCase							):
        digit_to_powers.append(UpperCamelCase							)

  digit_to_powers.sort()
  return digit_to_powers[n - 1]


if __name__ == "__main__":
   print(solution())
