code: 
  
  from __future__ import annotations
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int					)				->							Dict:
  	assert (
  	    c % greatest_common_divisor(lowercase_ ,lowercase_					) == 0
  	)  # greatest_common_divisor(a,b) function implemented below
  	(__A)   : int								= extended_gcd(lowercase_ ,lowercase_					)  # extended_gcd(a,b) function implemented below
  	__A   : List[Any]								= c / d
  	return (r * x, r * y)
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int = 2					)				->							Dict:
  	(__A)   : Tuple								= diophantine(lowercase_ ,lowercase_ ,lowercase_					)  # Initial value
  	__A   : List[Any]								= greatest_common_divisor(lowercase_ ,lowercase_					)
  	__A   : Optional[int]								= a // d
  	__A   : Optional[Any]								= b // d
  
  	for i in range(lowercase_					):
  		__A   : Union[str, Any]								= xa + i * q
  		__A   : List[Any]								= ya - i * p
  		print(lowercase_ ,lowercase_					)
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int					)				->							List[str]:
  	if a < b:
  		__A   : Optional[Any]								= b, a
  
  	while a % b != 0:
  		__A   : Union[str, Any]								= b, a % b
  
  	return b
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int					)				->							Tuple:
  	assert a >= 0 and b >= 0
  
  	if b == 0:
  		__A   : Optional[Any]								= a, 1, 0
  	else:
  		(__A)   : Any								= extended_gcd(lowercase_ ,a % b					)
  		__A   : Any								= q
  		__A   : str								= 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: 
  
  UpperCAmelCase_       :				str		   =      [
      [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
  ]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int					)				->							bool:
  	return 0 <= row < rows and 0 <= col < cols
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      set ,a__						:      list[list[int]]					)				->							int:
  	__A   : Union[str, Any]								= len(a__					)
  	__A   : Any								= len(mat[0]					)
  	if is_safe(a__ ,a__ ,a__ ,a__					) and (row, col) not in seen and mat[row][col] == 1:
  		seen.add((row, col)					)
  		return (
  		    1
  		    + depth_first_search(row + 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(row - 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(a__ ,col + 1 ,a__ ,a__					)
  		    + depth_first_search(a__ ,col - 1 ,a__ ,a__					)
  		)
  	else:
  		return 0
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[list[int]]					)				->							int:
  	__A   : set								= set()
  
  	__A   : Union[str, Any]								= 0
  	for row, line in enumerate(a__					):
  		for col, item in enumerate(a__					):
  			if item == 1 and (row, col) not in seen:
  				# Maximizing the area
  				__A   : Optional[Any]								= max(a__ ,depth_first_search(a__ ,a__ ,a__ ,a__					)					)
  	return max_area
  
  
  if __name__ == "__main__":
  			import doctest
  
  			print(find_max_area(matrix))  # Output -> 6
  			doctest.testmod()
  
  
  
  
  
  