





'''simple docstring'''





from __future__ import annotations


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int      ,						_lowercase    :   int )      ->       tuple[float, float]:




		'''simple docstring'''
		assert (
		    c % greatest_common_divisor(_lowercase      ,						_lowercase ) == 0
		)  # greatest_common_divisor(a,b) function implemented below
		(lowercase__)				:			Tuple            =		extended_gcd(_lowercase      ,						_lowercase )  # extended_gcd(a,b) function implemented below
		lowercase__				:			int            =		c / d
		return (r * x, r * y)


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int      ,						_lowercase    :   int      ,						_lowercase    :   int = 2 )      ->       None:




		'''simple docstring'''
		(lowercase__)				:			List[Any]            =		diophantine(_lowercase      ,						_lowercase      ,						_lowercase )  # Initial value
		lowercase__				:			Tuple            =		greatest_common_divisor(_lowercase      ,						_lowercase )
		lowercase__				:			Any            =		a // d
		lowercase__				:			List[str]            =		b // d

		for i in range(_lowercase ):
				lowercase__				:			str            =		xa + i * q
				lowercase__				:			Tuple            =		ya - i * p
				print(_lowercase      ,						_lowercase )


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int )      ->       int:




		'''simple docstring'''
		if a < b:
				lowercase__				:			Union[str, Any]            =		b, a

		while a % b != 0:
				lowercase__				:			Dict            =		b, a % b

		return b


def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int      ,						_lowercase    :   int )      ->       tuple[int, int, int]:




		'''simple docstring'''
		assert a >= 0 and b >= 0

		if b == 0:
				lowercase__				:			int            =		a, 1, 0
		else:
				(lowercase__)				:			Optional[Any]            =		extended_gcd(_lowercase      ,						a % b )
				lowercase__				:			List[Any]            =		q
				lowercase__				:			Union[str, 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)









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCamelCase:  Dict   =   {
    """configuration_deberta_v2""": ["""DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DebertaV2Config""", """DebertaV2OnnxConfig"""],
    """tokenization_deberta_v2""": ["""DebertaV2Tokenizer"""],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  List[Any]   =   ["""DebertaV2TokenizerFast"""]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  str   =   [
			    """TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """TFDebertaV2ForMaskedLM""",
			    """TFDebertaV2ForQuestionAnswering""",
			    """TFDebertaV2ForSequenceClassification""",
			    """TFDebertaV2ForTokenClassification""",
			    """TFDebertaV2Model""",
			    """TFDebertaV2PreTrainedModel""",
			]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__UpperCamelCase:  Tuple   =   [
			    """DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """DebertaV2ForMaskedLM""",
			    """DebertaV2ForMultipleChoice""",
			    """DebertaV2ForQuestionAnswering""",
			    """DebertaV2ForSequenceClassification""",
			    """DebertaV2ForTokenClassification""",
			    """DebertaV2Model""",
			    """DebertaV2PreTrainedModel""",
			]


if TYPE_CHECKING:
			from .configuration_deberta_va import (
			    DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    DebertaVaConfig,
			    DebertaVaOnnxConfig,
			)
			from .tokenization_deberta_va import DebertaVaTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_deberta_va import (
						    TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFDebertaVaForMaskedLM,
						    TFDebertaVaForQuestionAnswering,
						    TFDebertaVaForSequenceClassification,
						    TFDebertaVaForTokenClassification,
						    TFDebertaVaModel,
						    TFDebertaVaPreTrainedModel,
						)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_deberta_va import (
						    DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DebertaVaForMaskedLM,
						    DebertaVaForMultipleChoice,
						    DebertaVaForQuestionAnswering,
						    DebertaVaForSequenceClassification,
						    DebertaVaForTokenClassification,
						    DebertaVaModel,
						    DebertaVaPreTrainedModel,
						)

else:
			import sys

			__UpperCamelCase:  Optional[Any]   =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


