//#define _REAL_DEBUG_
#include <fstream>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>

using namespace std;

#ifdef _REAL_DEBUG_
ifstream cin("../10-lab-matching/input.txt");
ofstream cout("../10-lab-matching/output.txt");
#else
string file_name = "vertexcover";
ifstream cin(file_name + ".in");
ofstream cout(file_name + ".out");
#endif

const int inf = int(2e9), max_n = 4000;

// lr-graph
int size_left, size_right;
int to_norm[2][max_n];
vector<int> gl[max_n];
//


//normal-graph
int cnt_norm;
bool is_left[max_n * 2];
int to_lr[max_n * 2];
vector<int> g[max_n * 2];
int match_to_left[max_n * 2];
bool is_match[max_n * 2];
bool is_exist[max_n * 2][max_n * 2];
//

bool used[max_n * 2];
bool is_coved_left[max_n * 2];
vector<int> res_right;
vector<int> res_left;

void dfs(int v, bool is_right) {
    if (is_right) {
        res_right.push_back(to_lr[v]);
        is_coved_left[match_to_left[v]] = true;
    }
    for(auto to: g[v]) {
        if(!used[to]) {
            used[to] = true;
            dfs(to, is_right ^ 1);
        }
    }
    return;
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    cin >> size_left >> size_right;
    // left part: init convert array
    for (int i = 0; i < size_left; ++i) {
        is_left[cnt_norm] = true;
        to_lr[cnt_norm] = i;
        to_norm[1][i] = cnt_norm++;
    }
    // right part: init convert array
    for (int i = 0; i < size_right; ++i) {
        is_left[cnt_norm] = false;
        to_lr[cnt_norm] = i;
        to_norm[0][i] = cnt_norm++;
    }

    // read graph
    for (int i = 0, cnt_v; i < size_left; ++i) {
        cin >> cnt_v;
        for (int j = 0, v; j < cnt_v; ++j) {
            cin >> v; --v;
            gl[i].push_back(v);
        }
    }
    // read matching
    for (int i = 0, vr, l, r; i < size_left; ++i) {
        cin >> vr; --vr;
        if (vr != -1) {
            r = to_norm[0][vr];
            l = to_norm[1][i];
            g[r].push_back(l);
            is_exist[l][r] = true;
            is_match[l] = is_match[r] = true;
            match_to_left[r] = l;
        }
    }
    // init normal gragh
    for (int i = 0, l, r; i < size_left; ++i) {
        for (auto vr: gl[i]) {
            r = to_norm[0][vr];
            l = to_norm[1][i];
            if(!is_exist[l][r]) {
                g[l].push_back(r);
            }
        }
    }

    // count right vertex
    for (int i = 0, v; i < size_left; ++i) {
        v = to_norm[1][i];
        if(!is_match[v] && !used[v]) {
            dfs(v, false);
        }
    }

    //count left vertex
    for (int i = 0, v; i < size_left; ++i) {
        v = to_norm[1][i];
        if(is_match[v] && !is_coved_left[v]) {
            res_left.push_back(to_lr[v]);
        }
    }

    // write result
    sort(res_left.begin(), res_left.end());
    sort(res_right.begin(), res_right.end());

    cout << res_left.size() + res_right.size() << endl;
    cout << res_left.size() << " ";
    for (auto i: res_left) cout << i + 1 << " ";
    cout << endl;
    cout << res_right.size() << " ";
    for (auto i: res_right) cout << i + 1 << " ";

    return 0;
}