





'''simple docstring'''







from typing import List

from tokenizers import NormalizedString, PreTokenizedString, normalizers


class        __a   :

							def __init__(				self				:  List[str]							,  __magic_name__				:  Dict )       ->							None:







													"""simple docstring"""
													UpperCAmelCase_      :   Tuple      =	vocab
													UpperCAmelCase_      :   str      =	normalizers.BertNormalizer(
													    clean_text=__magic_name__							,  handle_chinese_chars=__magic_name__							,  strip_accents=__magic_name__							,  lowercase=__magic_name__							,  )
													try:
																			import rjieba
													except ImportError:
																			raise ImportError(
																			    '''You need to install rjieba to use RoFormerTokenizer. '''
																			    '''See https://pypi.org/project/rjieba/ for installation.''' )
													UpperCAmelCase_      :   Optional[int]      =	rjieba

							def      UpperCAmelCase__						(				self				:  Optional[int]							,  __magic_name__				:  int							,  __magic_name__				:  NormalizedString )       ->							List[NormalizedString]:







													"""simple docstring"""
													UpperCAmelCase_      :   Union[str, Any]      =	[]

													# this code slice normalized_string is too slow (6s) but test_alignement_methods can pass
													for token, start, end in self.jieba.tokenize(str(__magic_name__ )							,  hmm=__magic_name__ ):
																			if token in self.vocab:
																									splits.append(normalized_string[start:end] )
																			else:
																									UpperCAmelCase_      :   Union[str, Any]      =	self.normalizers.normalize_str(__magic_name__ ).split()
																									for token in token_list:
																															if token:
																																					UpperCAmelCase_      :   Dict      =	start + len(__magic_name__ )
																																					splits.append(normalized_string[start:end] )
																																					UpperCAmelCase_      :   Union[str, Any]      =	end

        # this code test_alignement_methods can't pass but fast (300ms)
        # for token in self.jieba.cut(str(normalized_string), False):
        #     if token in self.vocab:
        #         splits.append(NormalizedString(token))
        #     else:
        #         token_list = self.normalizers.normalize_str(token).split()
        #         for token in token_list:
        #             if token:
        #                 splits.append(NormalizedString(token))

													return splits



							def      UpperCAmelCase__						(				self				:  int							,  __magic_name__				:  PreTokenizedString )       ->							Optional[Any]:







													"""simple docstring"""
													pretok.split(self.jieba_split )











from collections import Counter




def  a_		(							__snake_case					)	->			int:

			'''simple docstring'''


			return sum(socks_by_color // 2 for socks_by_color in Counter(__snake_case					).values()					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

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