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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author kessido
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        EReachabilityFromTheCapital solver = new EReachabilityFromTheCapital();
        solver.solve(1, in, out);
        out.close();
    }

    static class EReachabilityFromTheCapital {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.NextInt();
            int m = in.NextInt();
            int s = in.NextInt() - 1;
            ArrayList<ArrayList<Integer>> g = new ArrayList<>();
            ArrayList<ArrayList<Integer>> gg = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                g.add(new ArrayList<>());
                gg.add(new ArrayList<>());
            }
            for (int i = 0; i < m; i++) {
                int u = in.NextInt() - 1;
                int v = in.NextInt() - 1;
                g.get(u).add(v);
                gg.get(v).add(u);
            }

            boolean[] reached = new boolean[n];
            ArrayList<Integer> l = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                dfs(i, reached, g, l);
            }
            int[] componnent = new int[n];
            Arrays.fill(componnent, -1);
            for (int i = n - 1; i >= 0; i--) {
                dfsReverse(l.get(i), l.get(i), gg, componnent);
            }

            int[] componnentIn = new int[n];
            Arrays.fill(componnentIn, -1);
            for (int i = 0; i < n; i++) {
                componnentIn[componnent[i]] = 0;
            }
            for (int i = 0; i < n; i++) {
                for (int j : g.get(i)) {
                    if (componnent[i] != componnent[j]) {
                        componnentIn[componnent[j]]++;
                    }
                }
            }
            int res = 0;
            for (int i = 0; i < n; i++) {
                if (i == componnent[s]) continue;
                if (componnentIn[i] == 0) res++;
            }
            out.println(res);
        }

        void dfs(int i, boolean[] reached, ArrayList<ArrayList<Integer>> g, ArrayList<Integer> l) {
            if (reached[i]) return;
            reached[i] = true;
            for (int j : g.get(i)) dfs(j, reached, g, l);
            l.add(i);
        }

        void dfsReverse(int i, int root, ArrayList<ArrayList<Integer>> gg, int[] componnent) {
            if (componnent[i] != -1) return;
            componnent[i] = root;
            for (int k : gg.get(i)) dfsReverse(k, root, gg, componnent);
        }

    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine(), " \t\n\r\f,");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}

