#include <bits/stdc++.h>

const int N = 2e3 + 50;

int n, m, A[N][N];

struct Z3vec {
	std::bitset<N> A, B, C;
	Z3vec() {
		A.reset();
		B.reset();
		C.reset();
	}
	Z3vec(std::bitset<N> A, std::bitset<N> B) : A(A), B(B), C(~(A ^ B)) {

	}
	void set(int k, int v) {
		assert(0 <= v && v < 3);
		A.reset(k);
		B.reset(k);
		C.reset(k);
		if (v == 0) {
			C.set(k);
		}
		else if (v == 1) {
			A.set(k);
		}
		else {
			B.set(k);
		}
	}
	int get(int k) {
		if (A[k]) return 1;
		else if (B[k]) return 2;
		return 0;
	}
} Z[N];

Z3vec operator+(const Z3vec &lhs, const Z3vec &rhs) {
	auto A = (lhs.C & rhs.A) | (lhs.A & rhs.C) | (lhs.B & rhs.B);
	// 1 + 0, 0 + 1, 2 + 2
	auto B = (lhs.A & rhs.A) | (lhs.B & rhs.C) | (lhs.C & rhs.B);
	// 1 + 1, 0 + 2, 2 + 0
	return Z3vec(A, B);
}

Z3vec operator-(const Z3vec &lhs, const Z3vec &rhs) {
	auto A = (lhs.A & rhs.C) | (lhs.B & rhs.A) | (lhs.C & rhs.B);
	// 1 - 0, 2 - 1, 0 - 2
	auto B = (lhs.B & rhs.C) | (lhs.C & rhs.A) | (lhs.A & rhs.B);
	// 2 - 0 0 - 1 1 - 2
	return Z3vec(A, B);
}

void operator+=(Z3vec &lhs, const Z3vec &rhs) {
	auto A = (lhs.C & rhs.A) | (lhs.A & rhs.C) | (lhs.B & rhs.B);
	// 1 + 0, 0 + 1, 2 + 2
	auto B = (lhs.A & rhs.A) | (lhs.B & rhs.C) | (lhs.C & rhs.B);
	// 1 + 1, 0 + 2, 2 + 0
	lhs.A = A, lhs.B = B;
	lhs.C = ~(lhs.A ^ lhs.B);
}

void operator-=(Z3vec &lhs, const Z3vec &rhs) {
	auto A = (lhs.A & rhs.C) | (lhs.B & rhs.A) | (lhs.C & rhs.B);
	// 1 - 0, 2 - 1, 0 - 2
	auto B = (lhs.B & rhs.C) | (lhs.C & rhs.A) | (lhs.A & rhs.B);
	// 2 - 0 0 - 1 1 - 2
	lhs.A = A, lhs.B = B;
	lhs.C = ~(lhs.A ^ lhs.B);
}

int p[N];

void gauss() {
	int lst = 1;
	for (int i = 1; i <= n; ++i) {	
		int k = -1;
		for (int j = lst; j <= m; ++j) {
			assert(Z[j].A[i] + Z[j].B[i] + Z[j].C[i] == 1);
			if (Z[j].C[i] == 0) {
				k = j;
				break;
			}
		}
		if (k == -1) {
			continue;
		}
		p[i] = lst;
		std::swap(Z[lst], Z[k]);
		int x = Z[lst].get(i);
		for (int j = 1; j <= m; ++j)
			if (lst != j) {
				int t = (x * Z[j].get(i)) % 3;
				if (t != 0) {
					auto w = Z[lst];
					if (t == 2) w += w;
					Z[j] -= w;
					assert(Z[j].get(i) == 0);
				}
			}
		++lst;
	}
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.tie(nullptr);
	std::cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		int x;
		for (int j = 1; j <= n + 1; ++j) {
			std::cin >> x;
			Z[i].set(j, x);
		}
	}
	gauss();
	for (int i = 1; i <= n; ++i) {
		if (p[i] == 0) printf("0 ");
		else printf("%d ", (Z[p[i]].get(i) * Z[p[i]].get(n + 1)) % 3);
	}
}