output_description: If there is no induced subgraph of G that satisfies the condition, print `-1`.
  Otherwise, print an induced subgraph of G that satisfies the condition, in the
  following format:
  
      
      
      K
      v_1
      v_2
      :
      v_K
      
  
  This represents the induced subgraph of G with K vertices whose vertex set is
  \\{v_1, v_2, \ldots, v_K\\}. (The order of v_1, v_2, \ldots, v_K does not
  matter.) If there are multiple subgraphs of G that satisfy the condition,
  printing any of them is accepted.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      A_1 B_1
      A_2 B_2
      :
      A_M B_M
attempt: import sys
  
  
  class Node:
      def __init__(self, i):
          self.i = i
          self.edge_to = []
          self.edge_from = []
          self.step_visit = -1
          self.exist = True
  
      def delete(self):
          if self.exist:
              self.exist = False
              for i in self.edge_from:
                  tree[i].del_edge_to(self.i)
                  if len(tree[i].edge_to) == 0:
                      tree[i].delete()
              for i in self.edge_to:
                  tree[i].del_edge_from(self.i)
                  if len(tree[i].edge_to) == 0:
                      tree[i].delete()
  
      def add_edge_from(self, i):
          self.edge_from.append(i)
  
      def add_edge_to(self, i):
          self.edge_to.append(i)
  
      def del_edge_from(self, i):
          self.edge_from.remove(i)
  
      def del_edge_to(self, i):
          self.edge_to.remove(i)
  
      def visit(self, step):
          if self.step_visit >= 0:
              return self.step_visit
          self.step_visit = step
          return -1
  
      def next(self):
          for i in range(len(self.edge_to)):
              if tree[self.edge_to[i]].exist:
                  return self.edge_to[i]
          return -1
  
  
  n_v, n_e = map(int, input().split())
  tree = [Node(i) for i in range(n_v)]
  trace = []
  for i in range(n_e):
      a, b = map(int, input().split())
      a -= 1
      b -= 1
      tree[a].add_edge_to(b)
      tree[b].add_edge_from(a)
  # input
  for i in range(n_v):
      if len(tree[i].edge_to) == 0 or len(tree[i].edge_from) == 0:
          tree[i].delete()
  # delete unnecessary nodes
  for i in range(n_v):
      if tree[i].exist:
          trace.append(i)
          tree[i].visit(0)
          next = tree[i].next()
          break
  if len(trace) == 0:
      print("-1")
      sys.exit()
  while True:
      start = tree[next].visit(len(trace))
      if start >= 0 or len(trace) > n_v + 1:
          if start == -1:
              print("-1")
              sys.exit()
          break
      else:
          trace.append(next)
          next = tree[next].next()
  # search loop
  for i in trace:
      for j in tree[i].edge_to:
          if j in trace:
              index = trace.index(j)
              if index > i:
                  del trace[i + 1 : index]
              else:
                  trace = trace[index : i + 1]
  # making it shorter
  print(len(trace) - start)
  for i in range(start, len(trace)):
      print(trace[i] + 1)
  
problem_description: Statement
  
  Given is a directed graph G with N vertices and M edges.  
  The vertices are numbered 1 to N, and the i-th edge is directed from Vertex
  A_i to Vertex B_i.  
  It is guaranteed that the graph contains no self-loops or multiple edges.
  
  Determine whether there exists an induced subgraph (see Notes) of G such that
  the in-degree and out-degree of every vertex are both 1. If the answer is yes,
  show one such subgraph.  
  Here the null graph is not considered as a subgraph.
samples: [{"input": "4 5\n    1 2\n    2 3\n    2 4\n    4 1\n    4 3", "output": "3\n    1\n    2\n    4\n    \n\nThe induced subgraph of G whose vertex set is \\\\{1, 2, 4\\\\} has the edge set\n\\\\{(1, 2), (2, 4), (4, 1)\\\\}. The in-degree and out-degree of every vertex in\nthis graph are both 1.\n\n* * *"}, {"input": "4 5\n    1 2\n    2 3\n    2 4\n    1 4\n    4 3", "output": "-1\n    \n\nThere is no induced subgraph of G that satisfies the condition.\n\n* * *"}, {"input": "6 9\n    1 2\n    2 3\n    3 4\n    4 5\n    5 6\n    5 1\n    5 2\n    6 1\n    6 2", "output": "4\n    2\n    3\n    4\n    5"}]