There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.

What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?

New roads will also be one-way.

Input

The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.

The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).

Output

Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.

Examples

Input

9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1


Output

3


Input

5 4 5
1 2
2 3
3 4
4 1


Output

1

Note

The first example is illustrated by the following:

<image>

For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.

The second example is illustrated by the following:

<image>

In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
import java.util.*;
import java.io.*;

public class codechef
{
	public static void main(String[] args) throws IOException
	{
		FastReader in=new FastReader();
		int n=in.nextInt();
		int m=in.nextInt();
		int c=in.nextInt();
		Graph g=new Graph(n);
		for(int i=0;i<m;i++)
			g.addEdge(in.nextInt(),in.nextInt());
		for(int i=0;i<g.al[c].size();i++)
		{
			g.dfs(g.al[c].get(i));
		}
		g.visited.add(c);
		ArrayList<Integer> non=new ArrayList<>();
		for(int i=1;i<=n;i++)
		{
			if(!g.visited.contains(i))
				non.add(i);
		}
		Stack<Integer> s=new Stack<>();
		for(int i:non)
			g.dfs(i,s);
		g.clear();
		int ans=0;
		while(!s.empty())
		{
			int x=s.pop();
			if(!g.visited.contains(x))
			{
				ans++;
				g.dfs(x);
			}
		}
		System.out.print(ans);
	}
}

class Graph
{
	int V;
	ArrayList<Integer> al[];
	Set<Integer> visited;

	public Graph(int v)
	{
		V=v+1;
		al=new ArrayList[V];
		visited=new HashSet<>();
		for(int i=1;i<V;i++)
			al[i]=new ArrayList<>();
	}

	public void addEdge(int a,int b)
	{
		al[a].add(b);
	}

	public void dfs(int a)
	{
		if(visited.contains(a))
			return;
		visited.add(a);
		for(int i:al[a])
			dfs(i);
	}

	public void dfs(int a,Stack s)
	{
		if(visited.contains(a))
			return;
		visited.add(a);
		for(int i:al[a])
			dfs(i);
		s.push(a);
	}

	public void clear()
	{
		visited.clear();
	}
}

class FastReader
{
	BufferedReader br;
	StringTokenizer st;
 
	public FastReader()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}
 
	public String next() throws IOException
	{
		if(st==null || !st.hasMoreElements())
		{
			st=new StringTokenizer(br.readLine());
		}
		return st.nextToken();
	}
 
	public int nextInt() throws IOException
	{
		return Integer.parseInt(next());
	}
 
	public long nextLong() throws IOException
	{
		return Long.parseLong(next());
	}
}