Problem: Berland has n cities, some of them are connected by bidirectional roads. For each road we know whether it is asphalted or not.

The King of Berland Valera II wants to asphalt all roads of Berland, for that he gathered a group of workers. Every day Valera chooses exactly one city and orders the crew to asphalt all roads that come from the city. The valiant crew fulfilled the King's order in a day, then workers went home.

Unfortunately, not everything is as great as Valera II would like. The main part of the group were gastarbeiters — illegal immigrants who are enthusiastic but not exactly good at understanding orders in Berlandian. Therefore, having received orders to asphalt the roads coming from some of the city, the group asphalted all non-asphalted roads coming from the city, and vice versa, took the asphalt from the roads that had it.

Upon learning of this progress, Valera II was very upset, but since it was too late to change anything, he asked you to make a program that determines whether you can in some way asphalt Berlandian roads in at most n days. Help the king.

Input

The first line contains two space-separated integers n, m <image> — the number of cities and roads in Berland, correspondingly. Next m lines contain the descriptions of roads in Berland: the i-th line contains three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n; ai ≠ bi; 0 ≤ ci ≤ 1). The first two integers (ai, bi) are indexes of the cities that are connected by the i-th road, the third integer (ci) equals 1, if the road was initially asphalted, and 0 otherwise. 

Consider the cities in Berland indexed from 1 to n, and the roads indexed from 1 to m. It is guaranteed that between two Berlandian cities there is not more than one road.

Output

In the first line print a single integer x (0 ≤ x ≤ n) — the number of days needed to asphalt all roads. In the second line print x space-separated integers — the indexes of the cities to send the workers to. Print the cities in the order, in which Valera send the workers to asphalt roads. If there are multiple solutions, print any of them. 

If there's no way to asphalt all roads, print "Impossible" (without the quotes).

Examples

Input

4 4
1 2 1
2 4 0
4 3 1
3 2 0


Output

4
3 2 1 3


Input

3 3
1 2 0
2 3 0
3 1 0


Output

Impossible

Solution (in JAVA):

Solution:
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.List;

public class Main {

	private static final String NO = "No";
	private static final String YES = "Yes";
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	private static final long MOD = (long) (1e9 + 7);

	void solve() {
		int T = 1;// ni();
		for (int i = 0; i < T; i++)
			solve(i);
	}

	// index 1 based
	int p[];
	int size[];

	void init(int n) {
		p = new int[n + 1];
		size = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			p[i] = i;
			size[i] = i <= n / 2 ? 1 : 0;
		}
	}

	private void connect(int u, int v) {
		int u0 = find(u);
		int v0 = find(v);
		if (u0 == v0)
			return;
		p[u0] = v0;
		size[v0] += size[u0];
	}

	private int find(int x) {
		if (p[x] == x)
			return x;
		else
			return p[x] = find(p[x]);
	}

	void solve(int nth) {
		int n = ni();
		int m = ni();
		init(n + n);
		for (int i = 0; i < m; i++) {
			int u = ni();
			int v = ni();
			int c = ni();
			if (c == 0) {
				connect(u, n + v);
				connect(n + u, v);
			} else {
				connect(u, v);
				connect(n + u, n + v);
			}
		}
		List<Integer> res = new ArrayList<Integer>();

		for (int i = 1; i <= n; i++) {
			int p1 = find(i);
			int p2 = find(i + n);
//			tr(i, p1, p2);
			if (p1 == p2) {
				out.print("Impossible");
				return;
			}
			if (size[p1] > size[p2] || size[p1] == size[p2] && p1 > p2)
				res.add(i);
		}
		out.println(res.size());
		for (int i : res)
			out.print(i + " ");
	}

	// a^b
	long power(long a, long b) {
		long x = 1, y = a;
		while (b > 0) {
			if (b % 2 != 0) {
				x = (x * y) % MOD;
			}
			y = (y * y) % MOD;
			b /= 2;
		}
		return x % MOD;
	}

	private long gcd(long a, long b) {
		while (a != 0) {
			long tmp = b % a;
			b = a;
			a = tmp;
		}
		return b;
	}

	void run() throws Exception {
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if (!INPUT.isEmpty())
			tr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception {
		new Main().run();
	}

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	private double nd() {
		return Double.parseDouble(ns());
	}

	private char nc() {
		return (char) skip();
	}

	private char[] nc(int n) {
		char[] ret = new char[n];
		for (int i = 0; i < n; i++)
			ret[i] = nc();
		return ret;
	}

	private String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n) {
			if (!(isSpaceChar(b)))
				buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private Integer[] na2(int n) {
		Integer[] a = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int[][] na(int n, int m) {
		int[][] a = new int[n][];
		for (int i = 0; i < n; i++)
			a[i] = na(m);
		return a;
	}

	private int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private Long[] nl2(int n) {
		Long[] a = new Long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}

	private long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}

	private long[][] nl(int n, int m) {
		long[][] a = new long[n][];
		for (int i = 0; i < n; i++)
			a[i] = nl(m);
		return a;
	}

	private long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	public static class IterablePermutation implements Iterable<int[]>, Iterator<int[]> {
		int[] a;
		boolean first = true;

		public IterablePermutation(int n) {
			assert n >= 1;
			a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = i;
		}

		public IterablePermutation(int... a) {
			this.a = Arrays.copyOf(a, a.length);
		}

		@Override
		public boolean hasNext() {
			if (first)
				return true;
			int n = a.length;
			int i;
			for (i = n - 2; i >= 0 && a[i] >= a[i + 1]; i--)
				;
			return i != -1;
		}

		@Override
		public int[] next() {
			if (first) {
				first = false;
				return a;
			}
			int n = a.length;
			int i;
			for (i = n - 2; i >= 0 && a[i] >= a[i + 1]; i--)
				;
			assert i != -1;
			int j;
			for (j = i + 1; j < n && a[i] < a[j]; j++)
				;
			int d = a[i];
			a[i] = a[j - 1];
			a[j - 1] = d;
			for (int p = i + 1, q = n - 1; p < q; p++, q--) {
				d = a[p];
				a[p] = a[q];
				a[q] = d;
			}
			return a;
		}

		@Override
		public Iterator<int[]> iterator() {
			return this;
		}
	}

	class Matrix {

		int N; // size of the matrix

		/**
		 * compute pow(base, pow) O(N^3) * logN
		 **/
		long[][] matrixPower(long[][] base, long pow) {
			N = base.length;
			long[][] ans = new long[N][N];
			// generate identity matrix
			for (int i = 0; i < N; i++)
				ans[i][i] = 1;

			// binary exponentiation
			while (pow != 0) {
				if ((pow & 1) != 0)
					ans = multiplyMatrix(ans, base);

				base = multiplyMatrix(base, base);

				pow >>= 1;
			}
			return ans;
		}

		/**
		 * compute m * m2 O(N^3)
		 **/
		long[][] multiplyMatrix(long[][] m, long[][] m2) {
			long[][] ans = new long[N][N];

			for (int i = 0; i < N; i++)
				for (int j = 0; j < N; j++) {
					ans[i][j] = 0;
					for (int k = 0; k < N; k++) {
						ans[i][j] += m[i][k] * m2[k][j];
						ans[i][j] %= MOD;
					}
				}
			return ans;
		}
	}

	private static void tr(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

}