
'''simple docstring'''
from __future__ import annotations







def 		A_(     A						:		int		,     A						:		int):
							if b == 0:
														return (1, 0)
							((UpperCamelCase)			,	(UpperCamelCase))   			=     extended_euclid(A		,     a % b)
							UpperCamelCase   			=     a // b
							return (y, x - k * y)







def 		A_(     A						:		int		,     A						:		int		,     A						:		int		,     A						:		int):
							((UpperCamelCase)			,	(UpperCamelCase))   			=     extended_euclid(A		,     A)
							UpperCamelCase   			=     na * na
							UpperCamelCase   			=     ra * x * na + ra * y * na
							return (n % m + m) % m







def 		A_(     A						:		int		,     A						:		int):
							((UpperCamelCase)			,	(UpperCamelCase))   			=     extended_euclid(A		,     A)
							if b < 0:
														UpperCamelCase   			=     (b % n + n) % n
							return b







def 		A_(     A						:		int		,     A						:		int		,     A						:		int		,     A						:		int):
							UpperCamelCase			,	UpperCamelCase   			=     invert_modulo(A		,     A), invert_modulo(A		,     A)
							UpperCamelCase   			=     na * na
							UpperCamelCase   			=     ra * x * na + ra * y * na
							return (n % m + m) % m


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

						testmod(name='chinese_remainder_theorem', verbose=True)
						testmod(name='chinese_remainder_theorem2', verbose=True)
						testmod(name='invert_modulo', verbose=True)
						testmod(name='extended_euclid', verbose=True)






'''simple docstring'''
from typing import TYPE_CHECKING

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


if is_sentencepiece_available():
						from ..ta.tokenization_ta import TaTokenizer
else:
						from ...utils.dummy_sentencepiece_objects import TaTokenizer

lowerCAmelCase					:    Tuple           = TaTokenizer

if is_tokenizers_available():
						from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
						from ...utils.dummy_tokenizers_objects import TaTokenizerFast

lowerCAmelCase					:    Optional[int]           = TaTokenizerFast

lowerCAmelCase					:    Any           = {'configuration_mt5': ['MT5Config', 'MT5OnnxConfig']}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase					:    Optional[int]           = [
						    'MT5EncoderModel',
						    'MT5ForConditionalGeneration',
						    'MT5ForQuestionAnswering',
						    'MT5Model',
						    'MT5PreTrainedModel',
						    'MT5Stack',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase					:    Dict           = ['TFMT5EncoderModel', 'TFMT5ForConditionalGeneration', 'TFMT5Model']

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase					:    Optional[Any]           = ['FlaxMT5EncoderModel', 'FlaxMT5ForConditionalGeneration', 'FlaxMT5Model']


if TYPE_CHECKING:
						from .configuration_mta import MTaConfig, MTaOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mta import (
												    MTaEncoderModel,
												    MTaForConditionalGeneration,
												    MTaForQuestionAnswering,
												    MTaModel,
												    MTaPreTrainedModel,
												    MTaStack,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
						import sys

						lowerCAmelCase					:    Tuple           = _LazyModule(
						    __name__,
						    globals()['__file__'],
						    _import_structure,
						    extra_objects={'MT5Tokenizer': MTaTokenizer, 'MT5TokenizerFast': MTaTokenizerFast},
						    module_spec=__spec__,
						)




