


from __future__ import annotations
def        __lowerCamelCase		(				UpperCAmelCase_		:	Optional[int]				,						UpperCAmelCase_		:	List[Any]				,						UpperCAmelCase_		:	Dict		):




      """simple docstring"""





      assert n > 1 and a > 0 and greatest_common_divisor(UpperCAmelCase_				,						UpperCAmelCase_		) == 1
      ((a)							,       (a)							,       (a))		:Dict											= extended_gcd(UpperCAmelCase_				,						UpperCAmelCase_		)  # Implemented below
      a		:Optional[Any]											= (b * s) % n
      return x
def        __lowerCamelCase		(				UpperCAmelCase_		:	str				,						UpperCAmelCase_		:	Tuple		):




      """simple docstring"""





      ((a)							,       (a))		:Dict											= extended_euclid(UpperCAmelCase_				,						UpperCAmelCase_		)  # Implemented below
      if b < 0:
            a		:List[str]											= (b % n + n) % n
      return b
def        __lowerCamelCase		(				UpperCAmelCase_		:	Tuple				,						UpperCAmelCase_		:	Dict				,						UpperCAmelCase_		:	int		):




      """simple docstring"""





      a		:str											= invert_modulo(UpperCAmelCase_				,						UpperCAmelCase_		)
      a		:List[Any]											= (b * s) % n
      return x
def        __lowerCamelCase		(				UpperCAmelCase_		:	Dict				,						UpperCAmelCase_		:	int		):




      """simple docstring"""





      assert a >= 0 and b >= 0

      if b == 0:
            a							,       a							,       a		:List[str]											= a, 1, 0
      else:
            ((a)							,       (a)							,       (a))		:Optional[Any]											= extended_gcd(UpperCAmelCase_				,						a % b		)
            a		:Union[str, Any]											= q
            a		:int											= p - q * (a // b)

      assert a % d == 0 and b % d == 0
      assert d == a * x + b * y

      return (d, x, y)
def        __lowerCamelCase		(				UpperCAmelCase_		:	Dict				,						UpperCAmelCase_		:	str		):




      """simple docstring"""





      if b == 0:
            return (1, 0)
      ((a)							,       (a))		:int											= extended_euclid(UpperCAmelCase_				,						a % b		)
      a		:List[str]											= a // b
      return (y, x - k * y)
def        __lowerCamelCase		(				UpperCAmelCase_		:	Optional[int]				,						UpperCAmelCase_		:	List[str]		):




      """simple docstring"""





      if a < b:
            a							,       a		:Tuple											= b, a

      while a % b != 0:
            a							,       a		:Tuple											= b, a % b

      return b


if __name__ == "__main__":
     from doctest import testmod

     testmod(name='''modular_division''', verbose=True)
     testmod(name='''modular_division2''', verbose=True)
     testmod(name='''invert_modulo''', verbose=True)
     testmod(name='''extended_gcd''', verbose=True)
     testmod(name='''extended_euclid''', verbose=True)
     testmod(name='''greatest_common_divisor''', verbose=True)









import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


snake_case       :					Tuple        =  logging.get_logger(__name__)







class 	_snake_case						(   _snake_case							):




 def __init__(	self      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
       warnings.warn(
           '''The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
           ''' Please use ConvNextImageProcessor instead.'''      ,						_lowerCamelCase      ,						)
       super().__init__(*_lowerCamelCase      ,						**_lowerCamelCase					)





