code: 
  
  
  def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->int:
  
  
  
  
  
  
  
        """simple docstring"""
  
        if len(_UpperCamelCase     ) < len(_UpperCamelCase     ):
              return levenshtein_distance(_UpperCamelCase,    _UpperCamelCase     )
  
        if len(_UpperCamelCase     ) == 0:
              return len(_UpperCamelCase     )
  
        lowercase			:   List[str]					   =		list(range(len(_UpperCamelCase     ) + 1     )     )
  
        for i, ca in enumerate(_UpperCamelCase     ):
              lowercase			:   Union[str, Any]					   =		[i + 1]
  
              for j, ca in enumerate(_UpperCamelCase     ):
                    # Calculate insertions, deletions and substitutions
                    lowercase			:   Dict					   =		previous_row[j + 1] + 1
                    lowercase			:   List[str]					   =		current_row[j] + 1
                    lowercase			:   Tuple					   =		previous_row[j] + (ca != ca)
  
                    # Get the minimum to append to the current row
                    current_row.append(min(_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )     )
  
              # Store the previous row
              lowercase			:   Optional[Any]					   =		current_row
  
        # Returns the last element (distance)
        return previous_row[-1]
  
  
  if __name__ == "__main__":
    __a   				=      input('''Enter the first word:\n''').strip()
    __a   				=      input('''Enter the second word:\n''').strip()
  
    __a   				=      levenshtein_distance(first_word, second_word)
    print(F'''Levenshtein distance between {first_word} and {second_word} is {result}''')
  
  
style_context: 
  
  
  __a   				=      [
      [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 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->bool:
  
  
  
  
  
  
  
        """simple docstring"""
  
        return 0 <= row < rows and 0 <= col < cols
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->int:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Optional[int]					   =		len(_UpperCamelCase     )
        lowercase			:   str					   =		len(mat[0]     )
        if is_safe(_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     ) and (row, col) not in seen and mat[row][col] == 1:
              seen.add((row, col)     )
              return (
                  1
                  + depth_first_search(row + 1,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )
                  + depth_first_search(row - 1,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )
                  + depth_first_search(_UpperCamelCase,    col + 1,    _UpperCamelCase,    _UpperCamelCase     )
                  + depth_first_search(_UpperCamelCase,    col - 1,    _UpperCamelCase,    _UpperCamelCase     )
              )
        else:
              return 0
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->int:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   set					   =		set()
  
        lowercase			:   Tuple					   =		0
        for row, line in enumerate(_UpperCamelCase     ):
              for col, item in enumerate(_UpperCamelCase     ):
                    if item == 1 and (row, col) not in seen:
                          # Maximizing the area
                          lowercase			:   Tuple					   =		max(_UpperCamelCase,    depth_first_search(_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )     )
        return max_area
  
  
  if __name__ == "__main__":
    import doctest
  
    print(find_max_area(matrix))  # Output -> 6
    doctest.testmod()
  
  