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.util.concurrent.LinkedBlockingDeque;
import java.io.*;
import java.lang.*;
	
	public class graph1
	{
		public static int n;
		public static ArrayList<Integer> adj[];
		public static ArrayList<Integer> child[];
		public static boolean[] vis;
		public static int[] par;
		public static int[] level;
		public static int[] set;
		public static int[] a;
		public static int[] ans;
		public static int count;
		
		public static long INF = Long.MAX_VALUE/100;
		
		
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);
	
	//		n = in.nextInt();
			n = in.nextInt();
			int m = in.nextInt();
			int s = in.nextInt();
			
			
			//children = new ArrayList[n+1];
			vis = new boolean[n+1];
			par = new int[n+1];
			set = new int[n+1];
			level = new int[n+1];
			
			adj = new ArrayList[n+1];
			for(int i=0; i<=n; i++)
			{
				vis [i] = false;
				par[i] = -1;
			}
			
			
			
			for(int i=0;i<=n;i++)
			{
				adj[i] = new ArrayList<Integer>();
			}
			
			
			for(int i=0; i<m; i++)
			{
				int u = in.nextInt();
				int v = in.nextInt();
				adj[u].add(v);
			}
			
			int count = 0;
			int[] ver = new int[n];
			ArrayList<pair> list = new ArrayList<>();
			for(int i=1; i<=n; i++)
			{
				if(!vis[i])
				{
				//	pw.println(bfs(i));
					list.add(new pair(i, bfs(i)));
				}
				
			}
			Collections.sort(list);
			fbfs(s);
			for(int i=0; i<list.size(); i++)
			{
				
				int v = (int)(long)list.get(i).x;
				if(!vis[v])
				{
					fbfs(v);
					count++;
				}
				
				
			}
			
			
			pw.println(count);
			
			
			//code ends....
			pw.flush();
			pw.close();
		}
		
		
		
		
		
		public static int bfs(int x)
		{
			Queue<Integer> queue = new LinkedList<>();
			queue.add(x);
			//level[x] = 1;
			int c = 0;
			//parent[x] = 0;
			boolean[] vis = new boolean[n+1]; 
			vis[x] = true;
			while(!queue.isEmpty())
			{
				int last = queue.poll();
				for(int p : adj[last])
				{
					if(!vis[p])
					{
							//	children[last].add(a);
						queue.add(p);
					//	System.out.println(p+" ");
						
						vis[p] = true;
						c++;
					//	parent[a] = last;
						//level[a] = level[last]+1;
						
					}
				}
			}
			return c;
		}
		
		public static int fbfs(int x)
		{
			Queue<Integer> queue = new LinkedList<>();
			queue.add(x);
			//level[x] = 1;
			int c = 0;
			//parent[x] = 0;
			//boolean[] vis = new boolean[n+1]; 
			vis[x] = true;
			while(!queue.isEmpty())
			{
				int last = queue.poll();
				for(int p : adj[last])
				{
					if(!vis[p])
					{
							//	children[last].add(a);
						queue.add(p);
					//	System.out.println(p+" ");
						
						vis[p] = true;
						c++;
					//	parent[a] = last;
						//level[a] = level[last]+1;
						
					}
				}
			}
			return c;
		}
		
		
		/*
		
		
		public static void fun(int s)
		{
			
			if(vis[s])
				return;
			set[s] = count;
			vis[s] = true;
			fun(a[s]);
			
		}
		

		public static int dfs(int s)
		{
			for(int i=0; i<=n; i++)
			{
				vis [i] = false;
				par[i] = -1;
				level[i] = 0;
				
			}
			Stack<Integer> stk = new Stack<>();
	 		stk.add(s);
			par[s] = 0;
			vis[s] = true;
			
			while(!stk.isEmpty())
			{
				int last = stk.pop();
			///	System.out.println(last);
				boolean f = false;
				for(int a : adj[last])
				{
					if(!vis[a])
					{
						//child[last].add(a);
						stk.add(a);
						par[a] = last;
						level[a] = level[last] +1;
						vis[a] = true;
					}
				}
			
			}
			int max = 0;
			int maxi = 0;
			for(int i=1; i<=n; i++)
			{
				if(level[i]>max)
				{
					max = level[i];
					maxi = i;
				}
				
			}
			return maxi;
		}
				
		 */
	
		
/*		public static void dfsrec(int s)
		{
			if(vis[s])
				return;
			
			vis[s] = true;
			int k = 0;
			for(int p: adj[s])
			{
				boolean f2 = false;
				if(!vis[p])
				{
					k++;
					dfsrec(p);
				}
				
			}
			par[s] = k;
			
		}
		
		public static int find(int i) {
			
			
			if(par[i]==-1)
				return i;
			else
				return find(par[i]);
				
		}
		
		 public static void union( int x, int y)
		    {
		        int xset = find( x);
		        int yset = find(y);
		        par[xset] = yset;
		    }

	 */
		
		
	/*	 public static boolean cycle(HashSet<pair> set) {
			 
			 
			 for(pair p: set)
			 {
				 int x = find(p.x);
				 int y = find(p.y);
				 if(x==y)
					 return true;
		
				 union(x, y);
				 
			 }
			 
			 return false;
		 }
		 */
		
		
		
		
		
		
		static class pair implements Comparable<pair>
		 
		{
			Long x;
			Integer y;
			pair(long adj,int y)
			{
		
				this.x=adj;
				this.y=y;
			}
			
			public int compareTo(pair o) {
				//int result = x.compareTo(o.x);
				//if(result==0)
					int result = -y.compareTo(o.y);
				
				return result;
			}  
			
			public String toString()
			{
				return x+" "+y;
			}
			
			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}
			
			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}
	
	
		static class triplet implements Comparable<triplet>
		{
			Integer x,y,z;
			triplet(int x,int y,int z)
			{
				this.x = x;
				this.y = y;
				this.z = z;
			}
			
			public  int compareTo(triplet o)
			{
				int result = x.compareTo(o.x);
				if(result==0)
					result =  y.compareTo(o.y);
				if(result==0)
					result = z.compareTo(o.z);
	
				return result;
			}
			
			public boolean equlas(Object o)
			{
				if(o instanceof triplet)
				{
					triplet p = (triplet)o;
					return x==p.x && y==p.y && z==p.z;
				}
				return false;
			}
			
			public String toString()
			{
				return x+" "+y+" "+z;
			}
			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode() + new Long(z).hashCode(); 
			}
		}
		
	
		
		
		
		static class InputReader 
		{
			 
			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;
	 
			public InputReader(InputStream stream) 
			{
				this.stream = stream;
			}
	 
			public int snext() 
			{
				if (snumChars == -1)
					throw new InputMismatchException();
				if (curChar >= snumChars) 
				{
					curChar = 0;
					try 
					{
						snumChars = stream.read(buf);
					} 
					catch (IOException e) 
					{
						throw new InputMismatchException();
					}
					if (snumChars <= 0)
						return -1;
				}
				return buf[curChar++];
			}
	 
			public int nextInt() 
		    {
				int c = snext();
				while (isSpaceChar(c)) 
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
			    {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do 
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}
	 
			public long nextLong()
		    {
				int c = snext();
				while (isSpaceChar(c)) 
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-') 
				{
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do 
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}
	 
			public int[] nextIntArray(int n) 
			{
				int a[] = new int[n];
				for (int i = 0; i < n; i++) 
				{
					a[i] = nextInt();
				}
				return a;
			}
	 
			public String readString()
		    {
				int c = snext();
				while (isSpaceChar(c)) 
				{
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do 
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}
	 
			public String nextLine() 
			{
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do 
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(c));
				return res.toString();
			}
	 
			public boolean isSpaceChar(int c) 
			{
				if (filter != null)
					return filter.isSpaceChar(c);
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}
	 
			private boolean isEndOfLine(int c) 
			{
				return c == '\n' || c == '\r' || c == -1;
			}
	 
			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
		
		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;
		
		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}
		
		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}
		
		public static HashSet<Integer> primeFactorization(int n)
		{
			HashSet<Integer> a =new HashSet<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}
		
		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;
			
			isPrime[0] = false;
			isPrime[1] = false;
			
			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}
		
		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}
		
		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}
		
		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}
		
		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}
		
		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}
		
		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}
		
		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}
		
		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}
		
		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}
		
		public static int modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}
		
		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}
		
		
		
		
		
		public static boolean isPrime(int n)
		{
		    
		    if (n <= 1)  return false;
		    if (n <= 3)  return true;
		    
		    if (n%2 == 0 || n%3 == 0) 
		    	return false;
		 
		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }
		    
		    return true;
		}
		
		
	}