package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"strconv"
)


type Item struct {
	node int
	cost int
}


type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].cost < pq[j].cost
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*Item)
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func main() {
	
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	
	readInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	m := readInt()

	
	
	revAdj := make([][]int, n+1)
	
	outDeg := make([]int, n+1)

	for i := 0; i < m; i++ {
		u := readInt()
		v := readInt()
		revAdj[v] = append(revAdj[v], u)
		outDeg[u]++
	}

	s := readInt()
	t := readInt()

	if s == t {
		fmt.Println(0)
		return
	}

	
	
	dist := make([]int, n+1)
	for i := range dist {
		dist[i] = -1 
	}
	
	processedCount := make([]int, n+1)

	pq := &PriorityQueue{}
	heap.Init(pq)

	
	dist[t] = 0
	heap.Push(pq, &Item{node: t, cost: 0})

	for pq.Len() > 0 {
		top := heap.Pop(pq).(*Item)
		u := top.node
		d := top.cost

		
		if dist[u] != -1 && d > dist[u] {
			continue
		}

		if u == s {
			fmt.Println(d)
			return
		}

		
		for _, v := range revAdj[u] {
			processedCount[v]++

			
			
			
			
			costOrder := d + 1
			if dist[v] == -1 || costOrder < dist[v] {
				dist[v] = costOrder
				heap.Push(pq, &Item{node: v, cost: costOrder})
			}

			
			
			
			
			
			if processedCount[v] == outDeg[v] {
				costNoOrder := d
				if dist[v] == -1 || costNoOrder < dist[v] {
					dist[v] = costNoOrder
					heap.Push(pq, &Item{node: v, cost: costNoOrder})
				}
			}
		}
	}

	
	fmt.Println("-1")
}