lca(binups) + crascal(dsu)

/*

 ∧＿∧
( ･ω･｡)つ━☆・*。
⊂　 ノ 　　　・゜
しーＪ　　 Accepted

*/

// #pragma GCC optimize("O3")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define all(x) begin(x), end(x)
#define x first
#define y second
#define int unsigned int

using namespace std;
using namespace __gnu_pbds;

typedef pair<int, int> pii;
typedef long double ld;
template<typename T>
using kawaii_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

const ld PI = atan2(0, -1);

void seriy() {
    // ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(14);
    #ifdef _offline
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

const int MAXN = 1e5 + 10;
const int MAXM = 600;
const int INF = INT_MAX;
const int MOD = 1e9 + 7;
const int MAXLOG = 31;

struct edge {
    int u, v, w;
};

vector<vector<pair<int, int>>> g, g2;
vector<edge> edges;
vector<int> par, sz, p1, p2, w1, w2, d1, d2;
int up1[MAXLOG][MAXN], up2[MAXLOG][MAXN], kek1[MAXLOG][MAXN], kek2[MAXLOG][MAXN];
int n, m;

int get(int a) {
    if(par[a] == a) {
        return a;
    }
    return par[a] = get(par[par[a]]);
}

void unite(int a, int b) {
    a = get(a);
    b = get(b);
    if(a != b) {
        if(sz[a] < sz[b]) {
            swap(a, b);
        }
        par[b] = a;
        sz[a] += sz[b];
    }
}

void dfs(int u, int p) {
    for(auto v : g[u]) {
        if(v.x != p) {
            d1[v.x] = d1[u] + 1;
            p1[v.x] = u;
            w1[v.x] = v.y;
            dfs(v.x, u);
        }
    }
}

void dfs2(int u, int p) {
    for(auto v : g2[u]) {
        if(v.x != p) {
            d2[v.x] = d2[u] + 1;
            p2[v.x] = u;
            w2[v.x] = v.y;
            dfs2(v.x, u);
        }
    }
}

void build() {
    for(int i = 0; i < n; i++) {
        up1[0][i] = w1[i];
        kek1[0][i] = p1[i];
        up2[0][i] = w2[i];
        kek2[0][i] = p2[i];
    }
    for(int i = 1; i < MAXLOG; i++) {
        for(int j = 0; j < n; j++) {
            kek1[i][j] = kek1[i - 1][kek1[i - 1][j]];
            kek2[i][j] = kek2[i - 1][kek2[i - 1][j]];
            up1[i][j] = min(up1[i - 1][kek1[i - 1][j]], up1[i - 1][j]);
            up2[i][j] = min(up2[i - 1][kek2[i - 1][j]], up2[i - 1][j]);
        }
    }
}

pair<int, int> lca1(int a, int b) {
    if(d1[a] > d1[b]) {
        swap(a, b);
    }
    int lw = INF;
    for(int i = MAXLOG - 1; i >= 0; i--) {
        int to = kek1[i][b];
        if(d1[to] >= d1[a]) {
            lw = min(lw, up1[i][b]);
            b = kek1[i][b];
        }
    }
    if(a == b) {
        return {a, lw};
    }
    for(int i = MAXLOG - 1; i >= 0; i--) {
        int to1 = kek1[i][a];
        int to2 = kek1[i][b];
        if(to1 != to2) {
            a = kek1[i][a];
            b = kek1[i][b];
            lw = min(lw, up1[i][a]);
            lw = min(lw, up1[i][b]);
        }
    }
    return {p1[a], min(min(lw, w1[a]), w1[b])};
}

pair<int, int> lca2(int a, int b) {
    if(d2[a] > d2[b]) {
        swap(a, b);
    }
    int lw = INF;
    for(int i = MAXLOG - 1; i >= 0; i--) {
        int to = kek2[i][b];
        if(d2[to] >= d2[a]) {
            lw = min(lw, up2[i][b]);
            b = kek2[i][b];
        }
    }
    if(a == b) {
        return {a, lw};
    }
    for(int i = MAXLOG - 1; i >= 0; i--) {
        int to1 = kek2[i][a];
        int to2 = kek2[i][b];
        if(to1 != to2) {
            a = kek2[i][a];
            b = kek2[i][b];
            lw = min(lw, up2[i][a]);
            lw = min(lw, up2[i][b]);
        }
    }
    return {p2[a], min(min(lw, w2[a]), w2[b])};
}

signed main() {
    seriy();
    cin >> n >> m;
    p1.resize(n);
    p2.resize(n);
    d1.resize(n);
    d2.resize(n);
    g.resize(n);
    w1.resize(n, -1);
    w2.resize(n, -1);
    g2.resize(n);
    sz.resize(n, 1);
    par.resize(n);
    for(int i = 0; i < n; i++) {
        par[i] = i;
    }
    for(int i = 0; i < m; i++) {
        int u, v, t, w;
        cin >> t >> u >> v >> w;
        u--;
        v--;
        if(t == 1){
            g[u].push_back({v, w});
            g[v].push_back({u, w});
        }
        edges.push_back({u, v, w});
    }
    sort(all(edges), [&](edge a, edge b) {
        return a.w > b.w;
    });
    for(auto edge : edges) {
        int u = edge.u;
        int v = edge.v;
        if(get(u) != get(v)) {
            g2[u].push_back({v, edge.w});
            g2[v].push_back({u, edge.w});
            unite(u, v);
        }
    }
    dfs(0, -1);
    dfs2(0, -1);
    build();
    vector<int> ans;
    vector<int> keks(n);
    for(int j = 0; j < MAXLOG; j++) {
        for(int i = 0; i < n; i++) {
            if(p1[i] != p2[i]) {
                keks[i] |= 1;
            }
        }
    }
    for(int i = 0; i < n; i++) {
        if(!keks[i]) {
            ans.push_back(i + 1);
        }
    }
    cout << ans.size() << '\n';
    for(auto i : ans) {
        cout << i << " ";
    }
    return 0;
}