'''simple docstring'''




import json
import os
from functools import lru_cache
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  : int		       =    logging.get_logger(__name__)

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

__snake_case  : Dict		       =    {
    '''vocab_file''': {
        '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/vocab.json''',
        '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/vocab.json''',
        '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/vocab.json''',
        '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/vocab.json''',
        '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/merges.txt''',
        '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/merges.txt''',
        '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/merges.txt''',
        '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/merges.txt''',
        '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/merges.txt''',
    },
}

__snake_case  : int		       =    {
    '''gpt2''': 1_024,
    '''gpt2-medium''': 1_024,
    '''gpt2-large''': 1_024,
    '''gpt2-xl''': 1_024,
    '''distilgpt2''': 1_024,
}





@lru_cache()
def 	_UpperCAmelCase       (				)      -> Optional[int]:
    A_      =  (
        list(range(ord('''!'''  ),  ord('''~'''  ) + 1  )  ) + list(range(ord('''¡'''  ),  ord('''¬'''  ) + 1  )  ) + list(range(ord('''®'''  ),  ord('''ÿ'''  ) + 1  )  )
    )
    A_      =  bs[:]
    A_      =  0
    for b in range(2**8  ):
        if b not in bs:
            bs.append(lowercase_  )
            cs.append(2**8 + n  )
            n += 1
    A_      =  [chr(lowercase_  ) for n in cs]
    return dict(zip(lowercase_,  lowercase_  )  )





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> Optional[Any]:
    A_      =  set()
    A_      =  word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)  )
        A_      =  char
    return pairs




class       __UpperCAmelCase							(							_UpperCamelCase	):





       '''simple docstring'''



       __lowercase   :   Tuple  					=							VOCAB_FILES_NAMES
       __lowercase   :   int  					=							PRETRAINED_VOCAB_FILES_MAP
       __lowercase   :   Union[str, Any]  					=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       __lowercase   :   Dict  					=							["input_ids", "attention_mask"]

       def __init__( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE="replace"       ,	_SCREAMING_SNAKE_CASE="<|endoftext|>"       ,	_SCREAMING_SNAKE_CASE="<|endoftext|>"       ,	_SCREAMING_SNAKE_CASE="<|endoftext|>"       ,	_SCREAMING_SNAKE_CASE=None       ,	_SCREAMING_SNAKE_CASE=False       ,	_SCREAMING_SNAKE_CASE=False       ,	**_SCREAMING_SNAKE_CASE       ,	)						->	Union[str, Any]:
           A_      =  AddedToken(_SCREAMING_SNAKE_CASE       ,	lstrip=_SCREAMING_SNAKE_CASE       ,	rstrip=_SCREAMING_SNAKE_CASE					) if isinstance(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					) else bos_token
           A_      =  AddedToken(_SCREAMING_SNAKE_CASE       ,	lstrip=_SCREAMING_SNAKE_CASE       ,	rstrip=_SCREAMING_SNAKE_CASE					) if isinstance(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					) else eos_token
           A_      =  AddedToken(_SCREAMING_SNAKE_CASE       ,	lstrip=_SCREAMING_SNAKE_CASE       ,	rstrip=_SCREAMING_SNAKE_CASE					) if isinstance(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					) else unk_token
           A_      =  AddedToken(_SCREAMING_SNAKE_CASE       ,	lstrip=_SCREAMING_SNAKE_CASE       ,	rstrip=_SCREAMING_SNAKE_CASE					) if isinstance(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					) else pad_token
           super().__init__(
               errors=_SCREAMING_SNAKE_CASE       ,	unk_token=_SCREAMING_SNAKE_CASE       ,	bos_token=_SCREAMING_SNAKE_CASE       ,	eos_token=_SCREAMING_SNAKE_CASE       ,	pad_token=_SCREAMING_SNAKE_CASE       ,	add_prefix_space=_SCREAMING_SNAKE_CASE       ,	add_bos_token=_SCREAMING_SNAKE_CASE       ,	**_SCREAMING_SNAKE_CASE       ,	)
           A_      =  add_bos_token

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

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

       @property
       def    __A			( self					)						->	Optional[int]:
           return len(self.encoder					)

       def    __A			( self					)						->	Union[str, Any]:
           return dict(self.encoder       ,	**self.added_tokens_encoder					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	Optional[Any]:

           if token in self.cache:
               return self.cache[token]
           A_      =  tuple(_SCREAMING_SNAKE_CASE					)
           A_      =  get_pairs(_SCREAMING_SNAKE_CASE					)

           if not pairs:
               return token

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

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

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE=None					)						->	Optional[int]:

           if self.add_bos_token:
               A_      =  [self.bos_token_id]
           else:
               A_      =  []

           A_      =  bos_token_ids + token_ids_a

           if token_ids_a is None:
               return output

           return output + bos_token_ids + token_ids_a

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = None       ,	_SCREAMING_SNAKE_CASE = False					)						->	int:

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

           if not self.add_bos_token:
               return super().get_special_tokens_mask(
                   token_ids_a=_SCREAMING_SNAKE_CASE       ,	token_ids_a=_SCREAMING_SNAKE_CASE       ,	already_has_special_tokens=_SCREAMING_SNAKE_CASE					)

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

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  []
           for token in re.findall(self.pat       ,	_SCREAMING_SNAKE_CASE					):
               A_      =  ''''''.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(_SCREAMING_SNAKE_CASE					).split(''' '''					)					)
           return bpe_tokens

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	Any:
           return self.encoder.get(_SCREAMING_SNAKE_CASE       ,	self.encoder.get(self.unk_token					)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	Tuple:
           return self.decoder.get(_SCREAMING_SNAKE_CASE					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	List[Any]:
           A_      =  ''''''.join(_SCREAMING_SNAKE_CASE					)
           A_      =  bytearray([self.byte_decoder[c] for c in text]					).decode('''utf-8'''       ,	errors=self.errors					)
           return text

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = None					)						->	int:

           if not os.path.isdir(_SCREAMING_SNAKE_CASE					):
               logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''					)
               return
           A_      =  os.path.join(
               _SCREAMING_SNAKE_CASE       ,	(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']					)
           A_      =  os.path.join(
               _SCREAMING_SNAKE_CASE       ,	(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']					)

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

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

           return vocab_file, merge_file

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE=False       ,	**_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  kwargs.pop('''add_prefix_space'''       ,	self.add_prefix_space					)
           if is_split_into_words or add_prefix_space:
               A_      =  ''' ''' + text
           return (text, kwargs)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE					)						->	List[Any]:
           A_      =  []
           for is_user, text in conversation.iter_texts():
               input_ids.extend(self.encode(_SCREAMING_SNAKE_CASE       ,	add_special_tokens=_SCREAMING_SNAKE_CASE					) + [self.eos_token_id]					)
           if len(_SCREAMING_SNAKE_CASE					) > self.model_max_length:
               A_      =  input_ids[-self.model_max_length :]
           return input_ids







"""simple docstring"""







from collections import Counter



def       A__    (	lowercase_     :	list[int]						)  ->							int:
   return sum(socks_by_color // 2 for socks_by_color in Counter(lowercase_						).values()						)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

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






