


def 			UpperCamelCase (     __magic_name__					:							List[str]   ,   __magic_name__					:							str					)       ->  str:
		"""simple docstring"""




		if number < 0 or shift_amount < 0:
				raise ValueError("""both inputs must be positive integers"""					)

		lowercase__					      =		str(bin(__snake_case					)					)
		binary_number += "0" * shift_amount
		return binary_number






def 			UpperCamelCase (     __magic_name__					:							int   ,   __magic_name__					:							str					)       ->  str:
		"""simple docstring"""




		if number < 0 or shift_amount < 0:
				raise ValueError("""both inputs must be positive integers"""					)

		lowercase__					      =		str(bin(__snake_case					)					)[2:]
		if shift_amount >= len(__snake_case					):
				return "0b0"
		lowercase__					      =		binary_number[: len(__snake_case					) - shift_amount]
		return "0b" + shifted_binary_number






def 			UpperCamelCase (     __magic_name__					:							Tuple   ,   __magic_name__					:							int					)       ->  str:
		"""simple docstring"""




		if number >= 0:  # Get binary representation of positive number
				lowercase__					      =		"""0""" + str(bin(__snake_case					)					).strip("""-"""					)[2:]
		else:  # Get binary (2's complement) representation of negative number
				lowercase__					      =		len(bin(__snake_case					)[3:]					)  # Find 2's complement of number
				lowercase__					      =		bin(abs(__snake_case					) - (1 << binary_number_length)					)[3:]
				lowercase__					      =		(
				    """1""" + """0""" * (binary_number_length - len(__snake_case					)) + binary_number
				)

		if shift_amount >= len(__snake_case					):
				return "0b" + binary_number[0] * len(__snake_case					)
		return (
		    "0b"
		    + binary_number[0] * shift_amount
		    + binary_number[: len(__snake_case					) - shift_amount]
		)


if __name__ == "__main__":
	import doctest

	doctest.testmod()









class 							A   :
					'''simple docstring'''






					def __init__(self   :						int				, _UpperCAmelCase   :						list		)						->       None:




							"""simple docstring"""


							lowercase__					      =		set_counts
							lowercase__					      =		max(_UpperCAmelCase		)
							lowercase__					      =		len(_UpperCAmelCase		)
							lowercase__					      =		[1] * num_sets
							lowercase__					      =		list(range(_UpperCAmelCase		)		)

					def   lowerCamelCase__					(self   :						List[Any]				, _UpperCAmelCase   :						int				, _UpperCAmelCase   :						int		)						->       bool:




							"""simple docstring"""


							lowercase__					      =		self.get_parent(_UpperCAmelCase		)
							lowercase__					      =		self.get_parent(_UpperCAmelCase		)

							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]
									lowercase__					      =		0
									lowercase__					      =		dst_parent
									if self.ranks[dst_parent] == self.ranks[src_parent]:
											self.ranks[dst_parent] += 1
									lowercase__					      =		self.set_counts[dst_parent]
							else:
									self.set_counts[src_parent] += self.set_counts[dst_parent]
									lowercase__					      =		0
									lowercase__					      =		src_parent
									lowercase__					      =		self.set_counts[src_parent]

							lowercase__					      =		max(self.max_set				, _UpperCAmelCase		)
							return True


					def   lowerCamelCase__					(self   :						List[Any]				, _UpperCAmelCase   :						int		)						->       int:




							"""simple docstring"""


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

