#include <algorithm>
#include <fstream>
#include <set>
#include <sstream>
#include <vector>
#include <cassert>
#include <iostream>
#include <numeric>

#include "testlib.h"
using namespace std;

class UnionFind {
private:
    int sz;
    vector<int> par, size_;
public:
    UnionFind(){}
    UnionFind(int node_size) : sz(node_size), par(sz), size_(sz, 1){
        iota(par.begin(), par.end(), 0);
    }
    int find(int x){
        if(par[x] == x) return x;
        else return par[x] = find(par[x]);
    }
    void unite(int x,int y){
        x = find(x), y = find(y);
        if(x == y) return;
        if(size_[x] < size_[y]) swap(x,y);
        par[y] = x;
        size_[x] += size_[y];
    }
    int size(int x){
        x = find(x);
        return size_[x];
    }
    bool same(int x,int y){
        return find(x) == find(y);
    }
};

int main(int argc, char** argv)
{
    registerTestlibCmd(argc, argv);
    while (!ans.seekEof()) {
        int n = inf.readInt();
        int m = inf.readInt();
        vector<pair<int,int>> edges;
        for (int i = 0; i < m; ++i) {        
            int u = inf.readInt();
            int v = inf.readInt();
            u--;v--;
            edges.push_back({u,v});
        }
        int ans_K = ans.readInt();
        if(ans_K!=-1){
            for (int i = 0; i < m; ++i) {        
                int k = ans.readInt();
            }
        }

        int K = ouf.readInt();
        if(ans_K < K){
            quitf(_wa, "K = %d is larger than answer = %d", K, ans_K);
        }
        if(ans_K!=-1&&K==-1){
            quitf(_wa, "output has no assignment, but there is valid assignment");
        }
        if(ans_K==-1&&K!=-1){
            quitf(_wa, "output is invalid: there is no valid assignment");
        }
        if(ans_K==-1&&K==-1)continue;
        vector<set<int> > used_edge_set(K);
        for(int i=0;i<m;i++){
            int k = ouf.readInt();
            if(k < 1 || k > K){
                quitf(_wa, "output is invalid: invalid assignment");
            }
            k--;
            used_edge_set[k].insert(i);
        }
        for(int k=0;k<K;k++){
            UnionFind uf(n);
            for(int j=0;j<m;j++){
                if(used_edge_set[k].count(j))continue;
                uf.unite(edges[j].first, edges[j].second);
            }
            for(int i=0;i<n;i++){
                if(!uf.same(i,0)){
                    quitf(_wa, "output is invalid: complement graph for %d-th assignment is not connected", k+1);
                }
            }
        }
        if(ans_K > K){
            quitf(_fail, "judge failed: output K = %d is smaller than answer = %d. It is suspected that this judge is wrong.", K, ans_K);
        }
    }
    quitf(_ok, "OK");

    return 0;
}