



# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
# or u belongs to V and v to U. We can also say that there is no edge that connects
# vertices of same set.







def  lowerCAmelCase_	(lowerCAmelCase__:		Union[str, Any]  ):





			"""simple docstring"""


			UpperCAmelCase_:		List[str]							      =     [False] * len(lowerCAmelCase__  )
			UpperCAmelCase_:		List[Any]							      =     [-1] * len(lowerCAmelCase__  )

			def dfs(lowerCAmelCase__:		Dict		,						lowerCAmelCase__:		int  ):
						UpperCAmelCase_:		List[str]							      =     True
						UpperCAmelCase_:		List[Any]							      =     c
						for u in graph[v]:
									if not visited[u]:
												dfs(lowerCAmelCase__		,						1 - c  )

			for i in range(len(lowerCAmelCase__  )  ):
						if not visited[i]:
									dfs(lowerCAmelCase__		,						0  )

			for i in range(len(lowerCAmelCase__  )  ):
						for j in graph[i]:
									if color[i] == color[j]:
												return False

			return True


# Adjacency list of graph
a      :  str			     =			{0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}

print(check_bipartite_dfs(graph))











def  lowerCAmelCase_	(lowerCAmelCase__:		list  ):





			"""simple docstring"""


			if len(lowerCAmelCase__  ) <= 1:
						return [tuple(lowerCAmelCase__  )]

			UpperCAmelCase_:		List[Any]							      =     []

			def generate(lowerCAmelCase__:		int		,						lowerCAmelCase__:		list  ):
						if k == 1:
									res.append(tuple(arr[:]  )  )
									return

						generate(k - 1		,						lowerCAmelCase__  )

						for i in range(k - 1  ):
									if k % 2 == 0:  # k is even
												UpperCAmelCase_      ,							UpperCAmelCase_:		Union[str, Any]							      =     arr[k - 1], arr[i]
									else:  # k is odd
												UpperCAmelCase_      ,							UpperCAmelCase_:		Optional[int]							      =     arr[k - 1], arr[0]
									generate(k - 1		,						lowerCAmelCase__  )

			generate(len(lowerCAmelCase__  )		,						lowerCAmelCase__  )
			return res


if __name__ == "__main__":
	a      :  Optional[Any]			     =			input('Enter numbers separated by a comma:\n').strip()
	a      :  str			     =			[int(item) for item in user_input.split(',')]
	print(heaps(arr))






