code: 
  
  
  
  
  
  '''simple docstring'''
  
  from __future__ import annotations
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int      , __lowerCamelCase				:					int					)		->tuple[float, float]:
      assert (
          c % greatest_common_divisor(__lowerCamelCase      , __lowerCamelCase					) == 0
      )  # greatest_common_divisor(a,b) function implemented below
      ((_SCREAMING_SNAKE_CASE)       , (_SCREAMING_SNAKE_CASE)       , (_SCREAMING_SNAKE_CASE))             =    extended_gcd(__lowerCamelCase      , __lowerCamelCase					)  # extended_gcd(a,b) function implemented below
      _SCREAMING_SNAKE_CASE             =    c / d
      return (r * x, r * y)
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int      , __lowerCamelCase				:					int      , __lowerCamelCase				:					int = 2					)		->None:
      ((_SCREAMING_SNAKE_CASE)       , (_SCREAMING_SNAKE_CASE))             =    diophantine(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)  # Initial value
      _SCREAMING_SNAKE_CASE             =    greatest_common_divisor(__lowerCamelCase      , __lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    a // d
      _SCREAMING_SNAKE_CASE             =    b // d
  
      for i in range(__lowerCamelCase					):
          _SCREAMING_SNAKE_CASE             =    xa + i * q
          _SCREAMING_SNAKE_CASE             =    ya - i * p
          print(__lowerCamelCase      , __lowerCamelCase					)
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int					)		->int:
      if a < b:
          _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    b, a
  
      while a % b != 0:
          _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    b, a % b
  
      return b
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int					)		->tuple[int, int, int]:
      assert a >= 0 and b >= 0
  
      if b == 0:
          _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    a, 1, 0
      else:
          ((_SCREAMING_SNAKE_CASE)       , (_SCREAMING_SNAKE_CASE)       , (_SCREAMING_SNAKE_CASE))             =    extended_gcd(__lowerCamelCase      , a % b					)
          _SCREAMING_SNAKE_CASE             =    q
          _SCREAMING_SNAKE_CASE             =    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: 
  
  
  
  
  
  '''simple docstring'''
  
  import json
  import os
  import tempfile
  import unittest
  
  from transformers.modelcard import ModelCard
  
  
  class       a_  (       unittest.TestCase ):
  
      '''simple docstring'''
  
  
      def     snake_case_(	self )	->     int:
          _SCREAMING_SNAKE_CASE             =    {
              """model_details""": {
                  """Organization""": """testing""",
                  """Model date""": """today""",
                  """Model version""": """v2.1, Developed by Test Corp in 2019.""",
                  """Architecture""": """Convolutional Neural Network.""",
              },
              """metrics""": """BLEU and ROUGE-1""",
              """evaluation_data""": {
                  """Datasets""": {"""BLEU""": """My-great-dataset-v1""", """ROUGE-1""": """My-short-dataset-v2.1"""},
                  """Preprocessing""": """See details on https://arxiv.org/pdf/1810.03993.pdf""",
              },
              """training_data""": {
                  """Dataset""": """English Wikipedia dump dated 2018-12-01""",
                  """Preprocessing""": (
                      """Using SentencePiece vocabulary of size 52k tokens. See details on"""
                      """ https://arxiv.org/pdf/1810.03993.pdf"""
                  ),
              },
              """quantitative_analyses""": {"""BLEU""": 55.1, """ROUGE-1""": 76},
          }
  
  
      def     snake_case_(	self )	->     Tuple:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
          self.assertTrue(hasattr(A				,	"""model_details""" ) )
          self.assertTrue(hasattr(A				,	"""intended_use""" ) )
          self.assertTrue(hasattr(A				,	"""factors""" ) )
          self.assertTrue(hasattr(A				,	"""metrics""" ) )
          self.assertTrue(hasattr(A				,	"""evaluation_data""" ) )
          self.assertTrue(hasattr(A				,	"""training_data""" ) )
          self.assertTrue(hasattr(A				,	"""quantitative_analyses""" ) )
          self.assertTrue(hasattr(A				,	"""ethical_considerations""" ) )
          self.assertTrue(hasattr(A				,	"""caveats_and_recommendations""" ) )
  
  
      def     snake_case_(	self )	->     List[str]:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
          _SCREAMING_SNAKE_CASE             =    json.loads(modelcard.to_json_string() )
          for key, value in self.inputs_dict.items():
              self.assertEqual(obj[key]				,	A )
  
  
      def     snake_case_(	self )	->     Any:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
  
          with tempfile.TemporaryDirectory() as tmpdirname:
              _SCREAMING_SNAKE_CASE             =    os.path.join(A				,	"""modelcard.json""" )
              model_card_first.to_json_file(A )
              _SCREAMING_SNAKE_CASE             =    ModelCard.from_json_file(A )
  
          self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )
  
  
  
  
  
      def     snake_case_(	self )	->     List[Any]:
          _SCREAMING_SNAKE_CASE             =    ModelCard.from_dict(self.inputs_dict )
  
          with tempfile.TemporaryDirectory() as tmpdirname:
              model_card_first.save_pretrained(A )
              _SCREAMING_SNAKE_CASE             =    ModelCard.from_pretrained(A )
  
          self.assertEqual(model_card_second.to_dict()				,	model_card_first.to_dict() )
  
  
  
  