

'''simple docstring'''

import os
import unittest

import pytest
from parameterized import parameterized

from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device


# skipping in unittest tests

lowercase__            =     [(1,)]




def  UpperCamelCase(	):
 UpperCAmelCase			:      Dict		   =					bool(os.getenv('RUN_SLOW'    ,			0      )      )
 if run_slow:
  assert True
 else:
  assert False, "should have been skipped"




def  UpperCamelCase(	):
 UpperCAmelCase			:      Optional[Any]		   =					bool(os.getenv('RUN_SLOW'    ,			0      )      )
 if run_slow and torch_device == "cuda":
  assert True
 else:
  assert False, "should have been skipped"




@require_torch
class 			A_					(							unittest.TestCase				):






     '''simple docstring'''



     @slow
     @require_torch_gpu
     def   UpperCAmelCase_			(						self					:	Optional[Any]			)		->      Dict:
      check_slow_torch_cuda()


     @require_torch_gpu
     @slow
     def   UpperCAmelCase_			(						self					:	str			)		->      Optional[int]:
      check_slow_torch_cuda()




     @parameterized.expand(lowercase_			)
     @slow
     def   UpperCAmelCase_			(						self					:	Optional[Any]	,     lowercase_					:	Tuple=None			)		->      str:
      check_slow()




@slow
@require_torch_gpu
def  UpperCamelCase(	):
 check_slow_torch_cuda()




@require_torch_gpu
@slow
def  UpperCamelCase(	):
 check_slow_torch_cuda()




@slow
@pytest.mark.parametrize('param'    ,			[1]      )
def  UpperCamelCase(	UpperCAmelCase_      ):
 check_slow()




@pytest.mark.parametrize('param'    ,			[1]      )
@slow
def  UpperCamelCase(	UpperCAmelCase_      ):
 check_slow()







'''simple docstring'''

from __future__ import annotations




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 assert n > 1 and a > 0 and greatest_common_divisor(UpperCAmelCase_    ,			UpperCAmelCase_      ) == 1
 ((UpperCAmelCase)   ,					(UpperCAmelCase)   ,					(UpperCAmelCase))			:      Dict		   =					extended_gcd(UpperCAmelCase_    ,			UpperCAmelCase_      )  # Implemented below
 UpperCAmelCase			:      int		   =					(b * s) % n
 return x




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 ((UpperCAmelCase)   ,					(UpperCAmelCase))			:      int		   =					extended_euclid(UpperCAmelCase_    ,			UpperCAmelCase_      )  # Implemented below
 if b < 0:
  UpperCAmelCase			:      Optional[int]		   =					(b % n + n) % n
 return b




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_    ,			UpperCAmelCase_      ):
 UpperCAmelCase			:      Tuple		   =					invert_modulo(UpperCAmelCase_    ,			UpperCAmelCase_      )
 UpperCAmelCase			:      List[Any]		   =					(b * s) % n
 return x




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 assert a >= 0 and b >= 0

 if b == 0:
  UpperCAmelCase   ,					UpperCAmelCase   ,					UpperCAmelCase			:      Dict		   =					a, 1, 0
 else:
  ((UpperCAmelCase)   ,					(UpperCAmelCase)   ,					(UpperCAmelCase))			:      Optional[int]		   =					extended_gcd(UpperCAmelCase_    ,			a % b      )
  UpperCAmelCase			:      Dict		   =					q
  UpperCAmelCase			:      int		   =					p - q * (a // b)

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

 return (d, x, y)




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 if b == 0:
  return (1, 0)
 ((UpperCAmelCase)   ,					(UpperCAmelCase))			:      Tuple		   =					extended_euclid(UpperCAmelCase_    ,			a % b      )
 UpperCAmelCase			:      Tuple		   =					a // b
 return (y, x - k * y)




def  UpperCamelCase(	UpperCAmelCase_    ,			UpperCAmelCase_      ):
 if a < b:
  UpperCAmelCase   ,					UpperCAmelCase			:      Union[str, Any]		   =					b, a

 while a % b != 0:
  UpperCAmelCase   ,					UpperCAmelCase			:      int		   =					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)




