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
  from collections import defaultdict
  
  input = sys.stdin.readline
  
  
  def inpl():
      return list(map(int, input().split()))
  
  
  N, M = inpl()
  
  G = [[] for _ in range(N)]
  rG = [[] for _ in range(N)]
  
  for _ in range(M):
      a, b = inpl()
      G[a - 1].append(b - 1)
      rG[b - 1].append(a - 1)
  
  
  def SCC(G, rG):
      N = len(G)
  
      def dfs(i):
          nonlocal t, rorder, searched
          searched[i] = True
          for j in G[i]:
              if not searched[j]:
                  dfs(j)
          rorder[t] = i
          t += 1
  
      def rdfs(i):
          nonlocal t, group, g
          group[i] = g
          for j in rG[i]:
              if group[j] == -1:
                  rdfs(j)
  
      t = 0
      rorder = [-1] * N
      searched = [0] * N
      group = [-1] * N
  
      for i in range(N):
          if not searched[i]:
              dfs(i)
      g = 0
      for i in range(N - 1, -1, -1):
          if group[rorder[i]] == -1:
              rdfs(rorder[i])
              g += 1
      return group, g
  
  
  def check(target):
      if len(target) == 1:
          return False
  
      init = list(target)[0] * 1
      Q = [init]
      searched = [0] * len(G)
      searched[init] = 1
  
      while Q:
          p = Q.pop()
          for q in G[p]:
              if searched[q]:
                  continue
              if not q in target:
                  continue
              searched[q] = True
              Q.append(q)
      if not all([searched[x] for x in target]):
          return False
  
      Q = [init]
      searched = [0] * N
      searched[init] = 1
  
      while Q:
          p = Q.pop()
          for q in rG[p]:
              if searched[q]:
                  continue
              if not q in target:
                  continue
              searched[q] = True
              Q.append(q)
  
      return all([searched[x] for x in target])
  
  
  group, g = SCC(G, rG)
  
  units = defaultdict(set)
  
  for i in range(N):
      units[group[i]].add(i)
  
  for unit in units.values():
      if len(unit) == 1:
          continue
      target = unit | set()
      for u in unit:
          if check(target ^ set([u])):
              target = target ^ set([u])
      print(len(target))
      print(*[t + 1 for t in target], sep="\n")
      break
  else:
      print(-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"}]