#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// 0: (a=0, b=0), 1: (a=1, b=0), 2: (a=1, b=1)
struct ArrayZ3 {
  static int N, LEN;
  static void setN(int N_) {
    assert(N_ >= 0);
    N = N_;
    LEN = (N + 63) >> 6;
  }
  vector<unsigned long long> as, bs;
  ArrayZ3() : as(LEN, 0ULL), bs(LEN, 0ULL) {};
  friend ostream &operator<<(ostream &os, const ArrayZ3 &f) {
    for (int i = 0; i < N; ++i) os << f[i];
    return os;
  }
  void set(int i, int val) {
    const int x = i >> 6, y = i & 63;
    (val >= 1) ? (as[x] |= 1ULL << y) : (as[x] &= ~(1ULL << y));
    (val >= 2) ? (bs[x] |= 1ULL << y) : (bs[x] &= ~(1ULL << y));
  }
  int operator[](int i) const {
    const int x = i >> 6, y = i & 63;
    return static_cast<int>(as[x] >> y & 1ULL) + static_cast<int>(bs[x] >> y & 1ULL);
  }
  void swap(ArrayZ3 &f) {
    as.swap(f.as);
    bs.swap(f.bs);
  }
  // [i, N); assumes (*this)[floor(i/64)*64, i) is zero
  int sumSuf(int i) const {
    int ret = 0;
    for (int x = i >> 6; x < LEN; ++x) {
      ret += __builtin_popcountll(as[x]) + __builtin_popcountll(bs[x]);
    }
    return ret % 3;
  }
  // [i, N); assumes (*this)[floor(i/64)*64, i) is zero
  void negateSuf(int i) {
    for (int x = i >> 6; x < LEN; ++x) {
      bs[x] ^= as[x];
    }
  }
  // [i, N); assumes f[floor(i/64)*64, i) is zero
  void addSuf(int i, const ArrayZ3 &f) {
    for (int x = i >> 6; x < LEN; ++x) {
      const unsigned long long t = as[x] ^ f.bs[x];
      as[x] = (as[x] ^ f.as[x]) | (bs[x] ^ t);
      bs[x] = t & (bs[x] ^ f.as[x]);
    }
  }
  // [i, N); assumes f[floor(i/64)*64, i) is zero
  void subSuf(int i, const ArrayZ3 &f) {
    for (int x = i >> 6; x < LEN; ++x) {
      const unsigned long long t = as[x] ^ f.as[x];
      as[x] = t | (bs[x] ^ f.bs[x]);
      bs[x] = (bs[x] ^ f.as[x]) & (f.bs[x] ^ t);
    }
  }
  // [i, N); assumes f[floor(i/64)*64, i) is zero
  // pointwise
  void mulSuf(int i, const ArrayZ3 &f) {
    for (int x = i >> 6; x < LEN; ++x) {
      bs[x] = (as[x] &= f.as[x]) & (bs[x] ^ f.bs[x]);
    }
  }
};
int ArrayZ3::N, ArrayZ3::LEN;
// !!!Use ArrayZ3::setN!!!


void unittest() {
  mt19937_64 rng;
  for (int t = 0; t < 100; ++t) {
    const int N = 1 + rng() % 1000;
    cerr << "[unittest] N = " << N << endl;
    vector<int> as(N), bs(N), cs(N), ds(N);
    for (int i = 0; i < N; ++i) {
      as[i] = rng() % 3;
      bs[i] = rng() % 3;
      cs[i] = rng() % 3;
      ds[i] = rng() % 3;
    }
    ArrayZ3::setN(N);
    ArrayZ3 A, B, C, D;
    for (int i = 0; i < N; ++i) {
      A.set(i, as[i]);
      B.set(i, bs[i]);
      C.set(i, cs[i]);
      D.set(i, ds[i]);
    }
    auto check = [&]() -> void {
      for (int x = 0; x < ArrayZ3::LEN; ++x) {
        assert(!(~A.as[x] & A.bs[x]));
      }
      for (int i = 0; i < N; ++i) {
        assert(as[i] == A[i]);
      }
    };
    A.negateSuf(0);
    for (int i = 0; i < N; ++i) (as[i] *= 2) %= 3;
    check();
    A.addSuf(0, B);
    for (int i = 0; i < N; ++i) (as[i] += bs[i]) %= 3;
    check();
    A.subSuf(0, C);
    for (int i = 0; i < N; ++i) (as[i] += (3 - cs[i])) %= 3;
    check();
    A.mulSuf(0, D);
    for (int i = 0; i < N; ++i) (as[i] *= ds[i]) %= 3;
    check();
  }
}


int M, N;
ArrayZ3 a[2010];

int main() {
#ifdef LOCAL
  unittest();
#endif
  
  for (; ~scanf("%d%d", &N, &M); ) {
    ArrayZ3::setN(N + 1);
    for (int i = 0; i < M; ++i) {
      a[i] = ArrayZ3();
      for (int j = 0; j <= N; ++j) {
        int val;
        scanf("%d", &val);
        a[i].set(j, val);
      }
    }
// for(int i=0;i<M;++i)cerr<<a[i]<<endl;
    
    int r = 0;
    vector<int> js;
    for (int h = 0; h < N; ++h) {
      for (int i = r; i < M; ++i) if (a[i][h]) {
        a[r].swap(a[i]);
        break;
      }
      if (r < M && a[r][h]) {
        if (a[r][h] == 2) {
          a[r].negateSuf(h);
        }
        for (int i = r + 1; i < M; ++i) {
          const int s = a[i][h];
          if (s == 1) a[i].subSuf(h, a[r]);
          if (s == 2) a[i].addSuf(h, a[r]);
        }
        ++r;
        js.push_back(h);
      }
    }
// cerr<<"r = "<<r<<", js = "<<js<<endl;
// for(int i=0;i<M;++i)cerr<<a[i]<<endl;
    
    ArrayZ3 xs;
    for (int i = r; --i >= 0; ) {
      const int j = js[i];
      auto prod = a[i];
      prod.mulSuf(j, xs);
      xs.set(j, (a[i][N] - prod.sumSuf(j + 1) + 3) % 3);
    }
    
    for (int j = 0; j < N; ++j) {
      if (j) printf(" ");
      printf("%d", xs[j]);
    }
    puts("");
  }
  return 0;
}