


import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


_snake_case				=			set()
_snake_case				=			get_logger(__name__)







def 	A (		A__ = None			):

     def decorator(A__			):
          global _emitted_deprecation_warnings

          if inspect.isclass(A__			):
               UpperCAmelCase    :					Optional[Any]			=      deprecated_class_or_function.__init__
               UpperCAmelCase    :					List[str]			=      deprecated_class_or_function.__name__
          else:
               UpperCAmelCase    :					List[str]			=      deprecated_class_or_function
               UpperCAmelCase    :					Any			=      deprecated_function.__name__
               # Support deprecating __init__ class method: class name instead
               UpperCAmelCase    :					str			=      name if name != "__init__" else deprecated_function.__qualname__.split("."			)[-2]

          UpperCAmelCase    :					List[str]			=      (
              f'{name} is deprecated and will be removed in the next major version of datasets.' + f' {help_message}'
              if help_message
              else ""
          )

          @wraps(A__			)
          def wrapper(*A__		,		**A__			):
               UpperCAmelCase    :					Union[str, Any]			=      hash(A__			)
               if func_hash not in _emitted_deprecation_warnings:
                    warnings.warn(A__		,		category=A__		,		stacklevel=2			)
                    _emitted_deprecation_warnings.add(A__			)
               return deprecated_function(*A__		,		**A__			)

          UpperCAmelCase    :					Optional[int]			=      "deprecated"

          if inspect.isclass(A__			):
               UpperCAmelCase    :					int			=      wrapper
               return deprecated_class_or_function
          else:
               return wrapper

     return decorator




class  A_ (			enum.EnumMeta  ):







 """simple docstring"""





 def __getattribute__(      cls       :			Tuple							,     _a       :			str					)     ->      List[Any]:
      UpperCAmelCase    :					Any			=      super().__getattribute__(_a					)
      if isinstance(_a							,     enum.Enum					) and obj._on_access:
           obj._on_access()
      return obj
 def __getitem__(      cls       :			str							,     _a       :			Any					)     ->      str:
      UpperCAmelCase    :					List[Any]			=      super().__getitem__(_a					)
      if member._on_access:
           member._on_access()
      return member

 def __call__(      cls       :			int							,     _a       :			Optional[Any]							,     _a       :			Dict=None							,     *, _a       :			Optional[Any]=None							,     _a       :			int=None							,     _a       :			Union[str, Any]=None							,     _a       :			str=1					)     ->      int:
      UpperCAmelCase    :					List[str]			=      super().__call__(_a							,     _a							,     module=_a							,     qualname=_a							,     type=_a							,     start=_a					)
      if isinstance(_a							,     enum.Enum					) and obj._on_access:
           obj._on_access()
      return obj




class  A_ (			enum.Enum   ,    metaclass=a_  ):







 """simple docstring"""





 def __new__(      cls       :			Union[str, Any]							,     _a       :			Optional[Any]					)     ->      Optional[int]:
      UpperCAmelCase    :					Union[str, Any]			=      object.__new__(cls					)
      UpperCAmelCase    :					List[Any]			=      value
      UpperCAmelCase    :					str			=      member.deprecate
      return member
 @property
 def 	_UpperCamelCase     (      self       :			Dict					)     ->      List[Any]:
      return ""

 def 	_UpperCamelCase     (      self       :			Optional[Any]					)     ->      Tuple:
      UpperCAmelCase    :					str			=      f' {self.help_message}' if self.help_message else ""
      warnings.warn(
          f'\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'
          + help_message							,     _a							,     stacklevel=3							,     )







from __future__ import annotations

import sys







def 	A (		A__		,		A__			):
     # base cases
     if abs(A__			) == 1:
          return a, 0
     elif abs(A__			) == 1:
          return 0, b

     UpperCAmelCase	,			UpperCAmelCase    :					Any			=      a, b
     UpperCAmelCase	,			UpperCAmelCase    :					List[Any]			=      1, 0
     UpperCAmelCase	,			UpperCAmelCase    :					Union[str, Any]			=      0, 1

     while remainder != 0:
          UpperCAmelCase    :					Union[str, Any]			=      old_remainder // remainder
          UpperCAmelCase	,			UpperCAmelCase    :					Dict			=      remainder, old_remainder - quotient * remainder
          UpperCAmelCase	,			UpperCAmelCase    :					int			=      coeff_a, old_coeff_a - quotient * coeff_a
          UpperCAmelCase	,			UpperCAmelCase    :					Optional[Any]			=      coeff_b, old_coeff_b - quotient * coeff_b

     # sign correction for negative numbers
     if a < 0:
          UpperCAmelCase    :					Union[str, Any]			=      -old_coeff_a
     if b < 0:
          UpperCAmelCase    :					int			=      -old_coeff_b

     return old_coeff_a, old_coeff_b







def 	A (		):
     if len(sys.argv			) < 3:
          print("2 integer arguments required"			)
          return 1
     UpperCAmelCase    :					Union[str, Any]			=      int(sys.argv[1]			)
     UpperCAmelCase    :					Any			=      int(sys.argv[2]			)
     print(extended_euclidean_algorithm(A__		,		A__			)			)
     return 0


if __name__ == "__main__":
      raise SystemExit(main())



