



"""simple docstring"""


import json
import os
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

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


if TYPE_CHECKING:
				from transformers.pipelines.conversational import Conversation

snake_case_         = logging.get_logger(__name__)

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

snake_case_         = {
    """vocab_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json"""
        ),
    },
    """merges_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt"""
        ),
    },
}

snake_case_         = {
    """microsoft/deberta-base""": 512,
    """microsoft/deberta-large""": 512,
    """microsoft/deberta-xlarge""": 512,
    """microsoft/deberta-base-mnli""": 512,
    """microsoft/deberta-large-mnli""": 512,
    """microsoft/deberta-xlarge-mnli""": 512,
}

snake_case_         = {
    """microsoft/deberta-base""": {"""do_lower_case""": False},
    """microsoft/deberta-large""": {"""do_lower_case""": False},
}

def 				_lowerCAmelCase   (     ):
						UpperCAmelCase    =				(
						    list(range(ord('!'		)	,			ord('~'		) + 1		)		) + list(range(ord('¡'		)	,			ord('¬'		) + 1		)		) + list(range(ord('®'		)	,			ord('ÿ'		) + 1		)		)
						)
						UpperCAmelCase    =				bs[:]
						UpperCAmelCase    =				0
						for b in range(2**8		):
												if b not in bs:
																		bs.append(lowercase_		)
																		cs.append(2**8 + n		)
																		n += 1
						UpperCAmelCase    =				[chr(lowercase_		) for n in cs]
						return dict(zip(lowercase_	,			lowercase_		)		)

def 				_lowerCAmelCase   (     lowercase_		):
						UpperCAmelCase    =				set()
						UpperCAmelCase    =				word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)		)
												UpperCAmelCase    =				char
						return pairs







class    A_    (  SCREAMING_SNAKE_CASE_       ):



						"""simple docstring"""
						__UpperCamelCase	       =							VOCAB_FILES_NAMES
						__UpperCamelCase	       =							PRETRAINED_VOCAB_FILES_MAP
						__UpperCamelCase	       =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						__UpperCamelCase	       =							["""input_ids""", """attention_mask""", """token_type_ids"""]






						def __init__(      self				:str     ,						lowercase_				:str     ,						lowercase_				:List[str]     ,						lowercase_				:Any="replace"     ,						lowercase_				:Optional[Any]="[CLS]"     ,						lowercase_				:str="[SEP]"     ,						lowercase_				:Optional[Any]="[SEP]"     ,						lowercase_				:List[str]="[CLS]"     ,						lowercase_				:Optional[int]="[UNK]"     ,						lowercase_				:Optional[Any]="[PAD]"     ,						lowercase_				:Dict="[MASK]"     ,						lowercase_				:Optional[int]=False     ,						lowercase_				:str=False     ,						**lowercase_				:Any     ,						)       ->    Optional[Any]:
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else bos_token
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else eos_token
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else sep_token
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else cls_token
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else unk_token
												UpperCAmelCase    =				AddedToken(lowercase_     ,						lstrip=lowercase_     ,						rstrip=lowercase_      ) if isinstance(lowercase_     ,						lowercase_      ) else pad_token

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

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

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

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






						@property
						# Copied from transformers.models.gpt2.tokenization_gpt2.GPT2Tokenizer.vocab_size
						def 			UpperCAmelCase__  (      self				:Optional[Any]      )       ->    str:
												return len(self.encoder      )






						def 			UpperCAmelCase__  (      self				:Tuple      )       ->    Optional[int]:
												return dict(self.encoder     ,						**self.added_tokens_encoder      )






						def 			UpperCAmelCase__  (      self				:List[str]     ,						lowercase_				:Dict      )       ->    Optional[int]:
												if token in self.cache:
																		return self.cache[token]
												UpperCAmelCase    =				tuple(lowercase_      )
												UpperCAmelCase    =				get_pairs(lowercase_      )

												if not pairs:
																		return token

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

																								if word[i] == first and i < len(lowercase_      ) - 1 and word[i + 1] == second:
																														new_word.append(first + second      )
																														i += 2
																								else:
																														new_word.append(word[i]      )
																														i += 1
																		UpperCAmelCase    =				tuple(lowercase_      )
																		UpperCAmelCase    =				new_word
																		if len(lowercase_      ) == 1:
																								break
																		else:
																								UpperCAmelCase    =				get_pairs(lowercase_      )
												UpperCAmelCase    =				' '.join(lowercase_      )
												UpperCAmelCase    =				word
												return word






						def 			UpperCAmelCase__  (      self				:List[Any]     ,						lowercase_				:List[int]     ,						lowercase_				:Optional[List[int]] = None      )       ->    List[int]:
												if token_ids_a is None:
																		return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
												UpperCAmelCase    =				[self.cls_token_id]
												UpperCAmelCase    =				[self.sep_token_id]
												return cls + token_ids_a + sep + token_ids_a + sep






						def 			UpperCAmelCase__  (      self				:List[Any]     ,						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_      )

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






						def 			UpperCAmelCase__  (      self				:Tuple     ,						lowercase_				:List[int]     ,						lowercase_				:Optional[List[int]] = None      )       ->    List[int]:
												UpperCAmelCase    =				[self.sep_token_id]
												UpperCAmelCase    =				[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      ) * [0] + len(token_ids_a + sep      ) * [1]






						def 			UpperCAmelCase__  (      self				:List[str]     ,						lowercase_				:Union[str, Any]      )       ->    Tuple:
												UpperCAmelCase    =				[]
												for token in re.findall(self.pat     ,						lowercase_      ):
																		UpperCAmelCase    =				''.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(lowercase_      ).split(' '      )      )
												return bpe_tokens






						def 			UpperCAmelCase__  (      self				:Union[str, Any]     ,						lowercase_				:int      )       ->    Dict:
												return self.encoder.get(lowercase_     ,						self.encoder.get(self.unk_token      )      )






						def 			UpperCAmelCase__  (      self				:int     ,						lowercase_				:Any      )       ->    List[str]:
												return self.decoder.get(lowercase_      )






						def 			UpperCAmelCase__  (      self				:Dict     ,						lowercase_				:Dict      )       ->    Dict:
												UpperCAmelCase    =				''.join(lowercase_      )
												UpperCAmelCase    =				bytearray([self.byte_decoder[c] for c in text]      ).decode('utf-8'     ,						errors=self.errors      )
												return text






						def 			UpperCAmelCase__  (      self				:str     ,						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
												UpperCAmelCase    =				os.path.join(
												    lowercase_     ,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']      )
												UpperCAmelCase    =				os.path.join(
												    lowercase_     ,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']      )

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

												UpperCAmelCase    =				0
												with open(lowercase_     ,						'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 lowercase_      : 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    =				token_index
																								writer.write(' '.join(lowercase_      ) + '\n'      )
																								index += 1

												return vocab_file, merge_file






						def 			UpperCAmelCase__  (      self				:int     ,						lowercase_				:Union[str, Any]     ,						lowercase_				:Dict=False     ,						**lowercase_				:List[str]      )       ->    Optional[Any]:
												UpperCAmelCase    =				kwargs.pop('add_prefix_space'     ,						self.add_prefix_space      )
												if (is_split_into_words or add_prefix_space) and (len(lowercase_      ) > 0 and not text[0].isspace()):
																		UpperCAmelCase    =				' ' + text
												return (text, kwargs)






						def 			UpperCAmelCase__  (      self				:Any     ,						lowercase_				:"Conversation"      )       ->    List[int]:
												UpperCAmelCase    =				[]
												for is_user, text in conversation.iter_texts():
																		input_ids.extend(self.encode(lowercase_     ,						add_special_tokens=lowercase_      ) + [self.eos_token_id]      )
												if len(lowercase_      ) > self.model_max_length:
																		UpperCAmelCase    =				input_ids[-self.model_max_length :]
												return input_ids










"""simple docstring"""


from collections import Counter

def 				_lowerCAmelCase   (     lowercase_		):
						return sum(socks_by_color // 2 for socks_by_color in Counter(lowercase_		).values()		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				snake_case_         = [int(x) for x in input("""Enter socks by color :""").rstrip().split()]
				print(f'''sock_merchant({colors}) = {sock_merchant(colors)}''')





