






def      __A					(     _lowercase ):

					'''simple docstring'''







					if bit_count < 0:
										raise ValueError('''The given input must be positive''' )

					# get the generated string sequence
					_A								= gray_code_sequence_string(_lowercase )
					#
					# convert them to integers
					for i in range(len(_lowercase ) ):
										_A								= int(sequence[i]					,			2 )

					return sequence




def      __A					(     _lowercase ):

					'''simple docstring'''







					if bit_count == 0:
										return ["0"]

					if bit_count == 1:
										return ["0", "1"]

					_A								= 1 << bit_count  # defines the length of the sequence
					# 1<< n is equivalent to 2^n

					# recursive answer will generate answer for n-1 bits
					_A								= gray_code_sequence_string(bit_count - 1 )

					_A								= []

					# append 0 to first half of the smaller sequence generated
					for i in range(seq_len // 2 ):
										_A								= '''0''' + smaller_sequence[i]
										sequence.append(_lowercase )

					# append 1 to second half ... start from the end of the list
					for i in reversed(range(seq_len // 2 ) ):
										_A								= '''1''' + smaller_sequence[i]
										sequence.append(_lowercase )

					return sequence


if __name__ == "__main__":
				import doctest

				doctest.testmod()











__A      =				{0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

__A      =				{0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}




def      __A					(     _lowercase					,			_lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= True
					_A								= []

					for neighbour in graph[vert]:
										if not visited[neighbour]:
															order += topology_sort(_lowercase					,			_lowercase					,			_lowercase )

					order.append(_lowercase )

					return order




def      __A					(     _lowercase					,			_lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= True
					_A								= [vert]

					for neighbour in reversed_graph[vert]:
										if not visited[neighbour]:
															component += find_components(_lowercase					,			_lowercase					,			_lowercase )

					return component




def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= len(_lowercase ) * [False]
					_A								= {vert: [] for vert in range(len(_lowercase ) )}

					for vert, neighbours in graph.items():
										for neighbour in neighbours:
															reversed_graph[neighbour].append(_lowercase )

					_A								= []
					for i, was_visited in enumerate(_lowercase ):
										if not was_visited:
															order += topology_sort(_lowercase					,			_lowercase					,			_lowercase )

					_A								= []
					_A								= len(_lowercase ) * [False]

					for i in range(len(_lowercase ) ):
										_A								= order[len(_lowercase ) - i - 1]
										if not visited[vert]:
															_A								= find_components(_lowercase					,			_lowercase					,			_lowercase )
															components_list.append(_lowercase )

					return components_list



