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.
                            /* Rajkin Hossain */
import java.io.*;
import java.util.*;

public class A {

    //static FastInput k = new FastInput("/home/rajkin/Desktop/input.txt");
    static FastInput k = new FastInput(System.in);
    static FastOutput z = new FastOutput();
    static int n, m, s;
    static ArrayList<Integer> graph [];
    static boolean [] marked;
    static boolean [] visited;
    static ArrayList<Pair> list;
    
    static int dfs2(int u) {
    	marked[u] = true;
    	
    	int sum = 1;
    	for(int i = 0; i<graph[u].size(); i++) {
    		int v = graph[u].get(i);
    		if(!marked[v] && !visited[v]) {
    			sum += dfs2(v);
    		}
    	}
    	
    	return sum;
    }
    
    static void countChildrens() {
    	for(int i = 0; i<n; i++) {
       		if(!visited[i]) {
    			list.add(new Pair(i, dfs2(i)));
    			Arrays.fill(marked, false);
    		}
    	}
    }
    
    static void dfs(int u) {
    	visited[u] = true;
    	for(int i = 0; i<graph[u].size(); i++) {
    		int v = graph[u].get(i);
    		if(!visited[v]) {
    			dfs(v);
    		}
    	}
    }
       
    static void startAlgorithm() {
    	dfs(s);
    	
    	countChildrens();
    	Collections.sort(list);
    	
    	int ans = 0;
    	for(int i = 0; i<list.size(); i++) {
    		int node = list.get(i).node;
    		
    		//System.out.println(node+" "+list.get(i).childrens);
    		if(!visited[node]) {
    			dfs(node);
    			ans++;
    		}
    	}
    	
    	z.println(ans);
    }
	
	static void getInputsAndInitializes() {
		n = k.nextInt();
		m = k.nextInt();
		s = k.nextInt() - 1;
		graph = new ArrayList[n];
		
		marked = new boolean[n];
		visited = new boolean[n];
		
		list = new ArrayList<Pair>();
		
		for(int i = 0; i<n; i++) {
			graph[i] = new ArrayList<Integer>();
		}
		
		for(int i = 0; i<m; i++) {
			int u = k.nextInt(); u--;
			int v = k.nextInt(); v--;
			
			graph[u].add(v);
		}
    }
    
	public static void main(String [] args) throws FileNotFoundException {        
		
		while(k.hasNext()) {
        	getInputsAndInitializes();
        	startAlgorithm();
        }
		
        z.flush();
        System.exit(0);
	}
	
	
	/* MARK: Pair implementation */
	
	public static class Pair implements Comparable<Pair>{
		int node, childrens;
		public Pair(int node, int childrens) {
			this.node = node;
			this.childrens = childrens;
		}
		
		public int compareTo(Pair p) {
			// TODO Auto-generated method stub
			return p.childrens - this.childrens;
		}
	}
	
	
	/* MARK: SetBit implementation */
	
	public static long setBit(long pos, long value) {
		return value |= (1l << pos);
	}
	
    /* MARK: FastInput and FastOutput implementation */
	 
    public static class FastInput {
        BufferedReader reader;
        StringTokenizer tokenizer;
 
        public FastInput(InputStream stream){
            reader = new BufferedReader(new InputStreamReader(stream));
        }
        
	    public FastInput(String path){
	        try {
	        	reader = new BufferedReader(new FileReader(path));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	        tokenizer = null;
	    }
 
        public String next() {
            return nextToken();
        }
        
        public String nextLine() {
            try {
				return reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            
            return null;
        }
 
        public boolean hasNext(){
            try {
                return reader.ready();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return false;
        }
 
        public String nextToken() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String line = null;
                try {
                    line = reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (line == null) {
                    return null;
                }
                tokenizer = new StringTokenizer(line);
            }
            return tokenizer.nextToken();
        }
 
        public Integer nextInt() {
            return Integer.parseInt(nextToken());
        }
       
        public Long nextLong() {
            return Long.valueOf(nextToken());
        }
    	
    	public void inputIntegerList(ArrayList<Integer> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextInt());
    		}
    	}
    	
    	public void inputLongList(ArrayList<Long> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextLong());
    		}
    	}
    	
    	public void inputWordList(ArrayList<String> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(next());
    		}
    	}
    	
    	public void inputLineList(ArrayList<String> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextLine());
    		}
    	}
    	
    	public void inputIntegerArray(int [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextInt();
    		}
    	}

    	public void inputLongArray(long [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextLong();
    		}
    	}
    	
    	public void inputWordArray(String [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = next();
    		}
    	}
    	
    	public void inputLineArray(String [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextLine();
    		}
    	}
    }
 
    public static class FastOutput extends PrintWriter {
    	public FastOutput() { 
            super(new BufferedOutputStream(System.out)); 
    	}
    	
    	public void printSideBySideSet(Set<Object> set, int size) {
    		boolean isFirstElementPrinted = false;
    		for(Object element : set) {
    			if(!isFirstElementPrinted) {
    				print(element);
    				isFirstElementPrinted = true;
    				
    				return;
    			}
    			print(" "+element);
    		}
    		println();
    	}
    	
    	public void printLineByLineSet(Set<Object> set, int size) {
    		for(Object element : set) {
    			println(element);
    		}
    	}
    	
    	public void printSideBySideList(ArrayList<Object> list, int size) {
    		print(list.get(0));
    		for(int i = 1; i<size; i++) {
    			print(" "+list.get(i));
    		}
    		println();
    	}
    	
    	public void printLineByLineList(ArrayList<Object> list, int size) {
    		for(int i = 0; i<size; i++) {
    			println(list.get(i));
    		}
    	}
    	
    	public void printSideBySideArray(Object [] array, int size) {
    		print(array[0]);
    		for(int i = 1; i<size; i++) {
    			print(" "+array[i]);
    		}
    		println();
    	}
    	
    	public void printLineByLineArray(Object [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			println(array[i]);
    		}
    	}
    }
}