#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    vector<vector<int>> adj;
    vector<int> comp, compSize;

    void dfs(int u, int id) {
        comp[u] = id;
        compSize[id]++;

        for (int v : adj[u]) {
            if (comp[v] == -1)
                dfs(v, id);
        }
    }

    int minMalwareSpread(int n,
                         vector<int>& from,
                         vector<int>& to,
                         vector<int>& malware) {

        adj.assign(n + 1, {});

        for (int i = 0; i < from.size(); i++) {
            adj[from[i]].push_back(to[i]);
            adj[to[i]].push_back(from[i]);
        }

        comp.assign(n + 1, -1);
        compSize.assign(n + 1, 0);

        int id = 0;

        // Find connected components
        for (int i = 1; i <= n; i++) {
            if (comp[i] == -1) {
                dfs(i, id);
                id++;
            }
        }

        vector<int> infectedCnt(id, 0);

        // Count infected nodes in each component
        for (int i = 1; i <= n; i++) {
            if (malware[i] == 1)
                infectedCnt[comp[i]]++;
        }

        int ans = -1;
        int maxSaved = -1;

        for (int i = 1; i <= n; i++) {

            if (malware[i] == 0)
                continue;

            int c = comp[i];

            if (infectedCnt[c] == 1) {

                if (compSize[c] > maxSaved) {
                    maxSaved = compSize[c];
                    ans = i;
                }
                else if (compSize[c] == maxSaved && i < ans) {
                    ans = i;
                }
            }
        }

        // If no component has exactly one infected node
        if (ans == -1) {
            for (int i = 1; i <= n; i++) {
                if (malware[i] == 1)
                    return i;
            }
        }

        return ans;
    }
};

int main() {

    int g_nodes, g_edges;
    cin >> g_nodes >> g_edges;

    vector<int> g_from(g_edges), g_to(g_edges);

    for (int i = 0; i < g_edges; i++)
        cin >> g_from[i];

    for (int i = 0; i < g_edges; i++)
        cin >> g_to[i];

    vector<int> malware(g_nodes + 1);

    for (int i = 1; i <= g_nodes; i++)
        cin >> malware[i];

    Solution obj;

    cout << obj.minMalwareSpread(g_nodes, g_from, g_to, malware);

    return 0;
}