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 {
    static Graph g;
    static int n;
    static boolean[]visited;
    static int cntr;
    public static void main(String[] args)
    {
        InputReader in = new InputReader(System.in);
        OutputWriter out = new OutputWriter(System.out);
        n = in.nextInt();
        g= new Graph(n+1);
        visited = new boolean[n+1];
        int m = in.nextInt();
        int s = in.nextInt();
        for (int i =0;i<m;i++)
        {
            g.adjList[in.nextInt()].add(in.nextInt());

        }
        BFS(s);
        cntr=0;
        for (int i =1;i<=n;i++)
        {
            if (!visited[i]&&i!=s)
                cntr++;
        }
        PriorityQueue<pair> p =new PriorityQueue<>();
        for (int i =1;i<n+1;i++)
            if (!visited[i]&&i!=s)
                p.add(new pair(-BFS2(i),i));
        while (!p.isEmpty())
        {
            pair temp = p.poll();
            if (!visited[temp.y])
                BFS3(temp.y);
        }
        out.printLine(cntr);
        out.flush();
    }
    static int BFS3(int start)
    {

        Queue<Integer> q = new LinkedList<>();
        visited[start] = true;
        q.add(start);
        int counter =0;
        while(!q.isEmpty())
        {
            int index = q.poll();

            for (int i=0;i<g.adjList[index].size();i++ )
            {

                if (!visited[g.adjList[index].get(i)]) {
                    visited[g.adjList[index].get(i)] = true;
                    q.add(g.adjList[index].get(i));
                    cntr--;
                }
            }

        }
        return  counter;
    }
    static int BFS2(int start)
    {
        boolean[]v =new boolean[n+1];
        Queue<Integer> q = new LinkedList<>();
        v[start] = true;
        q.add(start);
        int counter =0;
        while(!q.isEmpty())
        {
            int index = q.poll();

            for (int i=0;i<g.adjList[index].size();i++ )
            {

                if (!visited[g.adjList[index].get(i)]&&!v[g.adjList[index].get(i)]) {

                    q.add(g.adjList[index].get( i));
                    v[g.adjList[index].get(i)]=true;
                    counter++;
                }
            }

        }
        return  counter;
    }
    static int BFS(int start)
    {

        Queue<Integer> q = new LinkedList<>();
        visited[start] = true;
        q.add(start);
        int counter =0;
        while(!q.isEmpty())
        {
            int index = q.poll();

            for (int i=0;i<g.adjList[index].size();i++ )
            {

                if (!visited[g.adjList[index].get(i)]) {
                    visited[g.adjList[index].get(i)] = true;
                    q.add(g.adjList[index].get(i));
                    counter++;
                }
            }

        }
        return  counter;
    }

}

class pair  implements Comparable
{

    int x;
    int y;
    public pair(Object key, Object value) {

        this.x = (int)key;
        this.y=(int)value;
    }

    @Override
    public int compareTo(Object o) {
        pair temp =(pair)o;
        return  x-temp.x;
    }
}
class Graph {


    int n;
    ArrayList<Integer>[] adjList;

    public Graph(int n) {
        this.n = n;
        adjList = new ArrayList[n];
        for (int i = 0; i < n; i++)
            adjList[i] = new ArrayList<>();
    }

}


class InputReader {

    private final InputStream stream;
    private final byte[] buf = new byte[8192];
    private int curChar, snumChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        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 = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } 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 = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndOfLine(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    public void flush() {
        writer.flush();
    }

}