






# 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      lowercase__      (     __snake_case    :							List[Any]  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Any            =						[False] * len(__snake_case  )
					UpperCAmelCase_    :      Dict            =						[-1] * len(__snake_case  )

					def dfs(__snake_case    :							Dict     ,       __snake_case    :							Tuple  ):
										UpperCAmelCase_    :      Optional[Any]            =						True
										UpperCAmelCase_    :      Dict            =						c
										for u in graph[v]:
															if not visited[u]:
																				dfs(__snake_case     ,       1 - c  )

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

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

					return True


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






print(check_bipartite_dfs(graph))














import os

# Precomputes a list of the 100 first triangular numbers
__UpperCAmelCase								=						[int(0.5 * n * (n + 1)) for n in range(1, 101)]




def      lowercase__      (     ):


					'''simple docstring'''


					UpperCAmelCase_    :      Any            =						os.path.dirname(os.path.realpath(__snake_case  )  )
					UpperCAmelCase_    :      Optional[Any]            =						os.path.join(__snake_case     ,       'words.txt'  )

					UpperCAmelCase_    :      Union[str, Any]            =						''
					with open(__snake_case  ) as f:
										UpperCAmelCase_    :      List[Any]            =						f.readline()

					UpperCAmelCase_    :      Optional[int]            =						[word.strip('"'  ) for word in words.strip('\r\n'  ).split(','  )]
					UpperCAmelCase_    :      Optional[int]            =						[
					    word
					    for word in [sum(ord(__snake_case  ) - 64 for x in word  ) for word in words]
					    if word in TRIANGULAR_NUMBERS
					]
					return len(__snake_case  )


if __name__ == "__main__":
		print(solution())






