




import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


lowerCamelCase       :	List[str]									=     {
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

lowerCamelCase       :	Any									=     logging.WARNING

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					os.getenv('DATASETS_VERBOSITY'			,							lowercase  )
      if env_level_str:
            if env_level_str in log_levels:
                  return log_levels[env_level_str]
            else:
                  logging.getLogger().warning(
                      f"""Unknown option DATASETS_VERBOSITY={env_level_str}, """
                      f"""has to be one of: { ", ".join(log_levels.keys()  ) }"""  )
      return _default_log_level

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return __name__.split('.'  )[0]

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return logging.getLogger(_get_library_name()  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					_get_library_root_logger()
      library_root_logger.setLevel(_get_default_logging_level()  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					_get_library_root_logger()
      library_root_logger.setLevel(logging.NOTSET  )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: Optional[int] = None  ):


      '''simple docstring'''



      if name is None:
            lowerCamelCase_	  =					_get_library_name()
      return logging.getLogger(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return _get_library_root_logger().getEffectiveLevel()

def     _SCREAMING_SNAKE_CASE    (							lowercase			: Optional[int]  ):


      '''simple docstring'''



      _get_library_root_logger().setLevel(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return set_verbosity(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return set_verbosity(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return set_verbosity(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      return set_verbosity(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					False

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      lowerCamelCase_	  =					True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()







class 						A:



 '''simple docstring'''


 def __init__(       self      :						Any		,							*A_      :						str		,							**A_      :						Optional[Any]						)     ->			int:  # pylint: disable=unused-argument

       """simple docstring"""






       lowerCamelCase_	  =					args[0] if args else None

 def __iter__(       self      :						Optional[int]						)     ->			Any:

       """simple docstring"""






       return iter(self._iterator						)

 def __getattr__(       self      :						int		,							A_      :						Optional[int]						)     ->			Dict:

       """simple docstring"""






       def empty_fn(*A_      :						Optional[int]		,							**A_      :						str						):  # pylint: disable=unused-argument
             return

       return empty_fn

 def __enter__(       self      :						Tuple						)     ->			List[Any]:

       """simple docstring"""






       return self





 def __exit__(       self      :						int		,							A_      :						Optional[int]		,							A_      :						Union[str, Any]		,							A_      :						Optional[int]						)     ->			str:

       """simple docstring"""






       return

lowerCamelCase       :	Dict									=     True







class 						A:



 '''simple docstring'''


 def __call__(       self      :						Dict		,							*A_      :						int		,							A_      :						Any=False		,							**A_      :						Any						)     ->			Optional[int]:

       """simple docstring"""






       if _tqdm_active and not disable:
             return tqdm_lib.tqdm(*lowerCamelCase_		,							**lowerCamelCase_						)
       else:
             return EmptyTqdm(*lowerCamelCase_		,							**lowerCamelCase_						)

 def        a__				(       self      :						str		,							*A_      :						Union[str, Any]		,							**A_      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					None
       if _tqdm_active:
             return tqdm_lib.tqdm.set_lock(*lowerCamelCase_		,							**lowerCamelCase_						)





 def        a__				(       self      :						int						)     ->			Any:

       """simple docstring"""






       if _tqdm_active:
             return tqdm_lib.tqdm.get_lock()

lowerCamelCase       :	Union[str, Any]									=     _tqdm_cls()

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      global _tqdm_active
      return bool(_tqdm_active  )

def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      global _tqdm_active
      lowerCamelCase_	  =					True






def     _SCREAMING_SNAKE_CASE    (							):


      '''simple docstring'''



      global _tqdm_active
      lowerCamelCase_	  =					False









class 						A:



 '''simple docstring'''


 def __init__(       self      :						Dict						)     ->			Optional[int]:

       """simple docstring"""






       lowerCamelCase_	  =					0
       lowerCamelCase_	  =					0
       lowerCamelCase_	  =					{}

 def        a__				(       self      :						Union[str, Any]		,							A_      :						List[Any]						)     ->			int:

       """simple docstring"""






       if vertex not in self.adjacency:
             lowerCamelCase_	  =					{}
             self.num_vertices += 1

 def        a__				(       self      :						int		,							A_      :						int		,							A_      :						Optional[Any]		,							A_      :						List[str]						)     ->			Tuple:

       """simple docstring"""






       self.add_vertex(A_						)
       self.add_vertex(A_						)

       if head == tail:
             return

       lowerCamelCase_	  =					weight
       lowerCamelCase_	  =					weight

 def        a__				(       self      :						Optional[int]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					self.get_edges()
       for edge in edges:
             lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					edge
             edges.remove((tail, head, weight)						)
       for i in range(len(A_						)						):
             lowerCamelCase_	  =					list(edges[i]						)

       edges.sort(key=lambda A_						: e[2]						)
       for i in range(len(A_						) - 1						):
             if edges[i][2] >= edges[i + 1][2]:
                   lowerCamelCase_	  =					edges[i][2] + 1
       for edge in edges:
             lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					edge
             lowerCamelCase_	  =					weight
             lowerCamelCase_	  =					weight

 def __str__(       self      :						str						)     ->			Optional[int]:

       """simple docstring"""






       lowerCamelCase_	  =					''
       for tail in self.adjacency:
             for head in self.adjacency[tail]:
                   lowerCamelCase_	  =					self.adjacency[head][tail]
                   string += f"""{head} -> {tail} == {weight}\n"""
       return string.rstrip('\n'						)

 def        a__				(       self      :						Union[str, Any]						)     ->			Union[str, Any]:

       """simple docstring"""






       lowerCamelCase_	  =					[]
       for tail in self.adjacency:
             for head in self.adjacency[tail]:
                   output.append((tail, head, self.adjacency[head][tail])						)
       return output

 def        a__				(       self      :						List[str]						)     ->			int:

       """simple docstring"""






       return self.adjacency.keys()

 @staticmethod
 def        a__				(       A_      :						Optional[Any]=None		,							A_      :						List[str]=None						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					Graph()
       if vertices is None:
             lowerCamelCase_	  =					[]
       if edges is None:
             lowerCamelCase_	  =					[]
       for vertex in vertices:
             g.add_vertex(A_						)
       for edge in edges:
             g.add_edge(*A_						)
       return g







 class 						A:



  '''simple docstring'''


  def __init__(       self      :						Optional[int]						)     ->			int:

        """simple docstring"""






        lowerCamelCase_	  =					{}
        lowerCamelCase_	  =					{}

  def __len__(       self      :						Any						)     ->			List[str]:

        """simple docstring"""






        return len(self.parent						)

  def        a__				(       self      :						List[str]		,							A_      :						Any						)     ->			Dict:

        """simple docstring"""






        if item in self.parent:
              return self.find(A_						)

        lowerCamelCase_	  =					item
        lowerCamelCase_	  =					0
        return item

  def        a__				(       self      :						List[str]		,							A_      :						Tuple						)     ->			Optional[int]:

        """simple docstring"""






        if item not in self.parent:
              return self.make_set(A_						)
        if item != self.parent[item]:
              lowerCamelCase_	  =					self.find(self.parent[item]						)
        return self.parent[item]





  def        a__				(       self      :						Any		,							A_      :						int		,							A_      :						Tuple						)     ->			Union[str, Any]:

        """simple docstring"""






        lowerCamelCase_	  =					self.find(A_						)
        lowerCamelCase_	  =					self.find(A_						)

        if roota == roota:
              return roota

        if self.rank[roota] > self.rank[roota]:
              lowerCamelCase_	  =					roota
              return roota

        if self.rank[roota] < self.rank[roota]:
              lowerCamelCase_	  =					roota
              return roota

        if self.rank[roota] == self.rank[roota]:
              self.rank[roota] += 1
              lowerCamelCase_	  =					roota
              return roota
        return None

 @staticmethod
 def        a__				(       A_      :						int						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_	  =					graph.num_vertices

       lowerCamelCase_	  =					Graph.UnionFind()
       lowerCamelCase_	  =					[]
       while num_components > 1:
             lowerCamelCase_	  =					{}
             for vertex in graph.get_vertices():
                   lowerCamelCase_	  =					-1

             lowerCamelCase_	  =					graph.get_edges()
             for edge in edges:
                   lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					edge
                   edges.remove((tail, head, weight)						)
             for edge in edges:
                   lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					edge
                   lowerCamelCase_	  =					union_find.find(A_						)
                   lowerCamelCase_	  =					union_find.find(A_						)
                   if seta != seta:
                         if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                               lowerCamelCase_	  =					[head, tail, weight]

                         if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                               lowerCamelCase_	  =					[head, tail, weight]
             for vertex in cheap_edge:
                   if cheap_edge[vertex] != -1:
                         lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					cheap_edge[vertex]
                         if union_find.find(A_						) != union_find.find(A_						):
                               union_find.union(A_		,							A_						)
                               mst_edges.append(cheap_edge[vertex]						)
                               lowerCamelCase_	  =					num_components - 1
       lowerCamelCase_	  =					Graph.build(edges=A_						)
       return mst



