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.io.*;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.*;

public class Solution {
static class Degree{
    int degree,value;
    public Degree(int xx,int yy){
        value=xx;
        degree=yy;
    }
}
static int xg;
static final Comparator<Degree> com=new Comparator<Degree>(){
        public int compare(Degree a, Degree b){
            return Integer.compare(b.degree, a.degree);
        }
};
    static ArrayList tree[];
    static boolean visited[];
    static boolean visited1[];
    public static void dfs(int x){
        visited[x]=true;
        //System.out.println(x);
        Iterator<Integer> it=tree[x].iterator();
        while(it.hasNext()){
            int vv=it.next();
            if(!visited[vv])
                dfs(vv);
        }
    }
    public static void dfs1(int x){
        xg++;
        visited1[x]=true;
        Iterator<Integer> it=tree[x].iterator();
        while(it.hasNext()){
            int vv=it.next();
            if(!visited1[vv])
                dfs1(vv);
        }
    }
    public static void main(String[] args)
    {
    
        InputReader in=new InputReader(System.in);
    
        StringBuffer str=new StringBuffer();
        int n,m,s,i,j,k;
        n=in.nextInt();
        m=in.nextInt();
        s=in.nextInt();
        tree=new ArrayList[n+1];
        visited=new boolean[n+1];
        for(i=1;i<=n;i++){
            tree[i]=new ArrayList();
            visited[i]=false;
        }
        for(i=0;i<m;i++){
            int x=in.nextInt();
            int y=in.nextInt();
            tree[x].add(y);
        }
        //System.out.println(s);
        dfs(s);
        int c=0;
        Degree dg[]=new Degree[n+1];
        for(i=1;i<=n;i++){
            //System.out.println(visited[i]+" ");
            if(!visited[i]){
                xg=0;
                visited1=new boolean[n+1];
                dfs1(i);
                dg[i]=new Degree(i,xg);                
            }else{
                dg[i]=new Degree(0,0); 
            }
        }    
        dg[0]=new Degree(0,0); 
//        for(i=0;i<=n;i++){
//            System.out.println(dg[i].value+" "+dg[i].degree);
//        }        
        Arrays.sort(dg,com);        
        for(i=0;i<=n;i++){
            if(dg[i].degree==0 &&dg[i].value==0){
                continue;
            }else{
                //System.out.println(visited[dg[i].value]);
                if(!visited[dg[i].value]){
                c++;
                dfs(dg[i].value);
                }
            }
        }        
        System.out.println(c);
        }
    

    static class InputReader{
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
 
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
 
        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
 
        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }
 
        public void skip(int x) {
            while (x-- > 0)
                read();
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
 
        public String nextString() {
            return next();
        }
 
        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
 
            return res.toString();
        }
 
        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }
 
        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
 
        public boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }
 
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }
} 