



'''simple docstring'''






def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int  )      ->   int:
							if b == 0:
														return 1
							if (b % 2) == 0:
														return actual_power(__lowerCamelCase   ,      int(b / 2  )  ) * actual_power(__lowerCamelCase   ,      int(b / 2  )  )
							else:
														return a * actual_power(__lowerCamelCase   ,      int(b / 2  )  ) * actual_power(__lowerCamelCase   ,      int(b / 2  )  )


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int  )      ->   str:
							if b < 0:
														return 1 / actual_power(__lowerCamelCase   ,      __lowerCamelCase  )
							return actual_power(__lowerCamelCase   ,      __lowerCamelCase  )


if __name__ == "__main__":
						print(power(-2, -3))










"""simple docstring"""






class        __SCREAMING_SNAKE_CASE	:


					'''simple docstring'''





					def __init__(       self							:  Dict,  lowerCamelCase							:  list     )->					None:
								lowerCamelCase__		:		Tuple			=set_counts
								lowerCamelCase__		:		Dict			=max(lowerCamelCase     )
								lowerCamelCase__		:		Union[str, Any]			=len(lowerCamelCase     )
								lowerCamelCase__		:		List[str]			=[1] * num_sets
								lowerCamelCase__		:		str			=list(range(lowerCamelCase     )     )



					def 		snake_case       (       self							:  Tuple,  lowerCamelCase							:  int,  lowerCamelCase							:  int     )->					bool:
								lowerCamelCase__		:		List[Any]			=self.get_parent(lowerCamelCase     )
								lowerCamelCase__		:		str			=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]
											lowerCamelCase__		:		Tuple			=0
											lowerCamelCase__		:		int			=dst_parent
											if self.ranks[dst_parent] == self.ranks[src_parent]:
														self.ranks[dst_parent] += 1
											lowerCamelCase__		:		str			=self.set_counts[dst_parent]
								else:
											self.set_counts[src_parent] += self.set_counts[dst_parent]
											lowerCamelCase__		:		List[Any]			=0
											lowerCamelCase__		:		List[str]			=src_parent
											lowerCamelCase__		:		Dict			=self.set_counts[src_parent]

								lowerCamelCase__		:		str			=max(self.max_set,  lowerCamelCase     )
								return True




					def 		snake_case       (       self							:  Union[str, Any],  lowerCamelCase							:  int     )->					int:
								if self.parents[disj_set] == disj_set:
											return disj_set
								lowerCamelCase__		:		Tuple			=self.get_parent(self.parents[disj_set]     )
								return self.parents[disj_set]




