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 newclass {
	static class pair implements Comparable<pair>{
		int a;int b; 
		public pair(int a, int b) {
			this.a=a;
			this.b=b;
			
		}
        public int compareTo(pair p){
        	return(a-p.a==0)?b-p.b:a-p.a;
        }
        public String toString () {
        	return a+" "+b;
        }
	}
	  static long gcd(long a, long b) 
	    { 
	    if (a == 0) 
	        return b;  
	    return gcd(b % a, a);  
	    } 
	  static long lcm(long a, long b) 
	    { 
	        return (a*b)/gcd(a, b); 
	    } 
	      
  public static void main(String[] args) throws IOException {
	  
	  Scanner sc = new Scanner(System.in);
	  PrintWriter out = new PrintWriter(System.out);
	   n =sc.nextInt();
	   m =sc.nextInt();
	  int idx =sc.nextInt()-1;
	  adjList = new ArrayList[n];
		for (int i = 0; i < n; i++)
			adjList[i] = new ArrayList<>();
		vis = new boolean[n];
		while (m-- > 0) {
			int x = sc.nextInt()-1;
			int y = sc.nextInt()-1;
			adjList[x].add(y);
		}
        int ans = 0;
		stack = new Stack<>();
		for(int i = 0 ; i < n ; i++)
			if(!vis[i])
				check(i);
		while(!stack.isEmpty())
		{
			int u = stack.pop();
			if(u == idx) continue;
			vis = new boolean[n];
			dfs(idx);
			if(!vis[u]) {
				adjList[idx].add(u);
				ans++;
			}
		}
		out.println(ans);
	  out.flush();

}  
 static int n, m;
static ArrayList<Integer>[] adjList;
static Stack<Integer> stack;
static boolean[] vis;
static void check(int i) {
	vis[i] = true;
	for (int x : adjList[i])
		if (!vis[x])
			check(x);
	stack.add(i);
}
static void dfs(int i) {
	vis[i] = true;
	for (int x : adjList[i])
		if (!vis[x])
			dfs(x);
}
   static long pow(int a, int b) {
	   long ans =1;
	   while(b-->0) ans*=1l*a;
	   return ans;
   }
 static class Scanner 
  {
  	StringTokenizer st;
  	BufferedReader br;

  	public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

  	public String next() throws IOException 
  	{
  		while (st == null || !st.hasMoreTokens()) 
  			st = new StringTokenizer(br.readLine());
  		return st.nextToken();
  	}
    public boolean check() throws IOException{ return st.hasMoreTokens();}
  	public int nextInt() throws IOException {return Integer.parseInt(next());}
  	
  	public long nextLong() throws IOException {return Long.parseLong(next());}

  	public String nextLine() throws IOException {return br.readLine();}
  	
  	public double nextDouble() throws IOException
  	{
  		String x = next();
  		StringBuilder sb = new StringBuilder("0");
  		double res = 0, f = 1;
  		boolean dec = false, neg = false;
  		int start = 0;
  		if(x.charAt(0) == '-')
  		{
  			neg = true;
  			start++;
  		}
  		for(int i = start; i < x.length(); i++)
  			if(x.charAt(i) == '.')
  			{
  				res = Long.parseLong(sb.toString());
  				sb = new StringBuilder("0");
  				dec = true;
  			}
  			else
  			{
  				sb.append(x.charAt(i));
  				if(dec)
  					f *= 10;
  			}
  		res += Long.parseLong(sb.toString()) / f;
  		return res * (neg?-1:1);
  	}
  	
  	public boolean ready() throws IOException {return br.ready();}


  }
 static void shuffle(int[] a)
	{
		int n = a.length;
		for(int i = 0; i < n; i++)
		{
			int r = i + (int)(Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}
}