




class 				__UpperCamelCase      :





				'''simple docstring'''



				def __init__(			self							,			UpperCAmelCase_    ):
											lowerCAmelCase =		data
											lowerCAmelCase =		42
											lowerCAmelCase =		42




def    UpperCAmelCase							(  _snake_case				):
							lowerCAmelCase =		0
							lowerCAmelCase =		x



def    UpperCAmelCase							(  _snake_case    ,			_snake_case				):
							lowerCAmelCase ,  lowerCAmelCase =		find_set(_snake_case				), find_set(_snake_case				)
							if x == y:
														return

							elif x.rank > y.rank:
														lowerCAmelCase =		x
							else:
														lowerCAmelCase =		y
														if x.rank == y.rank:
																					y.rank += 1



def    UpperCAmelCase							(  _snake_case				):






							if x != x.parent:
														lowerCAmelCase =		find_set(x.parent				)
							return x.parent



def    UpperCAmelCase							(  _snake_case				):
							lowerCAmelCase =		({0, 1, 2}, {3, 4, 5})
							for s in sets:
														if node.data in s:
																					return s
							lowerCAmelCase =		F"""{node.data} is not in {sets}"""
							raise ValueError(_snake_case				)



def    UpperCAmelCase							(  ):
							lowerCAmelCase =		[Node(_snake_case				) for i in range(6				)]
							for v in vertex:
														make_set(_snake_case				)

							union_set(vertex[0]    ,			vertex[1]				)
							union_set(vertex[1]    ,			vertex[2]				)
							union_set(vertex[3]    ,			vertex[4]				)
							union_set(vertex[3]    ,			vertex[5]				)

							for nodea in vertex:
														for nodea in vertex:
																					if find_python_set(_snake_case				).isdisjoint(find_python_set(_snake_case				)				):
																												assert find_set(_snake_case				) != find_set(_snake_case				)
																					else:
																												assert find_set(_snake_case				) == find_set(_snake_case				)


if __name__ == "__main__":
		test_disjoint_set()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


snake_case__   :				Dict						=	{
    'configuration_videomae': ['VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VideoMAEConfig'],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__   :				Any						=	[
           'VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST',
           'VideoMAEForPreTraining',
           'VideoMAEModel',
           'VideoMAEPreTrainedModel',
           'VideoMAEForVideoClassification',
       ]

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__   :				str						=	['VideoMAEFeatureExtractor']
       snake_case__   :				Tuple						=	['VideoMAEImageProcessor']

if TYPE_CHECKING:
       from .configuration_videomae import VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP, VideoMAEConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_videomae import (
                  VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VideoMAEForPreTraining,
                  VideoMAEForVideoClassification,
                  VideoMAEModel,
                  VideoMAEPreTrainedModel,
              )

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_videomae import VideoMAEFeatureExtractor
              from .image_processing_videomae import VideoMAEImageProcessor

else:
       import sys

       snake_case__   :				Optional[Any]						=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





