#include <iostream>
#include <algorithm>
#include <cmath>
#include <bitset>
#include <cstring>
#include <string.h>
#include <sstream>
#include <iomanip>
#include <queue>
#include <stack>
#include <deque>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <tuple>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const ll MOD = 1e9+7;
const ll CFMOD = 998244353;
const double PI  = 3.14159265358;
const double EPS = 1e-6;

#define INT_MX 2147483647
#define INF ((int)1e9)
#define LLINF ((ll)1e18)
#define F first
#define S second
#define MP(x,y) make_pair(x,y)
#define sz(v) ((int)v.size())
#define rs(n) resize(n)
#define ALL(v) v.begin(),v.end()
#define reset(v, x) memset((v),(x),sizeof(v))
#define EB emplace_back
#define PB push_back
#define PF push_front
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,a,b) for(int i=(a);i<(b);i++)
#define vec vector
#define __ <<' '<<
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#define N 200000

vec<int> v[8*N], r[8*N];

void add_edge(int a, int b){
    v[a].EB(b);
    r[b].EB(a);
}

int A[4*N + 10], B[4*N + 10], node_cnt, num[N + 10];
void build(int idx, int lb, int rb){
    if(lb == rb){
        A[idx] = B[idx] = node_cnt;
        num[lb] = node_cnt++;
        return ;
    }
    int mid = (lb + rb) / 2;
    build(idx * 2, lb, mid);
    build(idx * 2 + 1, mid + 1, rb);
    A[idx] = node_cnt++;
    B[idx] = node_cnt++;
    add_edge(A[idx * 2], A[idx]);
    add_edge(A[idx * 2 + 1], A[idx]);
    add_edge(B[idx], B[idx * 2]);
    add_edge(B[idx], B[idx * 2 + 1]);
}

void build_edge(int idx, int lb, int rb, int ql, int qr, int v, int type){
    if(ql <= lb && rb <= qr){
        if(type != 3)
            add_edge(num[v], B[idx]);
        else
            add_edge(A[idx], num[v]);
        return ;
    }

    int mid = (lb + rb) / 2;
    if(ql <= mid)
        build_edge(idx * 2, lb, mid, ql, qr, v, type);
    if(qr > mid)
        build_edge(idx * 2 + 1, mid + 1, rb, ql, qr, v, type);
}

int scc[8*N];
bool vis[8*N];
vec<int> order;

void revdfs(int x){
    vis[x] = true;
    for(int i : r[x]) if(!vis[i])
        revdfs(i);
    order.EB(x);
}

void dfs(int x, int s){
    scc[x] = s;
    for(int i:v[x]) if(scc[i] == -1)
        dfs(i, s);
}

void kosaraju(int n){
    reset(vis, 0);
    reset(scc, -1);

    rep(i, n) if(!vis[i])
        revdfs(i);

    int nscc = 0;
    for(int i = n-1; i >= 0; i--){
        int x = order[i];
        if(scc[x] == -1){
            dfs(x, nscc);
            nscc++;
        }
    }
}




void solve(){
    int n, m, mxn;
    int type, u, l, r;

    cin >> n >> m;
    mxn = 1;
    while(mxn < n)
        mxn <<= 1;
    mxn = n;
    build(1, 1, mxn);
    rep(i, m){
        cin >> type >> u;
        if(type == 1) cin >> l , r = l;
        else    cin >> l >> r;
        // l--; r--; u--;
        build_edge(1, 1, mxn, l, r, u, type);
    }

    int ipt;
    while(true){
        cin >> ipt;
        for(auto i:v[ipt])
            cout << i << ' ';
        cout << '\n';
    }

    kosaraju(mxn);

    vec<int> in_deg;
    in_deg.rs(n);

    rep(i, n)
        cout << scc[num[i+1]] << '\n';

    for(int i = mxn; i < mxn + n; i++){
        for(auto j:v[i])
            if(0 <= j - mxn && j - mxn < n)
                if(scc[i] != scc[j])
                    in_deg[j - mxn]++;
    }

    rep(i, n)
        cout << in_deg[i] << ' ';
    cout << '\n';

    int ans = 0, cnt;
    for(int i=mxn; i < mxn + n; i++){
        cnt = 0;
        for(auto j:v[i])
            if(0 <= j - mxn && j - mxn < n)
                if(in_deg[j - mxn] == 0)
                    cnt++;
        ans = max(ans, cnt);
    }

    cout << ans << '\n';
}

int main() {
    int T = 1;

    //cin >> T;
    while(T--){
        solve();
    }
}