output_description: If Ken cannot reach Vertex T from Vertex S by repeating ken-ken-pa, print -1.
  If he can, print the minimum number of ken-ken-pa needed to reach vertex T.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      u_1 v_1
      :
      u_M v_M
      S T
attempt: from collections import deque
  
  
  class unionFind:
      par = []
  
      def __init__(self, N):
          self.par = [i for i in range(N + 1)]
  
      def root(self, x):
          if self.par[x] == x:
              return x
          else:
              self.par[x] = self.root(self.par[x])
              return self.par[x]
  
      def unite(self, x, y):
          rx = self.root(x)
          ry = self.root(y)
          if rx == ry:
              return
          else:
              self.par[rx] = ry
  
      def same(self, x, y):
          return self.root(x) == self.root(y)
  
  
  N, M = map(int, input().split())
  uf = unionFind(3 * N)
  g = {i: [] for i in range(3 * N + 1)}
  
  
  for i in range(M):
      e = list(map(int, input().split()))
      g[3 * e[0]].append(3 * e[1] - 1)
      g[3 * e[0] - 1].append(3 * e[1] - 2)
      g[3 * e[0] - 2].append(3 * e[1])
      uf.unite(3 * e[0], 3 * e[1] - 1)
      uf.unite(3 * e[0] - 1, 3 * e[1] - 2)
      uf.unite(3 * e[0] - 2, 3 * e[1])
  
  
  S, T = map(int, input().split())
  
  if not uf.same(S * 3, T * 3):
      print(-1)
  else:
      q = deque([])
      qset = set()
      fp = []
      # root
      q.append((3 * S, 0))
      qset.add(3 * S)
      while len(q) > 0:
          now = q.popleft()
          for node in g[now[0]]:
              if node == 3 * T:
                  print((now[1] + 1) // 3)
                  q.clear()
                  break
              if node not in fp and node not in qset:
                  q.append((node, now[1] + 1))
                  qset.add(node)
          fp.append(now[0])
  
problem_description: Statement
  
  Ken loves _ken-ken-pa_ (Japanese version of hopscotch). Today, he will play it
  on a directed graph G. G consists of N vertices numbered 1 to N, and M edges.
  The i-th edge points from Vertex u_i to Vertex v_i.
  
  First, Ken stands on Vertex S. He wants to reach Vertex T by repeating ken-
  ken-pa. In one ken-ken-pa, he does the following exactly three times: follow
  an edge pointing from the vertex on which he is standing.
  
  Determine if he can reach Vertex T by repeating ken-ken-pa. If the answer is
  yes, find the minimum number of ken-ken-pa needed to reach Vertex T. Note that
  visiting Vertex T in the middle of a ken-ken-pa does not count as reaching
  Vertex T by repeating ken-ken-pa.
samples: [{"input": "4 4\n    1 2\n    2 3\n    3 4\n    4 1\n    1 3", "output": "2\n    \n\nKen can reach Vertex 3 from Vertex 1 in two ken-ken-pa, as follows: 1\n\\rightarrow 2 \\rightarrow 3 \\rightarrow 4 in the first ken-ken-pa, then 4\n\\rightarrow 1 \\rightarrow 2 \\rightarrow 3 in the second ken-ken-pa. This is\nthe minimum number of ken-ken-pa needed.\n\n* * *"}, {"input": "3 3\n    1 2\n    2 3\n    3 1\n    1 2", "output": "-1\n    \n\nAny number of ken-ken-pa will bring Ken back to Vertex 1, so he cannot reach\nVertex 2, though he can pass through it in the middle of a ken-ken-pa.\n\n* * *"}, {"input": "2 0\n    1 2", "output": "-1\n    \n\nVertex S and Vertex T may be disconnected.\n\n* * *"}, {"input": "6 8\n    1 2\n    2 3\n    3 4\n    4 5\n    5 1\n    1 4\n    1 5\n    4 6\n    1 6", "output": "2"}]