#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <bitset>

using namespace std;

ifstream fin("party.in");
ofstream fout("party.out");

const int MAXN = 102;

int N, M;
int X, Y, tip;
vector<int> implication[MAXN];
vector<int> q;
bitset<MAXN * 2> in, visited, solution;

static int NOT(int x) {
    return (x > N) ? x - N : x + N;
}

static void add_or(int x, int y) {
    implication[NOT(x)].push_back(y);
    implication[NOT(y)].push_back(x);
}

bool try_set(int node) {
    q.resize(0);
    in.reset();

    q.push_back(node);
    in.set(node);
    for (int i = 0; i < q.size(); ++i) {
        const int& x = q[i];
        if (in.test(NOT(x))) return false;

        for (const int& y : implication[x]) {
            if (in.test(y)) continue;
            q.push_back(y);
            in.set(y);
        }
    }

    for (const int& x : q) {
        solution.set(x);
        solution.reset(NOT(x));
        visited.set(x);
        visited.set(NOT(x));
    }
    return true;
}

int main()
{
    fin >> N >> M;
    q.reserve(N + 1);
    for (int i = 0; i < M; ++i) {
        fin >> X >> Y >> tip;
        switch (tip) {
            case 0: {
                add_or(X, Y);
                break;
            }
            case 1: {
                add_or(X, NOT(Y));
                break;
            }
            case 2: {
                add_or(NOT(X), Y);
                break;
            }
            case 3: {
                add_or(NOT(X), NOT(Y));
            }
        }
    }

    for (int i = 1; i <= N; ++i) {
        if (visited.test(i)) continue;

        if (try_set(i)) continue;
        try_set(NOT(i));
    }

    vector<int> ans;
    for (int i = 1; i <= N; ++i) {
        if (solution.test(i)) ans.push_back(i);
    }

    fout << ans.size() << '\n';
    for (const int& x : ans) {
        fout << x << '\n';
    }

    return 0;
}