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 Main {
    public static void main(String args[]) {new Main().run();}

    FastReader in = new FastReader();
    PrintWriter out = new PrintWriter(System.out);
    void run(){
        work();
        out.flush();
    }
    long mod=998244353;
    long gcd(long a,long b) {
        return a==0?b:gcd(b%a,a);
    }
    final long inf=Long.MAX_VALUE/3;
    int[] label;
    int[] pre;
    int root;
    int cur=1;
    int[] color;
    int[] degree;
    int[] id;
    ArrayList<Integer>[] graph;
    Stack<Integer> stack;
    void work(){
        int n=ni(),m=ni();
        root=ni()-1;
        stack=new Stack<>();
        label=new int[n];
        pre=new int[n];
        color=new int[n];
        degree=new int[n];
        id=new int[n];
        graph=ng(n,m);
        for(int i=0;i<n;i++){
            if(color[i]==0){
                dfs1(i);
            }
        }
        int ret=-1;
        boolean[] vis=new boolean[n];
        for(int i=0;i<n;i++){
            dfs2(i,vis);
        }
        for(int i=0;i<n;i++){
            if(id[i]==i&&degree[i]==0){
                ret++;
            }
        }
        out.println(ret);
    }

    private void dfs2(int node, boolean[] vis) {
        if(vis[node]){
            return;
        }
        vis[node]=true;
        for(int nn:graph[node]){
            if(nn!=root){
                if(id[node]!=id[nn]){
                    degree[id[nn]]++;
                }
                if(!vis[nn]){
                    dfs2(nn,vis);
                }
            }
        }
    }

    private void dfs1(int node) {
        stack.add(node);
        label[node]=cur;
        pre[node]=cur;
        color[node]=1;
        cur++;
        for(int nn:graph[node]){
            if(nn!=root&&color[nn]!=2){
                if(color[nn]==0){
                    dfs1(nn);
                }
                pre[node]=Math.min(label[nn],pre[node]);
            }
        }
        if(pre[node]==label[node]){
            while(stack.size()>0&&pre[stack.peek()]>=label[node]){
                int nn=stack.pop();
                id[nn]=node;
            }
        }
        color[node]=2;
    }


    //input
    @SuppressWarnings("unused")
    private ArrayList<Integer>[] ng(int n, int m) {
        ArrayList<Integer>[] graph=(ArrayList<Integer>[])new ArrayList[n];
        for(int i=0;i<n;i++) {
            graph[i]=new ArrayList<>();
        }
        for(int i=1;i<=m;i++) {
            int s=in.nextInt()-1,e=in.nextInt()-1;
            graph[s].add(e);
//            graph[e].add(s);
        }
        return graph;
    }

    private ArrayList<long[]>[] ngw(int n, int m) {
        ArrayList<long[]>[] graph=(ArrayList<long[]>[])new ArrayList[n];
        for(int i=0;i<n;i++) {
            graph[i]=new ArrayList<>();
        }
        for(int i=1;i<=m;i++) {
            long s=in.nextLong()-1,e=in.nextLong()-1,w=in.nextLong();
            graph[(int)s].add(new long[] {e,w});
            graph[(int)e].add(new long[] {s,w});
        }
        return graph;
    }

    private int ni() {
        return in.nextInt();
    }

    private long nl() {
        return in.nextLong();
    }

    private String ns() {
        return in.next();
    }

    private long[] na(int n) {
        long[] A=new long[n];
        for(int i=0;i<n;i++) {
            A[i]=in.nextLong();
        }
        return A;
    }

    private int[] nia(int n) {
        int[] A=new int[n];
        for(int i=0;i<n;i++) {
            A[i]=in.nextInt();
        }
        return A;
    }
}

class FastReader
{
    BufferedReader br;
    StringTokenizer st;

    public FastReader()
    {
        br=new BufferedReader(new InputStreamReader(System.in));
    }


    public String next()
    {
        while(st==null || !st.hasMoreElements())//回车，空行情况
        {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    public int nextInt()
    {
        return Integer.parseInt(next());
    }

    public long nextLong()
    {
        return Long.parseLong(next());
    }
}