





def 	lowerCAmelCase_					(			__a						)	->						bool:







  """simple docstring"""





  lowerCamelCase__: set[int]         =set()
  # To detect a back edge, keep track of vertices currently in the recursion stack
  lowerCamelCase__: set[int]         =set()
  return any(
      node not in visited and depth_first_search(__a      ,       __a      ,       __a      ,       __a						)
      for node in graph						)





def 	lowerCAmelCase_					(			__a      ,       __a      ,       __a      ,       __a						)	->						bool:







  """simple docstring"""





  visited.add(__a						)
  rec_stk.add(__a						)

  for node in graph[vertex]:
    if node not in visited:
      if depth_first_search(__a      ,       __a      ,       __a      ,       __a						):
        return True
    elif node in rec_stk:
      return True

    # The node needs to be removed from recursion stack before function ends
  rec_stk.remove(__a						)
  return False


if __name__ == "__main__":
     from doctest import testmod

     testmod()



def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# bit count represents no. of bits in the gray code
						if bit_count < 0:
												raise ValueError("""The given input must be positive"""       )

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

						return sequence




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# The approach is a recursive one
						# Base case achieved when either n = 0 or n=1
						if bit_count == 0:
												return ["0"]

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

						_lowercase					       =					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
						_lowercase					       =					gray_code_sequence_string(bit_count - 1       )

						_lowercase					       =					[]

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

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

						return sequence


if __name__ == "__main__":
		import doctest

		doctest.testmod()