





'''simple docstring'''

import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


__lowerCAmelCase		     =logging.get_logger(__name__)

__lowerCAmelCase		     ="▁"

__lowerCAmelCase		     ={"vocab_file": "sentencepiece.bpe.model"}

__lowerCAmelCase		     ={
    "vocab_file": {
        "facebook/mbart-large-50-one-to-many-mmt": (
            "https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model"
        ),
    }
}

__lowerCAmelCase		     ={
    "facebook/mbart-large-50-one-to-many-mmt": 1024,
}

# fmt: off
__lowerCAmelCase		     =["ar_AR", "cs_CZ", "de_DE", "en_XX", "es_XX", "et_EE", "fi_FI", "fr_XX", "gu_IN", "hi_IN", "it_IT", "ja_XX", "kk_KZ", "ko_KR", "lt_LT", "lv_LV", "my_MM", "ne_NP", "nl_XX", "ro_RO", "ru_RU", "si_LK", "tr_TR", "vi_VN", "zh_CN", "af_ZA", "az_AZ", "bn_IN", "fa_IR", "he_IL", "hr_HR", "id_ID", "ka_GE", "km_KH", "mk_MK", "ml_IN", "mn_MN", "mr_IN", "pl_PL", "ps_AF", "pt_XX", "sv_SE", "sw_KE", "ta_IN", "te_IN", "th_TH", "tl_XX", "uk_UA", "ur_PK", "xh_ZA", "gl_ES", "sl_SI"]






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

 __lowercase       		=    []
 __lowercase       		=    []
 def __init__(    self				:Any						,	lowercase_				:Tuple						,	lowercase_				:List[str]=None						,	lowercase_				:List[Any]=None						,	lowercase_				:Optional[Any]="</s>"						,	lowercase_				:Tuple="</s>"						,	lowercase_				:Optional[Any]="<s>"						,	lowercase_				:Tuple="<unk>"						,	lowercase_				:List[Any]="<pad>"						,	lowercase_				:Any="<mask>"						,	lowercase_				:Optional[Dict[str, Any]] = None						,	**lowercase_				:List[str]						,	)->							None:
     # Mask token behave like a normal word, i.e. include the space before it
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else mask_token

     A__    =      {} if sp_model_kwargs is None else sp_model_kwargs

     A__    =      kwargs.get("additional_special_tokens"						,	[]							)
     kwargs["additional_special_tokens"] += [
         code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
     ]

     super().__init__(
         src_lang=lowercase_						,	tgt_lang=lowercase_						,	eos_token=lowercase_						,	unk_token=lowercase_						,	sep_token=lowercase_						,	cls_token=lowercase_						,	pad_token=lowercase_						,	mask_token=lowercase_						,	sp_model_kwargs=self.sp_model_kwargs						,	**lowercase_						,	)

     A__    =      spm.SentencePieceProcessor(**self.sp_model_kwargs							)
     self.sp_model.Load(str(lowercase_							)							)
     A__    =      vocab_file

     # Original fairseq vocab and spm vocab must be "aligned":
     # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
     # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
     # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
     # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

     # Mimic fairseq token-to-id alignment for the first 4 token
     A__    =      {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

     # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
     A__    =      1

     A__    =      len(self.sp_model							)
     A__    =      {
         code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(lowercase_							)
     }
     A__    =      {v: k for k, v in self.lang_code_to_id.items()}
     A__    =      len(self.sp_model							) + len(self.lang_code_to_id							) + self.fairseq_offset

     self.fairseq_tokens_to_ids.update(self.lang_code_to_id							)
     A__    =      {v: k for k, v in self.fairseq_tokens_to_ids.items()}

     A__    =      src_lang if src_lang is not None else "en_XX"
     A__    =      self.lang_code_to_id[self._src_lang]
     A__    =      tgt_lang
     self.set_src_lang_special_tokens(self._src_lang							)
 @property
 def 					UpperCAmelCase_							(    self				:List[str]							)->							int:
     return len(self.sp_model							) + len(self.lang_code_to_id							) + self.fairseq_offset + 1  # Plus 1 for the mask token
 @property
 def 					UpperCAmelCase_							(    self				:str							)->							str:
     return self._src_lang
 @src_lang.setter
 def 					UpperCAmelCase_							(    self				:Dict						,	lowercase_				:str							)->							None:
     A__    =      new_src_lang
     self.set_src_lang_special_tokens(self._src_lang							)
 def __getstate__(    self				:List[Any]							)->							Dict:
     A__    =      self.__dict__.copy()
     A__    =      None
     return state
 def __setstate__(    self				:Any						,	lowercase_				:Dict							)->							None:
     A__    =      d

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

     A__    =      spm.SentencePieceProcessor(**self.sp_model_kwargs							)
     self.sp_model.Load(self.vocab_file							)
 def 					UpperCAmelCase_							(    self				:Tuple							)->							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 					UpperCAmelCase_							(    self				:Dict						,	lowercase_				:str							)->							List[str]:
     return self.sp_model.encode(lowercase_						,	out_type=lowercase_							)
 def 					UpperCAmelCase_							(    self				:str						,	lowercase_				:str							)->							int:
     if token in self.fairseq_tokens_to_ids:
         return self.fairseq_tokens_to_ids[token]
     A__    =      self.sp_model.PieceToId(lowercase_							)

     # Need to return unknown token if the SP model returned 0
     return spm_id + self.fairseq_offset if spm_id else self.unk_token_id
 def 					UpperCAmelCase_							(    self				:Any						,	lowercase_				:int							)->							str:
     if index in self.fairseq_ids_to_tokens:
         return self.fairseq_ids_to_tokens[index]
     return self.sp_model.IdToPiece(index - self.fairseq_offset							)
 def 					UpperCAmelCase_							(    self				:int						,	lowercase_				:str							)->							Any:
     A__    =      []
     A__    =      ""
     A__    =      False
     for token in tokens:
         # make sure that special tokens are not decoded using sentencepiece model
         if token in self.all_special_tokens:
             if not prev_is_special:
                 out_string += " "
             out_string += self.sp_model.decode(lowercase_							) + token
             A__    =      True
             A__    =      []
         else:
             current_sub_tokens.append(lowercase_							)
             A__    =      False
     out_string += self.sp_model.decode(lowercase_							)
     return out_string.strip()
 def 					UpperCAmelCase_							(    self				:Union[str, Any]						,	lowercase_				:str						,	lowercase_				:Optional[str] = None							)->							Tuple[str]:
     if not os.path.isdir(lowercase_							):
         logger.error(F"Vocabulary path ({save_directory}) should be a directory"							)
         return
     A__    =      os.path.join(
         lowercase_						,	(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)

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

     return (out_vocab_file,)
 def 					UpperCAmelCase_							(    self				:Dict						,	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				:Optional[Any]						,	lowercase_				:Union[str, Any]						,	lowercase_				:str						,	lowercase_				:Optional[str]						,	lowercase_				:Optional[str]						,	**lowercase_				:Optional[int]							)->							Optional[int]:
     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_						,	return_tensors=lowercase_						,	**lowercase_							)
     A__    =      self.convert_tokens_to_ids(lowercase_							)
     A__    =      tgt_lang_id
     return inputs
 def 					UpperCAmelCase_							(    self				:Union[str, Any]						,	lowercase_				:List[str]						,	lowercase_				:str = "en_XX"						,	lowercase_				:Optional[List[str]] = None						,	lowercase_				:str = "ro_RO"						,	**lowercase_				:Any						,	)->							BatchEncoding:
     A__    =      src_lang
     A__    =      tgt_lang
     return super().prepare_seqaseq_batch(lowercase_						,	lowercase_						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:Tuple							)->							int:
     return self.set_src_lang_special_tokens(self.src_lang							)
 def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							Any:
     return self.set_tgt_lang_special_tokens(self.tgt_lang							)
 def 					UpperCAmelCase_							(    self				:Optional[Any]						,	lowercase_				:str							)->							None:
     A__    =      self.lang_code_to_id[src_lang]
     A__    =      [self.cur_lang_code_id]
     A__    =      [self.eos_token_id]



 def 					UpperCAmelCase_							(    self				:int						,	lowercase_				:str							)->							None:
     A__    =      self.lang_code_to_id[tgt_lang]
     A__    =      [self.cur_lang_code_id]
     A__    =      [self.eos_token_id]










'''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())



