code: 
  
  
  from __future__ import annotations
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_			)						->							tuple[float, float]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         assert (
             c % greatest_common_divisor(UpperCAmelCase_    ,     UpperCAmelCase_			) == 0
         )  # greatest_common_divisor(a,b) function implemented below
         ((_lowercase)       ,	(_lowercase)       ,	(_lowercase))					:				str           =			extended_gcd(UpperCAmelCase_    ,     UpperCAmelCase_			)  # extended_gcd(a,b) function implemented below
         _lowercase					:				List[Any]           =			c / d
         return (r * x, r * y)
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_ = 2			)						->							None:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         ((_lowercase)       ,	(_lowercase))					:				List[str]           =			diophantine(UpperCAmelCase_    ,     UpperCAmelCase_    ,     UpperCAmelCase_			)  # Initial value
         _lowercase					:				Dict           =			greatest_common_divisor(UpperCAmelCase_    ,     UpperCAmelCase_			)
         _lowercase					:				List[str]           =			a // d
         _lowercase					:				Dict           =			b // d
  
         for i in range(UpperCAmelCase_			):
                _lowercase					:				Tuple           =			xa + i * q
                _lowercase					:				Union[str, Any]           =			ya - i * p
                print(UpperCAmelCase_    ,     UpperCAmelCase_			)
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_			)						->							int:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         if a < b:
                _lowercase       ,	_lowercase					:				List[Any]           =			b, a
  
         while a % b != 0:
                _lowercase       ,	_lowercase					:				Any           =			b, a % b
  
         return b
  
  def   UpperCamelCase__   (    UpperCAmelCase_    ,     UpperCAmelCase_			)						->							tuple[int, int, int]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         assert a >= 0 and b >= 0
  
         if b == 0:
                _lowercase       ,	_lowercase       ,	_lowercase					:				Optional[int]           =			a, 1, 0
         else:
                ((_lowercase)       ,	(_lowercase)       ,	(_lowercase))					:				List[Any]           =			extended_gcd(UpperCAmelCase_    ,     a % b			)
                _lowercase					:				int           =			q
                _lowercase					:				Any           =			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)
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  UpperCamelCase__				       =			{
      'configuration_wav2vec2_conformer': [
          'WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
          'Wav2Vec2ConformerConfig',
      ],
  }
  
  
  try:
     if not is_torch_available():
        raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
     pass
  else:
     UpperCamelCase__				       =			[
         'WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'Wav2Vec2ConformerForAudioFrameClassification',
         'Wav2Vec2ConformerForCTC',
         'Wav2Vec2ConformerForPreTraining',
         'Wav2Vec2ConformerForSequenceClassification',
         'Wav2Vec2ConformerForXVector',
         'Wav2Vec2ConformerModel',
         'Wav2Vec2ConformerPreTrainedModel',
     ]
  
  if TYPE_CHECKING:
     from .configuration_wavaveca_conformer import (
         WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
         WavaVecaConformerConfig,
     )
  
     try:
        if not is_torch_available():
           raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
        pass
     else:
        from .modeling_wavaveca_conformer import (
            WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            WavaVecaConformerForAudioFrameClassification,
            WavaVecaConformerForCTC,
            WavaVecaConformerForPreTraining,
            WavaVecaConformerForSequenceClassification,
            WavaVecaConformerForXVector,
            WavaVecaConformerModel,
            WavaVecaConformerPreTrainedModel,
        )
  
  else:
     import sys
  
     UpperCamelCase__				       =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)