code: 
  
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Dict		,						SCREAMING_SNAKE_CASE__			:		Any		,						SCREAMING_SNAKE_CASE__			:		Optional[Any]       )						->     List[str]:
  
  
  
  
  
       '''simple docstring'''
  
       assert (
           c % greatest_common_divisor(lowercase_		,						lowercase_       ) == 0
       )  # greatest_common_divisor(a,b) function implemented below
       ((_UpperCAmelCase)       , (_UpperCAmelCase)       , (_UpperCAmelCase))    :			List[str]              =					extended_gcd(lowercase_		,						lowercase_       )  # extended_gcd(a,b) function implemented below
       _UpperCAmelCase    :			Optional[int]              =					c / d
       return (r * x, r * y)
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int		,						SCREAMING_SNAKE_CASE__			:		Dict		,						SCREAMING_SNAKE_CASE__			:		Tuple		,						SCREAMING_SNAKE_CASE__			:		Dict = 2       )						->     Union[str, Any]:
  
  
  
  
  
       '''simple docstring'''
  
       ((_UpperCAmelCase)       , (_UpperCAmelCase))    :			List[Any]              =					diophantine(lowercase_		,						lowercase_		,						lowercase_       )  # Initial value
       _UpperCAmelCase    :			str              =					greatest_common_divisor(lowercase_		,						lowercase_       )
       _UpperCAmelCase    :			List[Any]              =					a // d
       _UpperCAmelCase    :			Optional[int]              =					b // d
  
       for i in range(lowercase_       ):
            _UpperCAmelCase    :			Optional[int]              =					xa + i * q
            _UpperCAmelCase    :			Union[str, Any]              =					ya - i * p
            print(lowercase_		,						lowercase_       )
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Any		,						SCREAMING_SNAKE_CASE__			:		str       )						->     Union[str, Any]:
  
  
  
  
  
       '''simple docstring'''
  
       if a < b:
            _UpperCAmelCase       , _UpperCAmelCase    :			Any              =					b, a
  
       while a % b != 0:
            _UpperCAmelCase       , _UpperCAmelCase    :			str              =					b, a % b
  
       return b
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Dict		,						SCREAMING_SNAKE_CASE__			:		Tuple       )						->     List[str]:
  
  
  
  
  
       '''simple docstring'''
  
       assert a >= 0 and b >= 0
  
       if b == 0:
            _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			str              =					a, 1, 0
       else:
            ((_UpperCAmelCase)       , (_UpperCAmelCase)       , (_UpperCAmelCase))    :			List[Any]              =					extended_gcd(lowercase_		,						a % b       )
            _UpperCAmelCase    :			int              =					q
            _UpperCAmelCase    :			Any              =					p - q * (a // b)
  
       assert a % d == 0 and b % d == 0
       assert d == a * x + b * y
  
       return (d, x, y)
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod(name="diophantine", verbose=True)
   testmod(name="diophantine_all_soln", verbose=True)
   testmod(name="extended_gcd", verbose=True)
   testmod(name="greatest_common_divisor", verbose=True)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
   from .tokenization_xglm import XGLMTokenizer
  else:
   _lowerCAmelCase       :      Tuple							=							None
  
  
  _lowerCAmelCase       :      List[str]							=							logging.get_logger(__name__)
  
  _lowerCAmelCase       :      str							=							{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}
  
  _lowerCAmelCase       :      Optional[Any]							=							{
      "vocab_file": {
          "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model",
      },
      "tokenizer_file": {
          "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json",
      },
  }
  
  _lowerCAmelCase       :      Union[str, Any]							=							{
      "facebook/xglm-564M": 20_48,
  }
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       _UpperCamelCase		):
        __SCREAMING_SNAKE_CASE		:     str				  =				VOCAB_FILES_NAMES
        __SCREAMING_SNAKE_CASE		:     List[str]				  =				PRETRAINED_VOCAB_FILES_MAP
        __SCREAMING_SNAKE_CASE		:     str				  =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
        __SCREAMING_SNAKE_CASE		:     int				  =				['input_ids', 'attention_mask']
        __SCREAMING_SNAKE_CASE		:     str				  =				XGLMTokenizer
  
  
  
        def __init__(  self  :			List[Any]  ,			A  :			Union[str, Any]=None  ,			A  :			Optional[Any]=None  ,			A  :			Optional[Any]="<s>"  ,			A  :			Optional[int]="</s>"  ,			A  :			str="</s>"  ,			A  :			int="<s>"  ,			A  :			int="<unk>"  ,			A  :			List[str]="<pad>"  ,			**A  :			Tuple  ,			):
             # Compatibility with the original tokenizer
             _UpperCAmelCase    :			Union[str, Any]              =					7
             _UpperCAmelCase    :			Optional[int]              =					[f'<madeupword{i}>' for i in range(self.num_madeup_words		)]
  
             _UpperCAmelCase    :			Any              =					kwargs.get("additional_special_tokens"  ,			[]		)
             kwargs["additional_special_tokens"] += [
                 word for word in madeup_words if word not in kwargs["additional_special_tokens"]
             ]
  
             super().__init__(
                 A  ,			tokenizer_file=A  ,			bos_token=A  ,			eos_token=A  ,			sep_token=A  ,			cls_token=A  ,			unk_token=A  ,			pad_token=A  ,			**A  ,			)
  
             _UpperCAmelCase    :			Any              =					vocab_file
             _UpperCAmelCase    :			Union[str, Any]              =					False if not self.vocab_file else True
  
  
  
        def 		snake_case_      (  self  :			List[str]  ,			A  :			List[int]  ,			A  :			Optional[List[int]] = None		):
  
             if token_ids_a is None:
                  return [self.sep_token_id] + token_ids_a
             _UpperCAmelCase    :			Tuple              =					[self.sep_token_id]
             return sep + token_ids_a + sep + sep + token_ids_a
  
  
  
        def 		snake_case_      (  self  :			str  ,			A  :			List[int]  ,			A  :			Optional[List[int]] = None		):
             _UpperCAmelCase    :			Optional[int]              =					[self.sep_token_id]
  
             if token_ids_a is None:
                  return len(sep + token_ids_a		) * [0]
             return len(sep + token_ids_a + sep + sep + token_ids_a		) * [0]
  
  
  
        def 		snake_case_      (  self  :			Dict  ,			A  :			str  ,			A  :			Optional[str] = None		):
             if not self.can_save_slow_tokenizer:
                  raise ValueError(
                      "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
                      "tokenizer."		)
  
             if not os.path.isdir(A		):
                  logger.error(f'Vocabulary path ({save_directory}) should be a directory.'		)
                  return
             _UpperCAmelCase    :			str              =					os.path.join(
                 A  ,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]		)
  
             if os.path.abspath(self.vocab_file		) != os.path.abspath(A		):
                  copyfile(self.vocab_file  ,			A		)
  
             return (out_vocab_file,)
  