#include<bits/stdc++.h>
using namespace std;

/* FastIO by rsk0315 (last update: 2018/02/21 00:36) */

namespace FastIn {
    static constexpr size_t BUF_SIZE=1<<17, INT_LEN=24, FLT_LEN=400;
    static char buf[BUF_SIZE|1]={}, *pos=buf, *endbuf=nullptr;
    FILE *fin;

    inline bool rebuffer() {
        // returns true <=> there is at least one unread character
        size_t rest=endbuf-pos;
        if (buf+rest > pos) {
            // buf[:pos] and buf[-pos:] are overlapping, which std::memcpy()
            // causes undefined behavior.
            return true;
        }

        std::memcpy(buf, pos, rest);
        pos = buf;
        size_t len=std::fread(pos+rest, 1, BUF_SIZE-rest, fin);
        *(endbuf = buf + (rest+len)) = 0;

        return *pos;
    }

    inline bool scan(char &in) {
        if ((in = *pos)) {
            ++pos;
            return true;
        }

        return rebuffer() && (in = *pos++);
    }

    inline bool scan(char *in) {
        if ((*in = *pos) == 0) {
            if (rebuffer() && (*in = *pos) == 0) {
                return false;
            }
        }
        ++in;
        while (true) {
            if ((*in = *pos++) == 0) {
                if (rebuffer() && (*in = *pos++) == 0) {
                    return true;
                }
            }
            ++in;
        }
    }

    inline bool scan(double &in) {
        if (pos + FLT_LEN >= endbuf && !rebuffer()) {
            in = 0.0;
            return false;
        }

        char *tmp;
        in = std::strtod(pos, &tmp);
        pos = tmp;
        return true;
    }

    template <class Int>
    inline bool scan(Int &in) {
        in = 0;

        // assume that no redundant whitespace appears
        if (pos + INT_LEN >= endbuf && !rebuffer()) {
            return false;
        }

        if (std::is_signed<Int>::value) {
            if (*pos == '-') {
                in = ~*++pos+'1';
                while (*++pos >= '0') {
                    in = in*10 + ~*pos+'1';
                }
                ++pos;
                return true;
            }
        }

        // assume that numbers are separated by the character whose value is
        // less than '0' (e.g. whitespaces, newlines)
        do {
            in = in*10 + *pos-'0';
        } while (*++pos >= '0');
        ++pos;
        return true;
    }

    inline bool eat() {
        if (*pos > ' ') {
            return true;
        }

        do {
            if (*pos == 0 && !rebuffer()) {
                return false;
            }
        } while (*++pos <= ' ');

        return true;
    }

    inline bool eat(char ch) {
        if (*pos == ch) {
            return true;
        }

        do {
            if (*pos == 0 && !rebuffer()) {
                return false;
            }
        } while (*++pos != ch);

        return true;
    }

    class Scanner {
        bool rebuffer() {
            return FastIn::rebuffer();
        }

    public:
        Scanner(FILE *fin=stdin) {
            FastIn::fin = fin;
            endbuf = pos + std::fread(buf, 1, BUF_SIZE, fin);
        }

        template <class T>
        inline bool scan(T &in) {
            return FastIn::scan(in);
        }

        template <class First, class... Rest>
        inline bool scan(First &in, Rest &...ins) {
            return scan(in) && scan(ins...);
        }
    };
}

template<size_t N>
size_t rankF2(vector<bitset<N>>& a, long n, long m){ // calculate rank of matrix in F_2
    size_t now(0), ret(0);
    while(now < m && ret < n){
        size_t i(ret);
        for(; i < n; ++i)if(a[i][now])break;
        if(i == n){
            ++now;
            continue;
        }
        size_t j(i + 1);
        for(; j < n; ++j)if(a[j][now])a[j] ^= a[i];
        swap(a[ret], a[i]);
        ++ret;
    }
    return ret;
}

int main(){
    constexpr long m = 998244353;
    auto modpow = [&m](long n){
        long r = 1, p = 2;
        while(n){
            if(n & 1){
                r *= p;
                r %= m;
            }
            p *= p;
            p %= m;
            n >>= 1;
        }
        return r;
    };
    
    FastIn::Scanner in;

    unsigned long N, M;
    in.scan(N, M);
    bool f = false;
    if(N > M && (f = true))swap(N, M);

    vector<bitset<300>> a(N);
    if(f)for(int i = 0; i < M; ++i)for(int j = 0, k; j < N; ++j){
        in.scan(k);
        a[j][i] = k > 0;
    }
    else for(auto& i : a)for(int j = 0, k; j < M; ++j){
        in.scan(k);
        i[j] = k > 0;
    }

    auto r = rankF2(a, N, M);
    cout << modpow(N + M - r - 1) * (modpow(r) - 1) % m << endl;
}


Measured memory_bytes: 384