



'''simple docstring'''

from collections import deque
from math import floor
from random import random
from time import time


class 	a__     :


	def __init__(self : int      )     ->			int:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= {}


	def 				lowercase__  (self : List[str],					__UpperCAmelCase : Dict,					__UpperCAmelCase : Optional[int],					__UpperCAmelCase : Union[str, Any]=1      )     ->			List[Any]:

					"""simple docstring"""

					if self.graph.get(UpperCamelCase__      ):
									if self.graph[u].count([w, v]      ) == 0:
													self.graph[u].append([w, v]      )
					else:
									SCREAMING_SNAKE_CASE  :						Dict      					= [[w, v]]
					if not self.graph.get(UpperCamelCase__      ):
									SCREAMING_SNAKE_CASE  :						str      					= []


	def 				lowercase__  (self : Union[str, Any]      )     ->			List[Any]:

					"""simple docstring"""

					return list(self.graph      )


	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : Optional[int],					__UpperCAmelCase : List[str]      )     ->			str:

					"""simple docstring"""

					if self.graph.get(UpperCamelCase__      ):
									for _ in self.graph[u]:
													if _[1] == v:
																	self.graph[u].remove(UpperCamelCase__      )


	def 				lowercase__  (self : List[Any],					__UpperCAmelCase : Tuple=-2,					__UpperCAmelCase : Union[str, Any]=-1      )     ->			Dict:

					"""simple docstring"""

					if s == d:
									return []
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= []
					SCREAMING_SNAKE_CASE  :						int      					= []
					if s == -2:
									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						str      					= s

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						List[Any]      					= s
													for node in self.graph[s]:
																	if visited.count(node[1]      ) < 1:
																					if node[1] == d:
																									visited.append(UpperCamelCase__      )
																									return visited
																					else:
																									stack.append(node[1]      )
																									visited.append(node[1]      )
																									SCREAMING_SNAKE_CASE  :						Dict      					= node[1]
																									break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						Optional[int]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						List[str]      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return visited


	def 				lowercase__  (self : List[str],					__UpperCAmelCase : int=-1      )     ->			Tuple:

					"""simple docstring"""

					if c == -1:
									SCREAMING_SNAKE_CASE  :						List[str]      					= floor(random() * 10000      ) + 10
					for i in range(UpperCamelCase__      ):
									# every vertex has max 100 edges
									for _ in range(floor(random() * 102      ) + 1      ):
													SCREAMING_SNAKE_CASE  :						int      					= floor(random() * c      ) + 1
													if n != i:
																	self.add_pair(UpperCamelCase__,					UpperCamelCase__,					1      )


	def 				lowercase__  (self : Optional[Any],					__UpperCAmelCase : List[Any]=-2      )     ->			List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= deque()
					SCREAMING_SNAKE_CASE  :						Tuple      					= []
					if s == -2:
									SCREAMING_SNAKE_CASE  :						int      					= list(self.graph      )[0]
					d.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					while d:
									SCREAMING_SNAKE_CASE  :						Dict      					= d.popleft()
									if len(self.graph[s]      ) != 0:
													for node in self.graph[s]:
																	if visited.count(node[1]      ) < 1:
																					d.append(node[1]      )
																					visited.append(node[1]      )
					return visited


	def 				lowercase__  (self : Optional[Any],					__UpperCAmelCase : Dict      )     ->			int:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= 0
					for x in self.graph:
									for y in self.graph[x]:
													if y[1] == u:
																	count += 1
					return count


	def 				lowercase__  (self : int,					__UpperCAmelCase : Tuple      )     ->			Dict:

					"""simple docstring"""

					return len(self.graph[u]      )


	def 				lowercase__  (self : Dict,					__UpperCAmelCase : Tuple=-2      )     ->			Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= []
					SCREAMING_SNAKE_CASE  :						str      					= []
					if s == -2:
									SCREAMING_SNAKE_CASE  :						str      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= s
					SCREAMING_SNAKE_CASE  :						Tuple      					= []

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						Any      					= s
													for node in self.graph[s]:
																	if visited.count(node[1]      ) < 1:
																					stack.append(node[1]      )
																					visited.append(node[1]      )
																					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= node[1]
																					break

            # check if all the children are visited
									if s == ss:
													sorted_nodes.append(stack.pop()      )
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						Optional[Any]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						Dict      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return sorted_nodes


	def 				lowercase__  (self : Tuple      )     ->			List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= []
					SCREAMING_SNAKE_CASE  :						int      					= []
					SCREAMING_SNAKE_CASE  :						Any      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Any      					= -2
					SCREAMING_SNAKE_CASE  :						Dict      					= []
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= s
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= False
					SCREAMING_SNAKE_CASE  :						str      					= set()

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						Dict      					= s
													for node in self.graph[s]:
																	if (
																	    visited.count(node[1]      ) > 0
																	    and node[1] != parent
																	    and indirect_parents.count(node[1]      ) > 0
																	    and not on_the_way_back
																	):
																					SCREAMING_SNAKE_CASE  :						str      					= len(UpperCamelCase__      ) - 1
																					while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																													anticipating_nodes.add(node[1]      )
																													break
																									else:
																													anticipating_nodes.add(stack[len_stack]      )
																													len_stack -= 1
																	if visited.count(node[1]      ) < 1:
																					stack.append(node[1]      )
																					visited.append(node[1]      )
																					SCREAMING_SNAKE_CASE  :						List[Any]      					= node[1]
																					break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													SCREAMING_SNAKE_CASE  :						List[Any]      					= True
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						List[str]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						Any      					= False
													indirect_parents.append(UpperCamelCase__      )
													SCREAMING_SNAKE_CASE  :						Tuple      					= s
													SCREAMING_SNAKE_CASE  :						Optional[int]      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return list(UpperCamelCase__      )


	def 				lowercase__  (self : List[Any]      )     ->			str:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= []
					SCREAMING_SNAKE_CASE  :						Dict      					= []
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Any      					= -2
					SCREAMING_SNAKE_CASE  :						Tuple      					= []
					SCREAMING_SNAKE_CASE  :						List[str]      					= s
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= False
					SCREAMING_SNAKE_CASE  :						int      					= set()

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						Dict      					= s
													for node in self.graph[s]:
																	if (
																	    visited.count(node[1]      ) > 0
																	    and node[1] != parent
																	    and indirect_parents.count(node[1]      ) > 0
																	    and not on_the_way_back
																	):
																					SCREAMING_SNAKE_CASE  :						Tuple      					= len(UpperCamelCase__      ) - 1
																					while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																													anticipating_nodes.add(node[1]      )
																													break
																									else:
																													return True
																	if visited.count(node[1]      ) < 1:
																					stack.append(node[1]      )
																					visited.append(node[1]      )
																					SCREAMING_SNAKE_CASE  :						Tuple      					= node[1]
																					break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													SCREAMING_SNAKE_CASE  :						Optional[Any]      					= True
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						Dict      					= False
													indirect_parents.append(UpperCamelCase__      )
													SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= s
													SCREAMING_SNAKE_CASE  :						str      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return False


	def 				lowercase__  (self : List[str],					__UpperCAmelCase : List[str]=-2,					__UpperCAmelCase : Any=-1      )     ->			str:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= time()
					self.dfs(UpperCamelCase__,					UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= time()
					return end - begin






	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : Optional[Any]=-2      )     ->			Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= time()
					self.bfs(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						List[str]      					= time()
					return end - begin



class 	a__     :


	def __init__(self : Any      )     ->			Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= {}


	def 				lowercase__  (self : Union[str, Any],					__UpperCAmelCase : Dict,					__UpperCAmelCase : List[str],					__UpperCAmelCase : str=1      )     ->			str:

					"""simple docstring"""

					if self.graph.get(UpperCamelCase__      ):
									# if there already is a edge
									if self.graph[u].count([w, v]      ) == 0:
													self.graph[u].append([w, v]      )
					else:
									# if u does not exist
									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= [[w, v]]
					# add the other way
					if self.graph.get(UpperCamelCase__      ):
									# if there already is a edge
									if self.graph[v].count([w, u]      ) == 0:
													self.graph[v].append([w, u]      )
					else:
									# if u does not exist
									SCREAMING_SNAKE_CASE  :						Any      					= [[w, u]]


	def 				lowercase__  (self : Optional[int],					__UpperCAmelCase : Any,					__UpperCAmelCase : Any      )     ->			Tuple:

					"""simple docstring"""

					if self.graph.get(UpperCamelCase__      ):
									for _ in self.graph[u]:
													if _[1] == v:
																	self.graph[u].remove(UpperCamelCase__      )
        # the other way round
					if self.graph.get(UpperCamelCase__      ):
									for _ in self.graph[v]:
													if _[1] == u:
																	self.graph[v].remove(UpperCamelCase__      )


	def 				lowercase__  (self : Union[str, Any],					__UpperCAmelCase : Dict=-2,					__UpperCAmelCase : List[Any]=-1      )     ->			Union[str, Any]:

					"""simple docstring"""

					if s == d:
									return []
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= []
					SCREAMING_SNAKE_CASE  :						int      					= []
					if s == -2:
									SCREAMING_SNAKE_CASE  :						List[Any]      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Tuple      					= s

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						List[Any]      					= s
													for node in self.graph[s]:
																	if visited.count(node[1]      ) < 1:
																					if node[1] == d:
																									visited.append(UpperCamelCase__      )
																									return visited
																					else:
																									stack.append(node[1]      )
																									visited.append(node[1]      )
																									SCREAMING_SNAKE_CASE  :						int      					= node[1]
																									break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						List[str]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						str      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return visited


	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : int=-1      )     ->			Tuple:

					"""simple docstring"""

					if c == -1:
									SCREAMING_SNAKE_CASE  :						Dict      					= floor(random() * 10000      ) + 10
					for i in range(UpperCamelCase__      ):
									# every vertex has max 100 edges
									for _ in range(floor(random() * 102      ) + 1      ):
													SCREAMING_SNAKE_CASE  :						List[str]      					= floor(random() * c      ) + 1
													if n != i:
																	self.add_pair(UpperCamelCase__,					UpperCamelCase__,					1      )


	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : Any=-2      )     ->			Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= deque()
					SCREAMING_SNAKE_CASE  :						str      					= []
					if s == -2:
									SCREAMING_SNAKE_CASE  :						str      					= list(self.graph      )[0]
					d.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					while d:
									SCREAMING_SNAKE_CASE  :						Dict      					= d.popleft()
									if len(self.graph[s]      ) != 0:
													for node in self.graph[s]:
																	if visited.count(node[1]      ) < 1:
																					d.append(node[1]      )
																					visited.append(node[1]      )
					return visited


	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : str      )     ->			str:

					"""simple docstring"""

					return len(self.graph[u]      )


	def 				lowercase__  (self : List[Any]      )     ->			Optional[int]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= []
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= []
					SCREAMING_SNAKE_CASE  :						Dict      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						List[Any]      					= -2
					SCREAMING_SNAKE_CASE  :						Dict      					= []
					SCREAMING_SNAKE_CASE  :						str      					= s
					SCREAMING_SNAKE_CASE  :						str      					= False
					SCREAMING_SNAKE_CASE  :						Tuple      					= set()

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						List[Any]      					= s
													for node in self.graph[s]:
																	if (
																	    visited.count(node[1]      ) > 0
																	    and node[1] != parent
																	    and indirect_parents.count(node[1]      ) > 0
																	    and not on_the_way_back
																	):
																					SCREAMING_SNAKE_CASE  :						Optional[int]      					= len(UpperCamelCase__      ) - 1
																					while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																													anticipating_nodes.add(node[1]      )
																													break
																									else:
																													anticipating_nodes.add(stack[len_stack]      )
																													len_stack -= 1
																	if visited.count(node[1]      ) < 1:
																					stack.append(node[1]      )
																					visited.append(node[1]      )
																					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= node[1]
																					break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													SCREAMING_SNAKE_CASE  :						str      					= True
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						str      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						Optional[Any]      					= False
													indirect_parents.append(UpperCamelCase__      )
													SCREAMING_SNAKE_CASE  :						Optional[int]      					= s
													SCREAMING_SNAKE_CASE  :						Optional[Any]      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return list(UpperCamelCase__      )


	def 				lowercase__  (self : Tuple      )     ->			Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= []
					SCREAMING_SNAKE_CASE  :						Any      					= []
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= list(self.graph      )[0]
					stack.append(UpperCamelCase__      )
					visited.append(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						List[Any]      					= -2
					SCREAMING_SNAKE_CASE  :						List[str]      					= []
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= s
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= False
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= set()

					while True:
									# check if there is any non isolated nodes
									if len(self.graph[s]      ) != 0:
													SCREAMING_SNAKE_CASE  :						Dict      					= s
													for node in self.graph[s]:
																	if (
																	    visited.count(node[1]      ) > 0
																	    and node[1] != parent
																	    and indirect_parents.count(node[1]      ) > 0
																	    and not on_the_way_back
																	):
																					SCREAMING_SNAKE_CASE  :						Any      					= len(UpperCamelCase__      ) - 1
																					while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																													anticipating_nodes.add(node[1]      )
																													break
																									else:
																													return True
																	if visited.count(node[1]      ) < 1:
																					stack.append(node[1]      )
																					visited.append(node[1]      )
																					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= node[1]
																					break

            # check if all the children are visited
									if s == ss:
													stack.pop()
													SCREAMING_SNAKE_CASE  :						Tuple      					= True
													if len(UpperCamelCase__      ) != 0:
																	SCREAMING_SNAKE_CASE  :						List[Any]      					= stack[len(UpperCamelCase__      ) - 1]
									else:
													SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= False
													indirect_parents.append(UpperCamelCase__      )
													SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= s
													SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= ss

									# check if se have reached the starting point
									if len(UpperCamelCase__      ) == 0:
													return False


	def 				lowercase__  (self : List[Any]      )     ->			Optional[Any]:

					"""simple docstring"""

					return list(self.graph      )


	def 				lowercase__  (self : Dict,					__UpperCAmelCase : Dict=-2,					__UpperCAmelCase : int=-1      )     ->			Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= time()
					self.dfs(UpperCamelCase__,					UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Any      					= time()
					return end - begin






	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : List[str]=-2      )     ->			Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= time()
					self.bfs(UpperCamelCase__      )
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= time()
					return end - begin









'''simple docstring'''

from ..utils import DummyObject, requires_backends


class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Dict	    =     ["torch", "transformers", "onnx"]


	def __init__(self : List[str],					*__UpperCAmelCase : Dict,					**__UpperCAmelCase : List[Any]      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : Optional[Any],					*__UpperCAmelCase : Tuple,					**__UpperCAmelCase : int      )     ->			int:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : Any,					*__UpperCAmelCase : Tuple,					**__UpperCAmelCase : Tuple      )     ->			Tuple:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Any	    =     ["torch", "transformers", "onnx"]


	def __init__(self : Dict,					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Optional[Any]      )     ->			int:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : Any,					*__UpperCAmelCase : Tuple,					**__UpperCAmelCase : List[str]      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : int,					*__UpperCAmelCase : List[Any],					**__UpperCAmelCase : Any      )     ->			Optional[Any]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Optional[Any]	    =     ["torch", "transformers", "onnx"]


	def __init__(self : Dict,					*__UpperCAmelCase : Dict,					**__UpperCAmelCase : Any      )     ->			List[str]:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : Tuple,					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : int      )     ->			Optional[Any]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : Union[str, Any],					*__UpperCAmelCase : List[str],					**__UpperCAmelCase : str      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Tuple	    =     ["torch", "transformers", "onnx"]


	def __init__(self : Union[str, Any],					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : List[Any]      )     ->			Tuple:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : str,					*__UpperCAmelCase : Optional[int],					**__UpperCAmelCase : Tuple      )     ->			str:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : int,					*__UpperCAmelCase : List[Any],					**__UpperCAmelCase : List[str]      )     ->			Tuple:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    List[Any]	    =     ["torch", "transformers", "onnx"]


	def __init__(self : Dict,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : int      )     ->			List[str]:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : List[str],					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Dict      )     ->			Union[str, Any]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : Any,					*__UpperCAmelCase : List[str],					**__UpperCAmelCase : List[Any]      )     ->			Dict:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )



class 	a__     (				metaclass=_lowercase	):
	__magic_name__		:    Dict	    =     ["torch", "transformers", "onnx"]


	def __init__(self : Tuple,					*__UpperCAmelCase : Optional[Any],					**__UpperCAmelCase : List[str]      )     ->			Any:

					"""simple docstring"""

					requires_backends(self,					['''torch''', '''transformers''', '''onnx''']      )


	@classmethod
	def 				lowercase__  (cls : Tuple,					*__UpperCAmelCase : Any,					**__UpperCAmelCase : Union[str, Any]      )     ->			Optional[int]:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )






	@classmethod
	def 				lowercase__  (cls : Optional[Any],					*__UpperCAmelCase : Union[str, Any],					**__UpperCAmelCase : Optional[Any]      )     ->			int:

					"""simple docstring"""

					requires_backends(cls,					['''torch''', '''transformers''', '''onnx''']      )




