code: from typing import TYPE_CHECKING
  
  # rely on isort to merge the imports
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available
  
  
  UpperCAmelCase					=				{
      '''configuration_ernie_m''': ['''ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ErnieMConfig'''],
  }
  
  try:
   if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   UpperCAmelCase					=				['''ErnieMTokenizer''']
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   UpperCAmelCase					=				[
       '''ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''ErnieMForMultipleChoice''',
       '''ErnieMForQuestionAnswering''',
       '''ErnieMForSequenceClassification''',
       '''ErnieMForTokenClassification''',
       '''ErnieMModel''',
       '''ErnieMPreTrainedModel''',
       '''ErnieMForInformationExtraction''',
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_ernie_m import ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieMConfig
  
   try:
    if not is_sentencepiece_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .tokenization_ernie_m import ErnieMTokenizer
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_ernie_m import (
        ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST,
        ErnieMForInformationExtraction,
        ErnieMForMultipleChoice,
        ErnieMForQuestionAnswering,
        ErnieMForSequenceClassification,
        ErnieMForTokenClassification,
        ErnieMModel,
        ErnieMPreTrainedModel,
    )
  
  
  else:
   import sys
  
   UpperCAmelCase					=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
style_context: from __future__ import annotations
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int		,						lowercase_:	int		,						lowercase_:	int				):
         assert (
             c % greatest_common_divisor(lowercase_		,						lowercase_				) == 0
         )  # greatest_common_divisor(a,b) function implemented below
         ((_UpperCamelCase)						,      (_UpperCamelCase)						,      (_UpperCamelCase))     :       int  						=  extended_gcd(lowercase_		,						lowercase_				)  # extended_gcd(a,b) function implemented below
         _UpperCamelCase     :       List[Any]  						=  c / d
         return (r * x, r * y)
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int		,						lowercase_:	int		,						lowercase_:	int		,						lowercase_:	int = 2				):
         ((_UpperCamelCase)						,      (_UpperCamelCase))     :       Tuple  						=  diophantine(lowercase_		,						lowercase_		,						lowercase_				)  # Initial value
         _UpperCamelCase     :       List[Any]  						=  greatest_common_divisor(lowercase_		,						lowercase_				)
         _UpperCamelCase     :       Optional[int]  						=  a // d
         _UpperCamelCase     :       Optional[Any]  						=  b // d
  
         for i in range(lowercase_				):
                _UpperCamelCase     :       Union[str, Any]  						=  xa + i * q
                _UpperCamelCase     :       List[Any]  						=  ya - i * p
                print(lowercase_		,						lowercase_				)
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int		,						lowercase_:	int				):
         if a < b:
                _UpperCamelCase						,      _UpperCamelCase     :       Optional[Any]  						=  b, a
  
         while a % b != 0:
                _UpperCamelCase						,      _UpperCamelCase     :       Union[str, Any]  						=  b, a % b
  
         return b
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	int		,						lowercase_:	int				):
         assert a >= 0 and b >= 0
  
         if b == 0:
                _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase     :       Optional[Any]  						=  a, 1, 0
         else:
                ((_UpperCamelCase)						,      (_UpperCamelCase)						,      (_UpperCamelCase))     :       Any  						=  extended_gcd(lowercase_		,						a % b				)
                _UpperCamelCase     :       Any  						=  q
                _UpperCamelCase     :       str  						=  p - q * (a // b)
  
         assert a % d == 0 and b % d == 0
         assert d == a * x + b * y
  
         return (d, x, y)
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod(name='''diophantine''', verbose=True)
   testmod(name='''diophantine_all_soln''', verbose=True)
   testmod(name='''extended_gcd''', verbose=True)
   testmod(name='''greatest_common_divisor''', verbose=True)
  
  
  
  