






class 							SCREAMING_SNAKE_CASE__						:



					def __init__( self					:  Tuple							,		__A					:  list	):
						snake_case__			:				Any       =  set_counts
						snake_case__			:				List[Any]       =  max(_lowerCAmelCase	)
						snake_case__			:				Dict       =  len(_lowerCAmelCase	)
						snake_case__			:				Any       =  [1] * num_sets
						snake_case__			:				int       =  list(range(_lowerCAmelCase	)	)



					def 	_lowercase					( self					:  Union[str, Any]							,		__A					:  int							,		__A					:  int	):
						snake_case__			:				Tuple       =  self.get_parent(_lowerCAmelCase	)
						snake_case__			:				int       =  self.get_parent(_lowerCAmelCase	)

						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]
							snake_case__			:				Dict       =  0
							snake_case__			:				Optional[Any]       =  dst_parent
							if self.ranks[dst_parent] == self.ranks[src_parent]:
								self.ranks[dst_parent] += 1
							snake_case__			:				Optional[int]       =  self.set_counts[dst_parent]
						else:
							self.set_counts[src_parent] += self.set_counts[dst_parent]
							snake_case__			:				Dict       =  0
							snake_case__			:				Tuple       =  src_parent
							snake_case__			:				Tuple       =  self.set_counts[src_parent]

						snake_case__			:				int       =  max(self.max_set							,		_lowerCAmelCase	)
						return True






					def 	_lowercase					( self					:  Dict							,		__A					:  int	):

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











__lowerCamelCase :      Optional[int]										=				"""Tobias Carryer"""

from time import time



class 							SCREAMING_SNAKE_CASE__						:





					"""simple docstring"""






					def __init__( self					:  List[Any]							,		__A					:  List[Any]							,		__A					:  Optional[int]							,		__A					:  List[str]							,		__A					:  Dict=int(time()	)	):  # noqa: B008
						snake_case__			:				List[Any]       =  multiplier
						snake_case__			:				Optional[int]       =  increment
						snake_case__			:				Optional[int]       =  modulo
						snake_case__			:				Union[str, Any]       =  seed






					def 	_lowercase					( self					:  str	):
						snake_case__			:				Union[str, Any]       =  (self.multiplier * self.seed + self.increment) % self.modulo
						return self.seed


if __name__ == "__main__":
	# Show the LCG in action.
	__lowerCamelCase :      int										=				LinearCongruentialGenerator(166_4525, 10_1390_4223, 2 << 31)
	while True:
		print(lcg.next_number())



