





'''simple docstring'''

import json
import os
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import BatchEncoding, PreTrainedTokenizer
from ...utils import logging


__lowerCAmelCase		     =logging.get_logger(__name__)

__lowerCAmelCase		     ="▁"

__lowerCAmelCase		     ={
    "vocab_file": "vocab.json",
    "spm_file": "sentencepiece.bpe.model",
    "tokenizer_config_file": "tokenizer_config.json",
}

__lowerCAmelCase		     ={
    "vocab_file": {
        "facebook/m2m100_418M": "https://huggingface.co/facebook/m2m100_418M/resolve/main/vocab.json",
        "facebook/m2m100_1.2B": "https://huggingface.co/facebook/m2m100_1.2B/resolve/main/vocab.json",
    },
    "spm_file": {
        "facebook/m2m100_418M": "https://huggingface.co/facebook/m2m100_418M/resolve/main/sentencepiece.bpe.model",
        "facebook/m2m100_1.2B": "https://huggingface.co/facebook/m2m100_1.2B/resolve/main/sentencepiece.bpe.model",
    },
    "tokenizer_config_file": {
        "facebook/m2m100_418M": "https://huggingface.co/facebook/m2m100_418M/resolve/main/tokenizer_config.json",
        "facebook/m2m100_1.2B": "https://huggingface.co/facebook/m2m100_1.2B/resolve/main/tokenizer_config.json",
    },
}

__lowerCAmelCase		     ={
    "facebook/m2m100_418M": 1024,
}

# fmt: off
__lowerCAmelCase		     ={
    "m2m100": ["af", "am", "ar", "ast", "az", "ba", "be", "bg", "bn", "br", "bs", "ca", "ceb", "cs", "cy", "da", "de", "el", "en", "es", "et", "fa", "ff", "fi", "fr", "fy", "ga", "gd", "gl", "gu", "ha", "he", "hi", "hr", "ht", "hu", "hy", "id", "ig", "ilo", "is", "it", "ja", "jv", "ka", "kk", "km", "kn", "ko", "lb", "lg", "ln", "lo", "lt", "lv", "mg", "mk", "ml", "mn", "mr", "ms", "my", "ne", "nl", "no", "ns", "oc", "or", "pa", "pl", "ps", "pt", "ro", "ru", "sd", "si", "sk", "sl", "so", "sq", "sr", "ss", "su", "sv", "sw", "ta", "th", "tl", "tn", "tr", "uk", "ur", "uz", "vi", "wo", "xh", "yi", "yo", "zh", "zu"],
    "wmt21": ["en", "ha", "is", "ja", "cs", "ru", "zh", "de"]
}






class        UpperCAmelCase     (	_SCREAMING_SNAKE_CASE    ):
 __lowercase       		=    VOCAB_FILES_NAMES
 __lowercase       		=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __lowercase       		=    PRETRAINED_VOCAB_FILES_MAP
 __lowercase       		=    ["""input_ids""", """attention_mask"""]

 __lowercase       		=    []
 __lowercase       		=    []
 def __init__(    self				:Optional[Any]						,	lowercase_				:Dict						,	lowercase_				:List[str]						,	lowercase_				:List[str]=None						,	lowercase_				:Dict=None						,	lowercase_				:Any="<s>"						,	lowercase_				:Optional[int]="</s>"						,	lowercase_				:Dict="</s>"						,	lowercase_				:Optional[Any]="<pad>"						,	lowercase_				:Tuple="<unk>"						,	lowercase_				:int="m2m100"						,	lowercase_				:Optional[Dict[str, Any]] = None						,	lowercase_				:Tuple=8						,	**lowercase_				:Any						,	)->							None:
     A__    =      {} if sp_model_kwargs is None else sp_model_kwargs

     A__    =      language_codes
     A__    =      FAIRSEQ_LANGUAGE_CODES[language_codes]
     A__    =      {lang_code: F"__{lang_code}__" for lang_code in fairseq_language_code}

     A__    =      kwargs.get("additional_special_tokens"						,	[]							)
     kwargs["additional_special_tokens"] += [
         self.get_lang_token(lowercase_							)
         for lang_code in fairseq_language_code
         if self.get_lang_token(lowercase_							) not in kwargs["additional_special_tokens"]
     ]

     super().__init__(
         src_lang=lowercase_						,	tgt_lang=lowercase_						,	bos_token=lowercase_						,	eos_token=lowercase_						,	sep_token=lowercase_						,	unk_token=lowercase_						,	pad_token=lowercase_						,	language_codes=lowercase_						,	sp_model_kwargs=self.sp_model_kwargs						,	num_madeup_words=lowercase_						,	**lowercase_						,	)

     A__    =      vocab_file
     A__    =      load_json(lowercase_							)
     A__    =      {v: k for k, v in self.encoder.items()}
     A__    =      spm_file
     A__    =      load_spm(lowercase_						,	self.sp_model_kwargs							)

     A__    =      len(self.encoder							)

     A__    =      {
         self.get_lang_token(lowercase_							): self.encoder_size + i for i, lang_code in enumerate(lowercase_							)
     }
     A__    =      {lang_code: self.encoder_size + i for i, lang_code in enumerate(lowercase_							)}
     A__    =      {v: k for k, v in self.lang_token_to_id.items()}

     A__    =      src_lang if src_lang is not None else """en"""
     A__    =      tgt_lang
     A__    =      self.get_lang_id(self._src_lang							)
     self.set_src_lang_special_tokens(self._src_lang							)

     A__    =      num_madeup_words
 @property
 def 					UpperCAmelCase_							(    self				:Dict							)->							int:
     return len(self.encoder							) + len(self.lang_token_to_id							)
 @property
 def 					UpperCAmelCase_							(    self				:Any							)->							str:
     return self._src_lang
 @src_lang.setter
 def 					UpperCAmelCase_							(    self				:List[str]						,	lowercase_				:str							)->							None:
     A__    =      new_src_lang
     self.set_src_lang_special_tokens(self._src_lang							)
 def 					UpperCAmelCase_							(    self				:str						,	lowercase_				:str							)->							List[str]:
     return self.sp_model.encode(lowercase_						,	out_type=lowercase_							)
 def 					UpperCAmelCase_							(    self				:List[Any]						,	lowercase_				:Union[str, Any]							)->							Dict:
     if token in self.lang_token_to_id:
         return self.lang_token_to_id[token]
     return self.encoder.get(lowercase_						,	self.encoder[self.unk_token]							)
 def 					UpperCAmelCase_							(    self				:Union[str, Any]						,	lowercase_				:int							)->							str:
     if index in self.id_to_lang_token:
         return self.id_to_lang_token[index]
     return self.decoder.get(lowercase_						,	self.unk_token							)
 def 					UpperCAmelCase_							(    self				:Optional[Any]						,	lowercase_				:int							)->							Optional[Any]:
     A__    =      []
     A__    =      """"""
     for token in tokens:
         # make sure that special tokens are not decoded using sentencepiece model
         if token in self.all_special_tokens:
             out_string += self.sp_model.decode(lowercase_							) + token
             A__    =      []
         else:
             current_sub_tokens.append(lowercase_							)
     out_string += self.sp_model.decode(lowercase_							)
     return out_string.strip()
 def 					UpperCAmelCase_							(    self				:List[str]						,	lowercase_				:List[int]						,	lowercase_				:Optional[List[int]] = None						,	lowercase_				:bool = False							)->							List[int]:

     if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=lowercase_						,	token_ids_a=lowercase_						,	already_has_special_tokens=lowercase_							)

     A__    =      [1] * len(self.prefix_tokens							)
     A__    =      [1] * len(self.suffix_tokens							)
     if token_ids_a is None:
         return prefix_ones + ([0] * len(lowercase_							)) + suffix_ones
     return prefix_ones + ([0] * len(lowercase_							)) + ([0] * len(lowercase_							)) + suffix_ones
 def 					UpperCAmelCase_							(    self				:Dict						,	lowercase_				:List[int]						,	lowercase_				:Optional[List[int]] = None							)->							List[int]:
     if token_ids_a is None:
         return self.prefix_tokens + token_ids_a + self.suffix_tokens
     # We don't expect to process pairs, but leave the pair logic for API consistency
     return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens
 def 					UpperCAmelCase_							(    self				:List[Any]							)->							Dict:
     A__    =      {self.convert_ids_to_tokens(lowercase_							): i for i in range(self.vocab_size							)}
     vocab.update(self.added_tokens_encoder							)
     return vocab
 def __getstate__(    self				:Optional[int]							)->							Dict:
     A__    =      self.__dict__.copy()
     A__    =      None
     return state
 def __setstate__(    self				:int						,	lowercase_				:Dict							)->							None:
     A__    =      d

     # for backward compatibility
     if not hasattr(self						,	"sp_model_kwargs"							):
         A__    =      {}

     A__    =      load_spm(self.spm_file						,	self.sp_model_kwargs							)
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	lowercase_				:str						,	lowercase_				:Optional[str] = None							)->							Tuple[str]:
     A__    =      Path(lowercase_							)
     if not save_dir.is_dir():
         raise OSError(F"{save_directory} should be a directory"							)
     A__    =      save_dir / (
         (filename_prefix + """-""" if filename_prefix else """""") + self.vocab_files_names["""vocab_file"""]
     )
     A__    =      save_dir / (
         (filename_prefix + """-""" if filename_prefix else """""") + self.vocab_files_names["""spm_file"""]
     )

     save_json(self.encoder						,	lowercase_							)

     if os.path.abspath(self.spm_file							) != os.path.abspath(lowercase_							) and os.path.isfile(self.spm_file							):
         copyfile(self.spm_file						,	lowercase_							)
     elif not os.path.isfile(self.spm_file							):
         with open(lowercase_						,	"wb"							) as fi:
             A__    =      self.sp_model.serialized_model_proto()
             fi.write(lowercase_							)

     return (str(lowercase_							), str(lowercase_							))
 def 					UpperCAmelCase_							(    self				:Any						,	lowercase_				:List[str]						,	lowercase_				:str = "en"						,	lowercase_				:Optional[List[str]] = None						,	lowercase_				:str = "ro"						,	**lowercase_				:List[Any]						,	)->							BatchEncoding:
     A__    =      src_lang
     A__    =      tgt_lang
     self.set_src_lang_special_tokens(self.src_lang							)
     return super().prepare_seqaseq_batch(lowercase_						,	lowercase_						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:List[Any]						,	lowercase_				:Optional[Any]						,	lowercase_				:Optional[str]						,	lowercase_				:Optional[str]						,	**lowercase_				:int							)->							Dict:
     if src_lang is None or tgt_lang is None:
         raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"							)
     A__    =      src_lang
     A__    =      self(lowercase_						,	add_special_tokens=lowercase_						,	**lowercase_							)
     A__    =      self.get_lang_id(lowercase_							)
     A__    =      tgt_lang_id
     return inputs
 def 					UpperCAmelCase_							(    self				:Tuple							)->							int:
     self.set_src_lang_special_tokens(self.src_lang							)
 def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							Union[str, Any]:
     self.set_tgt_lang_special_tokens(self.tgt_lang							)
 def 					UpperCAmelCase_							(    self				:List[str]						,	lowercase_				:str							)->							None:
     A__    =      self.get_lang_token(lowercase_							)
     A__    =      self.lang_token_to_id[lang_token]
     A__    =      [self.cur_lang_id]
     A__    =      [self.eos_token_id]
 def 					UpperCAmelCase_							(    self				:Union[str, Any]						,	lowercase_				:str							)->							None:
     A__    =      self.get_lang_token(lowercase_							)
     A__    =      self.lang_token_to_id[lang_token]
     A__    =      [self.cur_lang_id]
     A__    =      [self.eos_token_id]
 def 					UpperCAmelCase_							(    self				:Any						,	lowercase_				:str							)->							str:
     return self.lang_code_to_token[lang]



 def 					UpperCAmelCase_							(    self				:List[str]						,	lowercase_				:str							)->							int:
     A__    =      self.get_lang_token(lowercase_							)
     return self.lang_token_to_id[lang_token]





def 						UpperCamelCase    (							_lowerCamelCase : str						,	_lowerCamelCase : Dict[str, Any]	):
    A__    =      sentencepiece.SentencePieceProcessor(**A__	)
    spm.Load(str(A__	)	)
    return spm





def 						UpperCamelCase    (							_lowerCamelCase : str	):





    with open(A__						,	"r"	) as f:
        return json.load(A__	)





def 						UpperCamelCase    (							_lowerCamelCase : Any						,	_lowerCamelCase : str	):





    with open(A__						,	"w"	) as f:
        json.dump(A__						,	A__						,	indent=2	)










'''simple docstring'''

def 						UpperCamelCase    (							):
    A__    =      [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    A__    =      6
    A__    =      1
    A__    =      19_01

    A__    =      0

    while year < 20_01:
        day += 7

        if (year % 4 == 0 and year % 1_00 != 0) or (year % 4_00 == 0):
            if day > days_per_month[month - 1] and month != 2:
                month += 1
                A__    =      day - days_per_month[month - 2]
            elif day > 29 and month == 2:
                month += 1
                A__    =      day - 29
        else:
            if day > days_per_month[month - 1]:
                month += 1
                A__    =      day - days_per_month[month - 2]

        if month > 12:
            year += 1
            A__    =      1

        if year < 20_01 and day == 1:
            sundays += 1
    return sundays


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



