code: 
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  __UpperCAmelCase      = {'''configuration_qdqbert''': ['''QDQBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''QDQBertConfig''']}
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      __UpperCAmelCase      = [
          '''QDQBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''QDQBertForMaskedLM''',
          '''QDQBertForMultipleChoice''',
          '''QDQBertForNextSentencePrediction''',
          '''QDQBertForQuestionAnswering''',
          '''QDQBertForSequenceClassification''',
          '''QDQBertForTokenClassification''',
          '''QDQBertLayer''',
          '''QDQBertLMHeadModel''',
          '''QDQBertModel''',
          '''QDQBertPreTrainedModel''',
          '''load_tf_weights_in_qdqbert''',
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_qdqbert import QDQBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, QDQBertConfig
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_qdqbert import (
              QDQBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              QDQBertForMaskedLM,
              QDQBertForMultipleChoice,
              QDQBertForNextSentencePrediction,
              QDQBertForQuestionAnswering,
              QDQBertForSequenceClassification,
              QDQBertForTokenClassification,
              QDQBertLayer,
              QDQBertLMHeadModel,
              QDQBertModel,
              QDQBertPreTrainedModel,
              load_tf_weights_in_qdqbert,
          )
  
  
  else:
      import sys
  
      __UpperCAmelCase      = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import sys
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
     # base cases
     if abs(snake_case__			) == 1:
        return a, 0
     elif abs(snake_case__			) == 1:
        return 0, b
  
     UpperCamelCase			,  UpperCamelCase					:						Dict					=			a, b
     UpperCamelCase			,  UpperCamelCase					:						int					=			1, 0
     UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			0, 1
  
     while remainder != 0:
        UpperCamelCase					:						str					=			old_remainder // remainder
        UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			remainder, old_remainder - quotient * remainder
        UpperCamelCase			,  UpperCamelCase					:						List[Any]					=			coeff_a, old_coeff_a - quotient * coeff_a
        UpperCamelCase			,  UpperCamelCase					:						Optional[Any]					=			coeff_b, old_coeff_b - quotient * coeff_b
  
     # sign correction for negative numbers
     if a < 0:
        UpperCamelCase					:						Dict					=			-old_coeff_a
     if b < 0:
        UpperCamelCase					:						Any					=			-old_coeff_b
  
     return old_coeff_a, old_coeff_b
  def 	UpperCamelCase			(     )			->  Tuple:
     if len(sys.argv			) < 3:
        print('2 integer arguments required'			)
        return 1
     UpperCamelCase					:						Union[str, Any]					=			int(sys.argv[1]			)
     UpperCamelCase					:						Optional[int]					=			int(sys.argv[2]			)
     print(extended_euclidean_algorithm(snake_case__ ,  snake_case__			)			)
     return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  
  
  
  