'''simple docstring'''
def A__   (					UpperCAmelCase_  ,  UpperCAmelCase_							):
						while b:
												_UpperCamelCase :		int			    =       b, a % b
						return a






def A__   (					UpperCAmelCase_  ,  UpperCAmelCase_							):
						return a if b == 0 else euclidean_gcd_recursive(__lowerCAmelCase  ,  a % b							)






def A__   (					):
						print(f'euclidean_gcd(3, 5) = {euclidean_gcd(3  ,  5							)}'							)
						print(f'euclidean_gcd(5, 3) = {euclidean_gcd(5  ,  3							)}'							)
						print(f'euclidean_gcd(1, 3) = {euclidean_gcd(1  ,  3							)}'							)
						print(f'euclidean_gcd(3, 6) = {euclidean_gcd(3  ,  6							)}'							)
						print(f'euclidean_gcd(6, 3) = {euclidean_gcd(6  ,  3							)}'							)

						print(f'euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3  ,  5							)}'							)
						print(f'euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5  ,  3							)}'							)
						print(f'euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1  ,  3							)}'							)
						print(f'euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3  ,  6							)}'							)
						print(f'euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6  ,  3							)}'							)


if __name__ == "__main__":
					main()







'''simple docstring'''
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

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


snake_case_			:     List[Any]  	=  logging.get_logger(__name__)


snake_case_			:     str  	=  {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'}

# See all BART models at https://huggingface.co/models?filter=bart
snake_case_			:     Union[str, Any]  	=  {
    'vocab_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/vocab.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/vocab.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json',
    },
    'merges_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/merges.txt',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/merges.txt',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt',
    },
}

snake_case_			:     Any  	=  {
    'facebook/bart-base': 1024,
    'facebook/bart-large': 1024,
    'facebook/bart-large-mnli': 1024,
    'facebook/bart-large-cnn': 1024,
    'facebook/bart-large-xsum': 1024,
    'yjernite/bart_eli5': 1024,
}






@lru_cache()
def A__   (					):
						_UpperCamelCase :		str			    =       (
						    list(range(ord('!'							)  ,  ord('~'							) + 1							)							) + list(range(ord('¡'							)  ,  ord('¬'							) + 1							)							) + list(range(ord('®'							)  ,  ord('ÿ'							) + 1							)							)
						)
						_UpperCamelCase :		Any			    =       bs[:]
						_UpperCamelCase :		Union[str, Any]			    =       0
						for b in range(2**8							):
												if b not in bs:
																		bs.append(UpperCAmelCase_							)
																		cs.append(2**8 + n							)
																		n += 1
						_UpperCamelCase :		Any			    =       [chr(UpperCAmelCase_							) for n in cs]
						return dict(zip(UpperCAmelCase_  ,  UpperCAmelCase_							)							)






def A__   (					UpperCAmelCase_							):
						_UpperCamelCase :		Tuple			    =       set()
						_UpperCamelCase :		Dict			    =       word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)							)
												_UpperCamelCase :		Any			    =       char
						return pairs






class 							lowercase__     (							lowercase       ):
	lowercase__      =      VOCAB_FILES_NAMES
	lowercase__      =      PRETRAINED_VOCAB_FILES_MAP
	lowercase__      =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	lowercase__      =      ["""input_ids""", """attention_mask"""]





	def __init__(			self :    Optional[int]			,lowerCamelCase__ :    Tuple			,lowerCamelCase__ :    List[str]			,lowerCamelCase__ :    Optional[Any]="replace"			,lowerCamelCase__ :    str="<s>"			,lowerCamelCase__ :    str="</s>"			,lowerCamelCase__ :    str="</s>"			,lowerCamelCase__ :    Any="<s>"			,lowerCamelCase__ :    Tuple="<unk>"			,lowerCamelCase__ :    List[str]="<pad>"			,lowerCamelCase__ :    Optional[Any]="<mask>"			,lowerCamelCase__ :    Tuple=False			,**lowerCamelCase__ :    List[str]			,):







							'''simple docstring'''
							_UpperCamelCase :		Dict			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else bos_token
							_UpperCamelCase :		Tuple			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else eos_token
							_UpperCamelCase :		Optional[int]			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else sep_token
							_UpperCamelCase :		Tuple			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else cls_token
							_UpperCamelCase :		Union[str, Any]			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else unk_token
							_UpperCamelCase :		List[str]			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else pad_token

							# Mask token behave like a normal word, i.e. include the space before it
							_UpperCamelCase :		str			    =       AddedToken(lowerCamelCase__			,lstrip=lowerCamelCase__			,rstrip=lowerCamelCase__			) if isinstance(lowerCamelCase__			,lowerCamelCase__			) else mask_token

							super().__init__(
							    errors=lowerCamelCase__			,bos_token=lowerCamelCase__			,eos_token=lowerCamelCase__			,unk_token=lowerCamelCase__			,sep_token=lowerCamelCase__			,cls_token=lowerCamelCase__			,pad_token=lowerCamelCase__			,mask_token=lowerCamelCase__			,add_prefix_space=lowerCamelCase__			,**lowerCamelCase__			,)

							with open(lowerCamelCase__			,encoding='utf-8'			) as vocab_handle:
													_UpperCamelCase :		List[str]			    =       json.load(lowerCamelCase__			)
							_UpperCamelCase :		Union[str, Any]			    =       {v: k for k, v in self.encoder.items()}
							_UpperCamelCase :		Optional[Any]			    =       errors  # how to handle errors in decoding
							_UpperCamelCase :		Tuple			    =       bytes_to_unicode()
							_UpperCamelCase :		List[str]			    =       {v: k for k, v in self.byte_encoder.items()}
							with open(lowerCamelCase__			,encoding='utf-8'			) as merges_handle:
													_UpperCamelCase :		Dict			    =       merges_handle.read().split('\n'			)[1:-1]
							_UpperCamelCase :		str			    =       [tuple(merge.split()			) for merge in bpe_merges]
							_UpperCamelCase :		Dict			    =       dict(zip(lowerCamelCase__			,range(len(lowerCamelCase__			)			)			)			)
							_UpperCamelCase :		Tuple			    =       {}
							_UpperCamelCase :		List[Any]			    =       add_prefix_space

							# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
							_UpperCamelCase :		Any			    =       re.compile(R'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'			)





	@property
	def      UpperCamelCase_  (			self :    Union[str, Any]			):







							'''simple docstring'''
							return len(self.encoder			)





	def      UpperCamelCase_  (			self :    str			):







							'''simple docstring'''
							return dict(self.encoder			,**self.added_tokens_encoder			)





	def      UpperCamelCase_  (			self :    str			,lowerCamelCase__ :    Any			):







							'''simple docstring'''
							if token in self.cache:
													return self.cache[token]
							_UpperCamelCase :		Dict			    =       tuple(lowerCamelCase__			)
							_UpperCamelCase :		List[str]			    =       get_pairs(lowerCamelCase__			)

							if not pairs:
													return token

							while True:
													_UpperCamelCase :		List[str]			    =       min(lowerCamelCase__			,key=lambda lowerCamelCase__			: self.bpe_ranks.get(lowerCamelCase__			,float('inf'			)			)			)
													if bigram not in self.bpe_ranks:
																			break
													_UpperCamelCase    ,      _UpperCamelCase :		int			    =       bigram
													_UpperCamelCase :		Optional[int]			    =       []
													_UpperCamelCase :		Dict			    =       0
													while i < len(lowerCamelCase__			):
																			try:
																									_UpperCamelCase :		int			    =       word.index(lowerCamelCase__			,lowerCamelCase__			)
																			except ValueError:
																									new_word.extend(word[i:]			)
																									break
																			else:
																									new_word.extend(word[i:j]			)
																									_UpperCamelCase :		Dict			    =       j

																			if word[i] == first and i < len(lowerCamelCase__			) - 1 and word[i + 1] == second:
																									new_word.append(first + second			)
																									i += 2
																			else:
																									new_word.append(word[i]			)
																									i += 1
													_UpperCamelCase :		int			    =       tuple(lowerCamelCase__			)
													_UpperCamelCase :		Union[str, Any]			    =       new_word
													if len(lowerCamelCase__			) == 1:
																			break
													else:
																			_UpperCamelCase :		Any			    =       get_pairs(lowerCamelCase__			)
							_UpperCamelCase :		int			    =       ' '.join(lowerCamelCase__			)
							_UpperCamelCase :		List[Any]			    =       word
							return word





	def      UpperCamelCase_  (			self :    List[str]			,lowerCamelCase__ :    Optional[Any]			):







							'''simple docstring'''
							_UpperCamelCase :		int			    =       []
							for token in re.findall(self.pat			,lowerCamelCase__			):
													_UpperCamelCase :		int			    =       ''.join(
													    self.byte_encoder[b] for b in token.encode('utf-8'			)			)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
													bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCamelCase__			).split(' '			)			)
							return bpe_tokens





	def      UpperCamelCase_  (			self :    List[Any]			,lowerCamelCase__ :    List[Any]			):







							'''simple docstring'''
							return self.encoder.get(lowerCamelCase__			,self.encoder.get(self.unk_token			)			)





	def      UpperCamelCase_  (			self :    Optional[Any]			,lowerCamelCase__ :    int			):







							'''simple docstring'''
							return self.decoder.get(lowerCamelCase__			)





	def      UpperCamelCase_  (			self :    List[Any]			,lowerCamelCase__ :    Any			):







							'''simple docstring'''
							_UpperCamelCase :		Dict			    =       ''.join(lowerCamelCase__			)
							_UpperCamelCase :		Dict			    =       bytearray([self.byte_decoder[c] for c in text]			).decode('utf-8'			,errors=self.errors			)
							return text





	def      UpperCamelCase_  (			self :    Optional[Any]			,lowerCamelCase__ :    str			,lowerCamelCase__ :    Optional[str] = None			):







							'''simple docstring'''
							if not os.path.isdir(lowerCamelCase__			):
													logger.error(F'Vocabulary path ({save_directory}) should be a directory'			)
													return
							_UpperCamelCase :		List[Any]			    =       os.path.join(
							    lowerCamelCase__			,(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)
							_UpperCamelCase :		Union[str, Any]			    =       os.path.join(
							    lowerCamelCase__			,(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']			)

							with open(lowerCamelCase__			,'w'			,encoding='utf-8'			) as f:
													f.write(json.dumps(self.encoder			,indent=2			,sort_keys=lowerCamelCase__			,ensure_ascii=lowerCamelCase__			) + '\n'			)

							_UpperCamelCase :		Optional[Any]			    =       0
							with open(lowerCamelCase__			,'w'			,encoding='utf-8'			) as writer:
													writer.write('#version: 0.2\n'			)
													for bpe_tokens, token_index in sorted(self.bpe_ranks.items()			,key=lambda lowerCamelCase__			: kv[1]			):
																			if index != token_index:
																									logger.warning(
																									    F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
																									    ' Please check that the tokenizer is not corrupted!'			)
																									_UpperCamelCase :		int			    =       token_index
																			writer.write(' '.join(lowerCamelCase__			) + '\n'			)
																			index += 1

							return vocab_file, merge_file





	def      UpperCamelCase_  (			self :    Any			,lowerCamelCase__ :    List[int]			,lowerCamelCase__ :    Optional[List[int]] = None			):







							'''simple docstring'''
							if token_ids_a is None:
													return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
							_UpperCamelCase :		Optional[Any]			    =       [self.cls_token_id]
							_UpperCamelCase :		str			    =       [self.sep_token_id]
							return cls + token_ids_a + sep + sep + token_ids_a + sep





	def      UpperCamelCase_  (			self :    List[str]			,lowerCamelCase__ :    List[int]			,lowerCamelCase__ :    Optional[List[int]] = None			,lowerCamelCase__ :    bool = False			):







							'''simple docstring'''
							if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=lowerCamelCase__			,token_ids_a=lowerCamelCase__			,already_has_special_tokens=lowerCamelCase__			)

							if token_ids_a is None:
													return [1] + ([0] * len(lowerCamelCase__			)) + [1]
							return [1] + ([0] * len(lowerCamelCase__			)) + [1, 1] + ([0] * len(lowerCamelCase__			)) + [1]





	def      UpperCamelCase_  (			self :    Tuple			,lowerCamelCase__ :    List[int]			,lowerCamelCase__ :    Optional[List[int]] = None			):







							'''simple docstring'''
							_UpperCamelCase :		Tuple			    =       [self.sep_token_id]
							_UpperCamelCase :		Dict			    =       [self.cls_token_id]

							if token_ids_a is None:
													return len(cls + token_ids_a + sep			) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]





	def      UpperCamelCase_  (			self :    Any			,lowerCamelCase__ :    List[str]			,lowerCamelCase__ :    Tuple=False			,**lowerCamelCase__ :    Optional[int]			):







							'''simple docstring'''
							_UpperCamelCase :		Tuple			    =       kwargs.pop('add_prefix_space'			,self.add_prefix_space			)
							if (is_split_into_words or add_prefix_space) and (len(lowerCamelCase__			) > 0 and not text[0].isspace()):
													_UpperCamelCase :		List[str]			    =       ' ' + text
							return (text, kwargs)


