#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
void _dfs_forward(int v, const vector<vector<int> >& V, stack<int>& S,
                  vector<int>& visited) {
  if (visited[v] == 1) return;
  visited[v] = 1;
  for (int x : V[v]) {
    _dfs_forward(x, V, S, visited);
  }
  S.push(v);
}
void _dfs_reverse(int v, const vector<vector<int> >& V, vector<int>& visited,
                  vector<int>& component) {
  if (visited[v] == 1) return;
  visited[v] = 1;
  component.push_back(v);
  for (int x : V[v]) {
    _dfs_reverse(x, V, visited, component);
  }
}
vector<vector<int> > strongly_connected(const vector<vector<int> >& V) {
  int n = V.size();
  vector<int> visited(n);
  for (int i = 0; i < n; ++i) visited[i] = 0;
  stack<int> S;
  for (int i = 0; i < n; ++i)
    if (visited[i] == 0) _dfs_forward(i, V, S, visited);
  vector<vector<int> > V_transposed(n);
  for (int i = 0; i < n; ++i) {
    for (int x : V[i]) {
      V_transposed[x].push_back(i);
    }
  }
  for (int i = 0; i < n; ++i) visited[i] = 0;
  vector<vector<int> > res;
  while (!S.empty()) {
    int v = S.top();
    S.pop();
    if (visited[v] == 0) {
      vector<int> component;
      _dfs_reverse(v, V_transposed, visited, component);
      res.push_back(component);
    }
  }
  return res;
}
pair<bool, vector<int> > solve_2sat(const vector<pair<int, int> >& clauses,
                                    int n = -1) {
  if (n == -1) {
    for (const auto& p : clauses) {
      n = max(n, abs(p.first));
      n = max(n, abs(p.second));
    }
  }
  vector<vector<int> > V(2 * n);
  for (const auto& p : clauses) {
    int a = (p.first < 0 ? n - p.first - 1 : p.first - 1);
    int b = (p.second < 0 ? n - p.second - 1 : p.second - 1);
    int nega = (a < n ? a + n : a - n);
    int negb = (b < n ? b + n : b - n);
    V[nega].push_back(b);
    V[negb].push_back(a);
  }
  vector<vector<int> > scc = strongly_connected(V);
  vector<int> cc(2 * n);
  for (int i = 0; i < scc.size(); ++i) {
    for (int x : scc[i]) {
      cc[x] = i;
    }
  }
  vector<int> sol(n);
  for (int i = 0; i < n; ++i) {
    if (cc[i] == cc[n + i]) {
      return {false, {}};
    } else {
      sol[i] = (cc[i] > cc[i + n] ? 1 : 0);
    }
  }
  return {true, sol};
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<pair<int, int> > clauses;
  while (m--) {
    int a, b, c;
    cin >> a >> b >> c;
    if (c == 0) {
      clauses.push_back({a, b});
      clauses.push_back({-a, -b});
    } else {
      clauses.push_back({-a, b});
      clauses.push_back({a, -b});
    }
  }
  auto res = solve_2sat(clauses, n);
  if (res.first) {
    set<int> co;
    for (int i = 0; i < n; ++i) {
      if (res.second[i] == 1) co.insert(i);
    }
    cout << co.size() << (char)10;
    for (int x : co) cout << 1 + x << " ";
    cout << (char)10;
  } else {
    cout << "Impossible" << (char)10;
  }
}
