





class       __A     :


				def __init__(		self							):
								lowerCamelCase	 =0
								lowerCamelCase	 =0
								lowerCamelCase	 ={}


				def _snake_case       (		self   , UpperCAmelCase_							):
								if vertex not in self.adjacency:
												lowerCamelCase	 ={}
												self.num_vertices += 1


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								self.add_vertex(UpperCAmelCase_							)
								self.add_vertex(UpperCAmelCase_							)

								if head == tail:
												return

								lowerCamelCase	 =weight
								lowerCamelCase	 =weight


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_edges()
								for edge in edges:
												lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =edge
												edges.remove((tail, head, weight)							)
								for i in range(len(UpperCAmelCase_							)							):
												lowerCamelCase	 =list(edges[i]							)

								edges.sort(key=lambda UpperCAmelCase_							: e[2]							)
								for i in range(len(UpperCAmelCase_							) - 1							):
												if edges[i][2] >= edges[i + 1][2]:
																lowerCamelCase	 =edges[i][2] + 1
								for edge in edges:
												lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =edge
												lowerCamelCase	 =weight
												lowerCamelCase	 =weight


				def __str__(		self							):
								lowerCamelCase	 =""""""
								for tail in self.adjacency:
												for head in self.adjacency[tail]:
																lowerCamelCase	 =self.adjacency[head][tail]
																string += f"""{head} -> {tail} == {weight}\n"""
								return string.rstrip("""\n"""							)


				def _snake_case       (		self							):
								lowerCamelCase	 =[]
								for tail in self.adjacency:
												for head in self.adjacency[tail]:
																output.append((tail, head, self.adjacency[head][tail])							)
								return output


				def _snake_case       (		self							):
								return self.adjacency.keys()


				@staticmethod
				def _snake_case       (		UpperCAmelCase_=None   , UpperCAmelCase_=None							):
								lowerCamelCase	 =Graph()
								if vertices is None:
												lowerCamelCase	 =[]
								if edges is None:
												lowerCamelCase	 =[]
								for vertex in vertices:
												g.add_vertex(UpperCAmelCase_							)
								for edge in edges:
												g.add_edge(*UpperCAmelCase_							)
								return g

				class       __A     :


								def __init__(		self							):
												lowerCamelCase	 ={}
												lowerCamelCase	 ={}


								def __len__(		self							):
												return len(self.parent							)


								def _snake_case       (		self   , UpperCAmelCase_							):
												if item in self.parent:
																return self.find(UpperCAmelCase_							)

												lowerCamelCase	 =item
												lowerCamelCase	 =0
												return item


								def _snake_case       (		self   , UpperCAmelCase_							):
												if item not in self.parent:
																return self.make_set(UpperCAmelCase_							)
												if item != self.parent[item]:
																lowerCamelCase	 =self.find(self.parent[item]							)
												return self.parent[item]


								def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_							):
												lowerCamelCase	 =self.find(UpperCAmelCase_							)
												lowerCamelCase	 =self.find(UpperCAmelCase_							)

												if roota == roota:
																return roota

												if self.rank[roota] > self.rank[roota]:
																lowerCamelCase	 =roota
																return roota

												if self.rank[roota] < self.rank[roota]:
																lowerCamelCase	 =roota
																return roota

												if self.rank[roota] == self.rank[roota]:
																self.rank[roota] += 1
																lowerCamelCase	 =roota
																return roota
												return None




				@staticmethod
				def _snake_case       (		UpperCAmelCase_							):
								lowerCamelCase	 =graph.num_vertices

								lowerCamelCase	 =Graph.UnionFind()
								lowerCamelCase	 =[]
								while num_components > 1:
												lowerCamelCase	 ={}
												for vertex in graph.get_vertices():
																lowerCamelCase	 =-1

												lowerCamelCase	 =graph.get_edges()
												for edge in edges:
																lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =edge
																edges.remove((tail, head, weight)							)
												for edge in edges:
																lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =edge
																lowerCamelCase	 =union_find.find(UpperCAmelCase_							)
																lowerCamelCase	 =union_find.find(UpperCAmelCase_							)
																if seta != seta:
																				if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
																								lowerCamelCase	 =[head, tail, weight]

																				if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
																								lowerCamelCase	 =[head, tail, weight]
												for vertex in cheap_edge:
																if cheap_edge[vertex] != -1:
																				lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =cheap_edge[vertex]
																				if union_find.find(UpperCAmelCase_							) != union_find.find(UpperCAmelCase_							):
																								union_find.union(UpperCAmelCase_   , UpperCAmelCase_							)
																								mst_edges.append(cheap_edge[vertex]							)
																								lowerCamelCase	 =num_components - 1
								lowerCamelCase	 =Graph.build(edges=UpperCAmelCase_							)
								return mst












from ..utils import DummyObject, requires_backends

class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  int:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  Optional[int]:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  str:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  str:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  Optional[Any]:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  List[str]:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)





def      _lowercase					(						*_UpperCAmelCase			,      **_UpperCAmelCase				)						->  Dict:
				requires_backends(_UpperCAmelCase			,      ["""torch"""]				)

class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)




class       __A     (						metaclass=a    ):
				__A      =				["""torch"""]


				def __init__(		self   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(self   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)


				@classmethod
				def _snake_case       (		cls   , *UpperCAmelCase_   , **UpperCAmelCase_							):
								requires_backends(cls   , ["""torch"""]							)





