





"""simple docstring"""
class       a							:



 def __init__(     self				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= set_counts
  lowerCAmelCase    				= max(_snake_case     )
  lowerCAmelCase    				= len(_snake_case     )
  lowerCAmelCase    				= [1] * num_sets
  lowerCAmelCase    				= list(range(_snake_case     )     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= self.get_parent(_snake_case     )
  lowerCAmelCase    				= self.get_parent(_snake_case     )

  if src_parent == dst_parent:
   return False

  if self.ranks[dst_parent] >= self.ranks[src_parent]:
   self.set_counts[dst_parent] += self.set_counts[src_parent]
   lowerCAmelCase    				= 0
   lowerCAmelCase    				= dst_parent
   if self.ranks[dst_parent] == self.ranks[src_parent]:
    self.ranks[dst_parent] += 1
   lowerCAmelCase    				= self.set_counts[dst_parent]
  else:
   self.set_counts[src_parent] += self.set_counts[dst_parent]
   lowerCAmelCase    				= 0
   lowerCAmelCase    				= src_parent
   lowerCAmelCase    				= self.set_counts[src_parent]

  lowerCAmelCase    				= max(self.max_set				,       _snake_case     )
  return True



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if self.parents[disj_set] == disj_set:
   return disj_set
  lowerCAmelCase    				= self.get_parent(self.parents[disj_set]     )
  return self.parents[disj_set]










'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__a  			=						{
    "configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __a  			=						[
           "GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST",
           "GPTBigCodeForSequenceClassification",
           "GPTBigCodeForTokenClassification",
           "GPTBigCodeForCausalLM",
           "GPTBigCodeModel",
           "GPTBigCodePreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_gpt_bigcode import (
                  GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
                  GPTBigCodeForCausalLM,
                  GPTBigCodeForSequenceClassification,
                  GPTBigCodeForTokenClassification,
                  GPTBigCodeModel,
                  GPTBigCodePreTrainedModel,
              )


else:
       import sys

       __a  			=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
