// Go in my style.
// Not afraid to dark.

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

clock_t sttime;
#define STCLOCK sttime = clock ();
#define TIMENOW fprintf (stderr, "\nNOW TIME COSSEMED: %0.4lf\n", 1.0 * (clock () - sttime) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

#define ll long long

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
}

const int N = 2e5;
int n, df[N + 5], rp[N + 5], cnt, fa[N + 5], fl[N + 5], root, sz[N + 5];
array < int , 3 > eg[N + 5];
int firs[N + 5], nex[N * 2 + 5], to[N * 2 + 5], w[N * 2 + 5], tot;
ll dep[N + 5];
bool vis[N + 5];

inline void Add (int u, int v, int l){
    nex[++ tot] = firs[u], firs[u] = tot, to[tot] = v, w[tot] = l;
    nex[++ tot] = firs[v], firs[v] = tot, to[tot] = u, w[tot] = l;
}

void init (int u, int father){
    fa[u] = father;
    rp[df[u] = ++ cnt] = u;
    sz[u] = 1;
    for (int e = firs[u], v;e;e = nex[e]){
        v = to[e];
        if (v == father) continue;
        dep[v] = dep[u] + w[e];
        fl[v] = w[e];
        init (v, u);
        sz[u] += sz[v];
    }
}

namespace ds {
    namespace sgt {
        #define lson(qb) ((qb) << 1)
        #define rson(qb) ((qb) << 1 | 1)
        const int P = N << 2;
        int lt[P], rt[P];
        int dwn[P];
        ll mxd[P], dtag[P];
        inline void put_tag (int p, int x){ mxd[p] += x; dtag[p] += x; }
        inline void push_up (int p){
            mxd[p] = - 0x3f3f3f3f3f3f3f3fll;
            if (! dwn[lson (p)]) mxd[p] = max (mxd[p], mxd[lson (p)]);
            if (! dwn[rson (p)]) mxd[p] = max (mxd[p], mxd[rson (p)]);
        }
        inline void push_down (int p){
            if (dtag[p]){
                put_tag (lson (p), dtag[p]);
                put_tag (rson (p), dtag[p]);
                dtag[p] = 0;
            }
        }
        void Build (int p, int l, int r){
            tie (lt[p], rt[p]) = {l, r};
            dwn[p] = mxd[p] = dtag[p] = 0;
            if (l == r) return mxd[p] = dep[rp[l]], void ();
            int mid = (l + r) >> 1;
            Build (lson (p), l, mid), Build (rson (p), mid + 1, r);
            push_up (p);
        }
        void updm (int p, int l, int r, int x){
            if (l <= lt[p] && rt[p] <= r) return put_tag (p, x), void ();
            push_down (p);
            int mid = (lt[p] + rt[p]) >> 1;
            if (l <= mid) updm (lson (p), l, r, x);
            if (r > mid) updm (rson (p), l, r, x);
            push_up (p);
        }
        void updd (int p, int l, int r, int x){
            if (l <= lt[p] && rt[p] <= r) return dwn[p] += x, void ();
            push_down (p);
            int mid = (lt[p] + rt[p]) >> 1;
            if (l <= mid) updd (lson (p), l, r, x);
            if (r > mid) updd (rson (p), l, r, x);
            push_up (p);
        }
        void que (int p, ll d, vector < int > &ans){
            if (lt[p] == rt[p]) return ans.push_back (rp[lt[p]]);
            push_down (p);
            if (! dwn[lson (p)] && mxd[lson (p)] == d) que (lson (p), d, ans);
            if (! dwn[rson (p)] && mxd[rson (p)] == d) que (rson (p), d, ans);
        }
        #undef lson
        #undef rson
    }
} using namespace ds::sgt;

signed main (){
    STCLOCK

    io::read (n);
    for (int i = 1, u, v, l;i < n;++ i){
        io::read (u), io::read (v), io::read (l);
        Add (u, v, l);
        eg[i] = {u, v, l};
    }
    init (1, 0); Build (1, 1, n);
    for (int T = io::read (), o, x, u, v, l;T --;){
        io::read (o), io::read (x);
        if (o == 2){
            u = eg[x][0], v = eg[x][1], l = eg[x][2];
            if (u != fa[v]) swap (u, v);
            if (! vis[v]) updd (1, df[v], df[v] + sz[v] - 1, 1);
            else {
                if (df[v] > 1) updd (1, 1, df[v] - 1, 1);
                if (df[v] + sz[v] <= n) updd (1, df[v] + sz[v], n, 1);
            }
        } else
        if (o == 3){
            u = eg[x][0], v = eg[x][1], l = eg[x][2];
            if (u != fa[v]) swap (u, v);
            if (! vis[v]) updd (1, df[v], df[v] + sz[v] - 1, - 1);
            else {
                if (df[v] > 1) updd (1, 1, df[v] - 1, - 1);
                if (df[v] + sz[v] <= n) updd (1, df[v] + sz[v], n, - 1);
            }
        } else {
            if (x == fa[root]){
                vis[root] = false;
                updm (1, 1, n, - fl[root]);
                updm (1, df[root], df[root] + sz[root] - 1, fl[root] << 1);
            } else {
                vis[x] = true;
                updm (1, 1, n, fl[x]);
                updm (1, df[x], df[x] + sz[x] - 1, - fl[x] << 1);
            }
            root = x;
        }
        vector < int > ans;
        que (1, mxd[1], ans); sort (ans.begin (), ans.end ());
        io::write ((int) ans.size ());
        for (int x : ans) putchar (' '), io::write (x);
        puts ("");
    }

    TIMENOW
    return 0;
}