


"""simple docstring"""







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__lowercase          = logging.get_logger(__name__)

__lowercase          = {
    'facebook/convnext-tiny-224': 'https://huggingface.co/facebook/convnext-tiny-224/resolve/main/config.json',
    # See all ConvNeXT models at https://huggingface.co/models?filter=convnext
}






class 		_A    (    SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_    ):







    """simple docstring"""




    UpperCAmelCase			:				Any      =			"""convnext"""






    def __init__(   self							:       Optional[Any]							,					__UpperCAmelCase							:       int=3							,					__UpperCAmelCase							:       List[str]=4							,					__UpperCAmelCase							:       int=4							,					__UpperCAmelCase							:       str=None							,					__UpperCAmelCase							:       Union[str, Any]=None							,					__UpperCAmelCase							:       Tuple="gelu"							,					__UpperCAmelCase							:       Optional[Any]=0.02							,					__UpperCAmelCase							:       int=1e-12							,					__UpperCAmelCase							:       Tuple=1e-6							,					__UpperCAmelCase							:       Optional[Any]=0.0							,					__UpperCAmelCase							:       Tuple=224							,					__UpperCAmelCase							:       int=None							,					__UpperCAmelCase							:       Optional[int]=None							,					**__UpperCAmelCase							:       Any							,					):
      super().__init__(**UpperCamelCase__)

      a		:						List[Any] 				=     num_channels
      a		:						int 				=     patch_size
      a		:						Optional[int] 				=     num_stages
      a		:						Optional[Any] 				=     [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
      a		:						str 				=     [3, 3, 9, 3] if depths is None else depths
      a		:						Optional[int] 				=     hidden_act
      a		:						Tuple 				=     initializer_range
      a		:						Union[str, Any] 				=     layer_norm_eps
      a		:						str 				=     layer_scale_init_value
      a		:						Dict 				=     drop_path_rate
      a		:						str 				=     image_size
      a		:						List[Any] 				=     ['''stem'''] + [f'''stage{idx}''' for idx in range(1							,					len(self.depths) + 1)]
      a		:						Optional[int] 				=     get_aligned_output_features_output_indices(
          out_features=UpperCamelCase__							,					out_indices=UpperCamelCase__							,					stage_names=self.stage_names)






class 		_A    (    SCREAMING_SNAKE_CASE_    ):







    """simple docstring"""




    UpperCAmelCase			:				int      =			version.parse("""1.11"""    )






    @property
    def       __snake_case				(   self							:       Dict):
      return OrderedDict(
          [
              ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
          ])






    @property
    def       __snake_case				(   self							:       Tuple):
      return 1e-5








def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Dict				,    __UpperCamelCase			:    Dict							)			->							List[Any]:

				"""simple docstring"""







				if len(str(__UpperCamelCase							)							) == 1 or len(str(__UpperCamelCase							)							) == 1:
								return a * b

				A__	:						List[str]								=				max(len(str(__UpperCamelCase							)							)				,    len(str(__UpperCamelCase							)							)							)
				A__	:						Any								=				ma // 2

				A__							,				A__	:						Union[str, Any]								=				divmod(__UpperCamelCase				,    10**ma							)
				A__							,				A__	:						Tuple								=				divmod(__UpperCamelCase				,    10**ma							)

				A__	:						Optional[int]								=				karatsuba(__UpperCamelCase				,    __UpperCamelCase							)
				A__	:						Tuple								=				karatsuba((aa + aa)				,    (ba + ba)							)
				A__	:						Optional[int]								=				karatsuba(__UpperCamelCase				,    __UpperCamelCase							)

				return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)

def 					SCREAMING_SNAKE_CASE  (   )			->							Dict:

				"""simple docstring"""







				print(karatsuba(1_54_63				,    2_34_89							)							)


if __name__ == "__main__":
					main()