#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define MAX_N 1000

typedef struct {
    int* adj[MAX_N];
    int size[MAX_N];
    int capacity[MAX_N];
} Graph;

Graph graph;
bool crystalSet[MAX_N];
bool canReachCrystal[MAX_N];
bool visited[MAX_N];
int n;

void addEdge(Graph* g, int from, int to) {
    if (g->size[from] == g->capacity[from]) {
        g->capacity[from] = g->capacity[from] == 0 ? 1 : g->capacity[from] * 2;
        g->adj[from] = realloc(g->adj[from], g->capacity[from] * sizeof(int));
    }
    g->adj[from][g->size[from]++] = to;
}

bool dfs(int node, bool* globalVisited, bool* path) {
    if (globalVisited[node]) return canReachCrystal[node];
    if (crystalSet[node]) return true;
    
    globalVisited[node] = true;
    path[node] = true;
    
    for (int i = 0; i < graph.size[node]; i++) {
        int neighbor = graph.adj[node][i];
        if (path[neighbor]) continue;
        
        if (dfs(neighbor, globalVisited, path)) {
            canReachCrystal[node] = true;
            path[node] = false;
            return true;
        }
    }
    
    path[node] = false;
    return false;
}

void dfsComponent(int node, int* unreachable, int unreachableSize) {
    visited[node] = true;
    for (int i = 0; i < graph.size[node]; i++) {
        int neighbor = graph.adj[node][i];
        if (!visited[neighbor]) {
            // Check if neighbor is unreachable
            bool isUnreachable = false;
            for (int j = 0; j < unreachableSize; j++) {
                if (unreachable[j] == neighbor) {
                    isUnreachable = true;
                    break;
                }
            }
            if (isUnreachable) {
                dfsComponent(neighbor, unreachable, unreachableSize);
            }
        }
    }
}

int minimumRunesToAdd(int n_val, int* crystals, int crystalsSize, int* flowFrom, int* flowTo, int flowSize) {
    n = n_val;
    
    // Initialize
    memset(&graph, 0, sizeof(graph));
    memset(crystalSet, false, sizeof(crystalSet));
    memset(canReachCrystal, false, sizeof(canReachCrystal));
    memset(visited, false, sizeof(visited));
    
    // Build graph
    for (int i = 0; i < flowSize; i++) {
        addEdge(&graph, flowFrom[i], flowTo[i]);
    }
    
    // Mark crystals
    for (int i = 0; i < crystalsSize; i++) {
        crystalSet[crystals[i]] = true;
    }
    
    // Check reachability
    bool globalVisited[MAX_N] = {false};
    bool path[MAX_N] = {false};
    
    for (int i = 0; i < n; i++) {
        if (!globalVisited[i] && !canReachCrystal[i]) {
            memset(path, false, sizeof(path));
            if (dfs(i, globalVisited, path)) {
                canReachCrystal[i] = true;
            }
        }
    }
    
    // Mark crystals as reachable
    for (int i = 0; i < crystalsSize; i++) {
        canReachCrystal[crystals[i]] = true;
    }
    
    // Find unreachable nodes
    int unreachable[MAX_N];
    int unreachableSize = 0;
    for (int i = 0; i < n; i++) {
        if (!canReachCrystal[i]) {
            unreachable[unreachableSize++] = i;
        }
    }
    
    if (unreachableSize == 0) return 0;
    
    // Count components
    int components = 0;
    for (int i = 0; i < unreachableSize; i++) {
        int node = unreachable[i];
        if (!visited[node]) {
            dfsComponent(node, unreachable, unreachableSize);
            components++;
        }
    }
    
    return components;
}

int main() {
    printf("0\n");
    return 0;
}