






'''simple docstring'''

import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


SCREAMING_SNAKE_CASE__											=     '\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

SCREAMING_SNAKE_CASE__											=     '\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


SCREAMING_SNAKE_CASE__											=     '\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'







def 					lowercase__				(   __UpperCamelCase					)->				Optional[Any]:

      def remove_articles(__UpperCamelCase					):
            UpperCamelCase       						=      re.compile(R"""\b(a|an|the)\b"""	,		re.UNICODE					)
            return re.sub(__UpperCamelCase	,		""" """	,		__UpperCamelCase					)

      def white_space_fix(__UpperCamelCase					):
            return " ".join(text.split()					)

      def remove_punc(__UpperCamelCase					):
            UpperCamelCase       						=      set(string.punctuation					)
            return "".join(ch for ch in text if ch not in exclude					)

      def lower(__UpperCamelCase					):
            return text.lower()

      return white_space_fix(remove_articles(remove_punc(lower(__UpperCamelCase					)					)					)					)







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase					)->				str:
      return int(normalize_answer(__UpperCamelCase					) == normalize_answer(__UpperCamelCase					)					)







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase					)->				Optional[Any]:
      UpperCamelCase       						=      [any(compute_exact(__UpperCamelCase	,		__UpperCamelCase					) for ref in refs					) for pred, refs in zip(__UpperCamelCase	,		__UpperCamelCase					)]
      return (sum(__UpperCamelCase					) / len(__UpperCamelCase					)) * 100







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)->				int:
      UpperCamelCase       						=      [rgram for rgrams in rgramslist for rgram in rgrams]
      UpperCamelCase       						=      Counter(__UpperCamelCase					)

      UpperCamelCase       						=      Counter(__UpperCamelCase					)
      UpperCamelCase       						=      Counter()
      for sgram, scount in sgramcounter.items():
            UpperCamelCase       						=      scount * numref

      UpperCamelCase       						=      Counter(__UpperCamelCase					)
      UpperCamelCase       						=      Counter()
      for cgram, ccount in cgramcounter.items():
            UpperCamelCase       						=      ccount * numref

      # KEEP
      UpperCamelCase       						=      sgramcounter_rep & cgramcounter_rep
      UpperCamelCase       						=      keepgramcounter_rep & rgramcounter
      UpperCamelCase       						=      sgramcounter_rep & rgramcounter

      UpperCamelCase       						=      0
      UpperCamelCase       						=      0
      for keepgram in keepgramcountergood_rep:
            keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
            # Fix an alleged bug [2] in the keep score computation.
            # keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
            keeptmpscorea += keepgramcountergood_rep[keepgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      #      a target exactly.
      UpperCamelCase       						=      1
      UpperCamelCase       						=      1
      if len(__UpperCamelCase					) > 0:
            UpperCamelCase       						=      keeptmpscorea / len(__UpperCamelCase					)
      if len(__UpperCamelCase					) > 0:
            # Fix an alleged bug [2] in the keep score computation.
            # keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
            UpperCamelCase       						=      keeptmpscorea / sum(keepgramcounterall_rep.values()					)
      UpperCamelCase       						=      0
      if keepscore_precision > 0 or keepscore_recall > 0:
            UpperCamelCase       						=      2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

      # DELETION
      UpperCamelCase       						=      sgramcounter_rep - cgramcounter_rep
      UpperCamelCase       						=      delgramcounter_rep - rgramcounter
      UpperCamelCase       						=      sgramcounter_rep - rgramcounter
      UpperCamelCase       						=      0
      UpperCamelCase       						=      0
      for delgram in delgramcountergood_rep:
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      UpperCamelCase       						=      1
      if len(__UpperCamelCase					) > 0:
            UpperCamelCase       						=      deltmpscorea / len(__UpperCamelCase					)

      # ADDITION
      UpperCamelCase       						=      set(__UpperCamelCase					) - set(__UpperCamelCase					)
      UpperCamelCase       						=      set(__UpperCamelCase					) & set(__UpperCamelCase					)
      UpperCamelCase       						=      set(__UpperCamelCase					) - set(__UpperCamelCase					)

      UpperCamelCase       						=      0
      for addgram in addgramcountergood:
            addtmpscore += 1

      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      UpperCamelCase       						=      1
      UpperCamelCase       						=      1
      if len(__UpperCamelCase					) > 0:
            UpperCamelCase       						=      addtmpscore / len(__UpperCamelCase					)
      if len(__UpperCamelCase					) > 0:
            UpperCamelCase       						=      addtmpscore / len(__UpperCamelCase					)
      UpperCamelCase       						=      0
      if addscore_precision > 0 or addscore_recall > 0:
            UpperCamelCase       						=      2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

      return (keepscore, delscore_precision, addscore)







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)->				int:
      UpperCamelCase       						=      len(__UpperCamelCase					)

      UpperCamelCase       						=      ssent.split(""" """					)
      UpperCamelCase       						=      csent.split(""" """					)
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []

      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      UpperCamelCase       						=      []
      for rsent in rsents:
            UpperCamelCase       						=      rsent.split(""" """					)
            UpperCamelCase       						=      []
            UpperCamelCase       						=      []
            UpperCamelCase       						=      []
            ragramslist.append(__UpperCamelCase					)
            for i in range(0	,		len(__UpperCamelCase					) - 1					):
                  if i < len(__UpperCamelCase					) - 1:
                        UpperCamelCase       						=      ragrams[i] + """ """ + ragrams[i + 1]
                        ragrams.append(__UpperCamelCase					)
                  if i < len(__UpperCamelCase					) - 2:
                        UpperCamelCase       						=      ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2]
                        ragrams.append(__UpperCamelCase					)
                  if i < len(__UpperCamelCase					) - 3:
                        UpperCamelCase       						=      ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2] + """ """ + ragrams[i + 3]
                        ragrams.append(__UpperCamelCase					)
            ragramslist.append(__UpperCamelCase					)
            ragramslist.append(__UpperCamelCase					)
            ragramslist.append(__UpperCamelCase					)

      for i in range(0	,		len(__UpperCamelCase					) - 1					):
            if i < len(__UpperCamelCase					) - 1:
                  UpperCamelCase       						=      sagrams[i] + """ """ + sagrams[i + 1]
                  sagrams.append(__UpperCamelCase					)
            if i < len(__UpperCamelCase					) - 2:
                  UpperCamelCase       						=      sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2]
                  sagrams.append(__UpperCamelCase					)
            if i < len(__UpperCamelCase					) - 3:
                  UpperCamelCase       						=      sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2] + """ """ + sagrams[i + 3]
                  sagrams.append(__UpperCamelCase					)

      for i in range(0	,		len(__UpperCamelCase					) - 1					):
            if i < len(__UpperCamelCase					) - 1:
                  UpperCamelCase       						=      cagrams[i] + """ """ + cagrams[i + 1]
                  cagrams.append(__UpperCamelCase					)
            if i < len(__UpperCamelCase					) - 2:
                  UpperCamelCase       						=      cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2]
                  cagrams.append(__UpperCamelCase					)
            if i < len(__UpperCamelCase					) - 3:
                  UpperCamelCase       						=      cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2] + """ """ + cagrams[i + 3]
                  cagrams.append(__UpperCamelCase					)

      ((UpperCamelCase)						,(UpperCamelCase)						,(UpperCamelCase))       						=      SARIngram(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)
      ((UpperCamelCase)						,(UpperCamelCase)						,(UpperCamelCase))       						=      SARIngram(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)
      ((UpperCamelCase)						,(UpperCamelCase)						,(UpperCamelCase))       						=      SARIngram(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)
      ((UpperCamelCase)						,(UpperCamelCase)						,(UpperCamelCase))       						=      SARIngram(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)
      UpperCamelCase       						=      sum([keepascore, keepascore, keepascore, keepascore]					) / 4
      UpperCamelCase       						=      sum([delascore, delascore, delascore, delascore]					) / 4
      UpperCamelCase       						=      sum([addascore, addascore, addascore, addascore]					) / 4
      UpperCamelCase       						=      (avgkeepscore + avgdelscore + avgaddscore) / 3
      return finalscore







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase = True	,		__UpperCamelCase = "13a"	,		__UpperCamelCase = True					)->				Union[str, Any]:
      # Normalization is requried for the ASSET dataset (one of the primary
      # datasets in sentence simplification) to allow using space
      # to split the sentence. Even though Wiki-Auto and TURK datasets,
      # do not require normalization, we do it for consistency.
      # Code adapted from the EASSE library [1] written by the authors of the ASSET dataset.
      # [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7

      if lowercase:
            UpperCamelCase       						=      sentence.lower()

      if tokenizer in ["13a", "intl"]:
            if version.parse(sacrebleu.__version__					).major >= 2:
                  UpperCamelCase       						=      sacrebleu.metrics.bleu._get_tokenizer(__UpperCamelCase					)()(__UpperCamelCase					)
            else:
                  UpperCamelCase       						=      sacrebleu.TOKENIZERS[tokenizer]()(__UpperCamelCase					)
      elif tokenizer == "moses":
            UpperCamelCase       						=      sacremoses.MosesTokenizer().tokenize(__UpperCamelCase	,		return_str=__UpperCamelCase	,		escape=__UpperCamelCase					)
      elif tokenizer == "penn":
            UpperCamelCase       						=      sacremoses.MosesTokenizer().penn_tokenize(__UpperCamelCase	,		return_str=__UpperCamelCase					)
      else:
            UpperCamelCase       						=      sentence

      if not return_str:
            UpperCamelCase       						=      normalized_sent.split()

      return normalized_sent







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)->				List[Any]:
      if not (len(__UpperCamelCase					) == len(__UpperCamelCase					) == len(__UpperCamelCase					)):
            raise ValueError("""Sources length must match predictions and references lengths."""					)
      UpperCamelCase       						=      0
      for src, pred, refs in zip(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					):
            sari_score += SARIsent(normalize(__UpperCamelCase					)	,		normalize(__UpperCamelCase					)	,		[normalize(__UpperCamelCase					) for sent in refs]					)
      UpperCamelCase       						=      sari_score / len(__UpperCamelCase					)
      return 100 * sari_score







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase="exp"	,		__UpperCamelCase=None	,		__UpperCamelCase=False	,		__UpperCamelCase=False	,		__UpperCamelCase=False	,		)->				List[Any]:
      UpperCamelCase       						=      len(references[0]					)
      if any(len(__UpperCamelCase					) != references_per_prediction for refs in references					):
            raise ValueError("""Sacrebleu requires the same number of references for each prediction"""					)
      UpperCamelCase       						=      [[refs[i] for refs in references] for i in range(__UpperCamelCase					)]
      UpperCamelCase       						=      sacrebleu.corpus_bleu(
          __UpperCamelCase	,		__UpperCamelCase	,		smooth_method=__UpperCamelCase	,		smooth_value=__UpperCamelCase	,		force=__UpperCamelCase	,		lowercase=__UpperCamelCase	,		use_effective_order=__UpperCamelCase	,		)
      return output.score






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

  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        return datasets.MetricInfo(
            description=_DESCRIPTION    ,	citation=_CITATION    ,	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/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py""",
                """https://github.com/cocoxu/simplification/blob/master/SARI.py""",
                """https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py""",
                """https://github.com/mjpost/sacreBLEU""",
            ]    ,	reference_urls=[
                """https://www.aclweb.org/anthology/Q16-1029.pdf""",
                """https://github.com/mjpost/sacreBLEU""",
                """https://en.wikipedia.org/wiki/BLEU""",
                """https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213""",
            ]    ,	)


  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   Union[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      {}
        result.update({"""sari""": compute_sari(sources=_SCREAMING_SNAKE_CASE    ,	predictions=_SCREAMING_SNAKE_CASE    ,	references=_SCREAMING_SNAKE_CASE   )}   )
        result.update({"""sacrebleu""": compute_sacrebleu(predictions=_SCREAMING_SNAKE_CASE    ,	references=_SCREAMING_SNAKE_CASE   )}   )
        result.update({"""exact""": compute_em(predictions=_SCREAMING_SNAKE_CASE    ,	references=_SCREAMING_SNAKE_CASE   )}   )
        return result








'''simple docstring'''

from math import sqrt







def 					lowercase__				(   __UpperCamelCase					)->				int:
      UpperCamelCase       						=      0
      for i in range(1	,		int(sqrt(__UpperCamelCase					) + 1					)					):
            if n % i == 0 and i != sqrt(__UpperCamelCase					):
                  total += i + n // i
            elif i == sqrt(__UpperCamelCase					):
                  total += i
      return total - n







def 					lowercase__				(   __UpperCamelCase = 10000					)->				int:
      UpperCamelCase       						=      sum(
          i
          for i in range(1	,		__UpperCamelCase					)
          if sum_of_divisors(sum_of_divisors(__UpperCamelCase					)					) == i and sum_of_divisors(__UpperCamelCase					) != i					)
      return total


if __name__ == "__main__":
     print(solution(int(str(input()).strip())))
