




'''simple docstring'''







import enum
import inspect
from typing import Iterable, List, Optional, Tuple, Union


class      _a    (      enum.Enum					):
       __a							:	Optional[Any]  							=   "timm"
       __a							:	Optional[int]  							=   "transformers"






def 		snake_case_				(_a      :				Optional[Iterable[str]]       ,  _a      :				Optional[Iterable[int]]       ,  _a      :				Optional[Iterable[str]]	):
    if stage_names is None:
        raise ValueError('''Stage_names must be set for transformers backbones'''	)

    if out_features is not None:
        if not isinstance(lowercase_       ,  (list,)	):
            raise ValueError(F"out_features must be a list {type(lowercase_	)}"	)
        if any(feat not in stage_names for feat in out_features	):
            raise ValueError(F"out_features must be a subset of stage_names: {stage_names} got {out_features}"	)

    if out_indices is not None:
        if not isinstance(lowercase_       ,  (list, tuple)	):
            raise ValueError(F"out_indices must be a list or tuple, got {type(lowercase_	)}"	)
        if any(idx >= len(lowercase_	) for idx in out_indices	):
            raise ValueError('''out_indices must be valid indices for stage_names {stage_names}, got {out_indices}'''	)

    if out_features is not None and out_indices is not None:
        if len(lowercase_	) != len(lowercase_	):
            raise ValueError('''out_features and out_indices should have the same length if both are set'''	)
        if out_features != [stage_names[idx] for idx in out_indices]:
            raise ValueError('''out_features and out_indices should correspond to the same stages if both are set'''	)





def 		snake_case_				(_a      :				Optional[List[str]]       ,  _a      :				Optional[Union[List[int], Tuple[int]]]       ,  _a      :				List[str]       ,  ):
    if out_indices is None and out_features is None:
        UpperCAmelCase     			=						[len(lowercase_	) - 1]
        UpperCAmelCase     			=						[stage_names[-1]]
    elif out_indices is None and out_features is not None:
        UpperCAmelCase     			=						[stage_names.index(lowercase_	) for layer in out_features]
    elif out_features is None and out_indices is not None:
        UpperCAmelCase     			=						[stage_names[idx] for idx in out_indices]
    return out_features, out_indices





def 		snake_case_				(_a      :				Optional[List[str]]       ,  _a      :				Optional[Union[List[int], Tuple[int]]]       ,  _a      :				List[str]       ,  ):
    verify_out_features_out_indices(out_features=lowercase_       ,  out_indices=lowercase_       ,  stage_names=lowercase_	)
    UpperCAmelCase			,	UpperCAmelCase     			=						_align_output_features_output_indices(
        out_features=lowercase_       ,  out_indices=lowercase_       ,  stage_names=lowercase_	)
    # Verify that the aligned out_features and out_indices are valid
    verify_out_features_out_indices(out_features=lowercase_       ,  out_indices=lowercase_       ,  stage_names=lowercase_	)
    return output_features, output_indices


class      _a    :
       __a							:	Optional[BackboneType]  							=   None
       def        A (      self		:      Union[str, Any]  ,							lowercase		:      Optional[int]							):



           '''simple docstring'''

           if getattr(self  ,							'''_backbone'''  ,							_SCREAMING_SNAKE_CASE							) is None:
               raise ValueError('''self._backbone must be set before calling _init_timm_backbone'''							)

           # These will diagree with the defaults for the transformers models e.g. for resnet50
           # the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
           # the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
           UpperCAmelCase     			=						[stage['''module'''] for stage in self._backbone.feature_info.info]
           UpperCAmelCase     			=						[stage['''num_chs'''] for stage in self._backbone.feature_info.info]
           UpperCAmelCase     			=						self._backbone.feature_info.out_indices
           UpperCAmelCase     			=						self._backbone.feature_info.module_name()

           # We verify the out indices and out features are valid
           verify_out_features_out_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=self.stage_names							)
           UpperCAmelCase			,	UpperCAmelCase     			=						out_features, out_indices
       def        A (      self		:      List[str]  ,							lowercase		:      List[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						getattr(_SCREAMING_SNAKE_CASE  ,							'''stage_names'''							)
           UpperCAmelCase     			=						getattr(_SCREAMING_SNAKE_CASE  ,							'''out_features'''  ,							_SCREAMING_SNAKE_CASE							)
           UpperCAmelCase     			=						getattr(_SCREAMING_SNAKE_CASE  ,							'''out_indices'''  ,							_SCREAMING_SNAKE_CASE							)

           UpperCAmelCase     			=						stage_names
           UpperCAmelCase			,	UpperCAmelCase     			=						get_aligned_output_features_output_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=_SCREAMING_SNAKE_CASE							)
           # Number of channels for each stage. This is set in the transformer backbone model init
           UpperCAmelCase     			=						None
       def        A (      self		:      List[Any]  ,							lowercase		:      int							):



           '''simple docstring'''

           UpperCAmelCase     			=						config

           UpperCAmelCase     			=						getattr(_SCREAMING_SNAKE_CASE  ,							'''use_timm_backbone'''  ,							_SCREAMING_SNAKE_CASE							)
           UpperCAmelCase     			=						BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS

           if self.backbone_type == BackboneType.TIMM:
               self._init_timm_backbone(_SCREAMING_SNAKE_CASE							)
           elif self.backbone_type == BackboneType.TRANSFORMERS:
               self._init_transformers_backbone(_SCREAMING_SNAKE_CASE							)
           else:
               raise ValueError(f"backbone_type {self.backbone_type} not supported."							)
       @property
       def        A (      self		:      List[Any]							):



           '''simple docstring'''

           return self._out_features
       @out_features.setter
       def        A (      self		:      int  ,							lowercase		:      Optional[int]							):



           '''simple docstring'''

           UpperCAmelCase			,	UpperCAmelCase     			=						get_aligned_output_features_output_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=self.stage_names							)
       @property
       def        A (      self		:      Tuple							):



           '''simple docstring'''

           return self._out_indices
       @out_indices.setter
       def        A (      self		:      Union[str, Any]  ,							lowercase		:      int							):



           '''simple docstring'''

           UpperCAmelCase			,	UpperCAmelCase     			=						get_aligned_output_features_output_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=self.stage_names							)
       @property
       def        A (      self		:      str							):



           '''simple docstring'''

           return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names							)}
       @property
       def        A (      self		:      Union[str, Any]							):



           '''simple docstring'''

           return [self.out_feature_channels[name] for name in self.out_features]
       def        A (      self		:      Optional[Any]  ,							*lowercase		:      Tuple  ,							**lowercase		:      Dict							):



           '''simple docstring'''

           UpperCAmelCase     			=						dict(inspect.signature(self.forward							).parameters							)
           UpperCAmelCase     			=						{k: v for k, v in kwargs.items() if k in signature}
           return self(*_SCREAMING_SNAKE_CASE  ,							**_SCREAMING_SNAKE_CASE							)
       def        A (      self		:      str  ,							lowercase		:      Union[str, Any]  ,							lowercase		:      Dict = None  ,							lowercase		:      Any = None  ,							lowercase		:      str = None  ,							):



           '''simple docstring'''

           raise NotImplementedError('''This method should be implemented by the derived class.'''							)







       def        A (      self		:      List[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						super().to_dict()
           UpperCAmelCase     			=						output.pop('''_out_features'''							)
           UpperCAmelCase     			=						output.pop('''_out_indices'''							)
           return output






class      _a    :
       @property
       def        A (      self		:      List[Any]							):



           '''simple docstring'''

           return self._out_features
       @out_features.setter
       def        A (      self		:      List[str]  ,							lowercase		:      int							):



           '''simple docstring'''

           UpperCAmelCase			,	UpperCAmelCase     			=						get_aligned_output_features_output_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=self.stage_names							)
       @property
       def        A (      self		:      Tuple							):



           '''simple docstring'''

           return self._out_indices
       @out_indices.setter
       def        A (      self		:      Any  ,							lowercase		:      Dict							):



           '''simple docstring'''

           UpperCAmelCase			,	UpperCAmelCase     			=						get_aligned_output_features_output_indices(
               out_features=_SCREAMING_SNAKE_CASE  ,							out_indices=_SCREAMING_SNAKE_CASE  ,							stage_names=self.stage_names							)







       def        A (      self		:      Optional[Any]							):



           '''simple docstring'''

           UpperCAmelCase     			=						super().to_dict()
           UpperCAmelCase     			=						output.pop('''_out_features'''							)
           UpperCAmelCase     			=						output.pop('''_out_indices'''							)
           return output





"""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)}")






