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.*;
import java.math.*;
public class Solution{
    
    static HashMap<Integer,Node> luckup = new HashMap<Integer,Node>();
    
    static class Node{
        int id;
        LinkedList<Integer> next = new LinkedList<Integer>();
        LinkedList<Integer> previous = new LinkedList<Integer>();
        public Node(int id){
            this.id = id;
        }
    }
    
    static Node getNode(int id){
        return luckup.get(id);
    }
    
    static void addEdges(int first,int second){
        getNode(first).next.add(second);
        getNode(second).previous.add(first);
    }
    
    static boolean[] not_reched;
    
    static int racine;
    static boolean[] visited;
    
    static void reche(int s){
        
        LinkedList<Integer> nextToVisit = new LinkedList<Integer>();
        nextToVisit.add(s);
        boolean cycle = false;
        
        while(!nextToVisit.isEmpty()){
            
            Node node = getNode(nextToVisit.poll());
            for(int i:node.next){
                
                if(!not_reched[i]) continue;
                if(i==s){
                    
                    cycle = true;
                    continue;
                    
                }
                not_reched[i] = false;
                nextToVisit.add(i);
                
            }
            
        }
        
        if(cycle){
            
            Arrays.fill(visited,false);
            nextToVisit.add(s);
            visited[s] = true;
            while(!nextToVisit.isEmpty()){
                
                Node node = getNode(nextToVisit.poll());
                for(int i:node.previous){
                    if(visited[i]) continue;
                    visited[i] = true;
                    if(not_reched[i]){
                        not_reched[s] = false;
                        return ;
                    }
                    nextToVisit.add(i);
                }
                
            }
            
        }
        
        
        
    }
    
    
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        PrintWriter out = new PrintWriter(System.out);
        
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int s = Integer.parseInt(st.nextToken());
        for(int i=1;i<=n;i++) luckup.put(i,new Node(i));
        
        for(int i=0;i<m;i++){
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            addEdges(u,v);
        }
        
        visited = new boolean[n+1];
        
        not_reched = new boolean[n+1];
        Arrays.fill(not_reched,true);
        not_reched[s] = false;
        
        racine = s;
        reche(s);
        
        for(int i=1;i<=n;i++){
            if(not_reched[i]) reche(i);
        }
        
        int nb = 0;
        for(int i=1;i<=n;i++){
            if(not_reched[i]) nb++;
        }
        
        out.println(nb);
        
        
        out.flush();
    }
    
}