



# 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.
from queue import Queue





def   __lowerCamelCase				(					__magic_name__		:     Union[str, Any]  ):
							a__:				str 							=Queue()
							a__:				Optional[int] 							=[False] * len(__magic_name__  )
							a__:				List[Any] 							=[-1] * len(__magic_name__  )

							def bfs():
														while not queue.empty():
																					a__:				Union[str, Any] 							=queue.get()
																					a__:				str 							=True

																					for neighbour in graph[u]:
																												if neighbour == u:
																																			return False

																												if color[neighbour] == -1:
																																			a__:				Dict 							=1 - color[u]
																																			queue.put(__magic_name__  )

																												elif color[neighbour] == color[u]:
																																			return False

														return True

							for i in range(len(__magic_name__  )  ):
														if not visited[i]:
																					queue.put(__magic_name__  )
																					a__:				Optional[int] 							=0
																					if bfs() is False:
																												return False

							return True


if __name__ == "__main__":
		# Adjacency List of graph
		print(check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}))









def        __lowerCAmelCase    (SCREAMING_SNAKE_CASE = 1000					)->  int:




      """simple docstring"""

      snake_case_       =      0
      snake_case_       =      (n - 1) // 3
      total += ((terms) * (6 + (terms - 1) * 3)) // 2  # total of an A.P.
      snake_case_       =      (n - 1) // 5
      total += ((terms) * (10 + (terms - 1) * 5)) // 2
      snake_case_       =      (n - 1) // 15
      total -= ((terms) * (30 + (terms - 1) * 15)) // 2
      return total


if __name__ == "__main__":
   print(f'''{solution() = }''')