#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdlib>
#include <memory.h>

using namespace std;

const int N = 3000;

typedef unsigned int u32;

int n, m;
u32 a[N][(N+31)/32];
u32 sumCross[N][(N+31)/32];
int sumHor[N];
u32 sumVert[(N+31)/32];

inline void set(u32*const a, int n) {
    a[n/32] |= (1u<<(n&31));
}

void read() {
    scanf("%d%d\n", &n, &m);
    for (int i = 0; i < n; i++) {
        char buf[N*2+10];
        gets(buf);
        for (int j = 0; j < m; j++)
            if(buf[j*2] == '2')
                set((u32*)a[i], j);
    }
}

bool get(u32 *a, int n) {
    return (a[n/32] >> n) & 1;
}

int popcnt(u32 *a, int n) {
    int ans = 0;
    for(int i = 0; i < n / 32; ++i)
        ans += __builtin_popcount(a[i]);
    if(n&31)
        ans += __builtin_popcount(a[n/32]&((1<<(n&31))-1));
    return ans;
}

void xor2(u32 *a, u32 *b, int n) {
    for(int i = 0; i < n / 32; ++i)
        a[i] ^= b[i];
    if(n&31)
        a[n/32] ^= b[n/32]&((1<<(n&31))-1);
}

void xor3(u32 *a, u32 *b, u32 *c, int n) {
    for(int i = 0; i < n / 32; ++i)
        a[i] = b[i] ^ c[i];
    if(n&31)
        a[n/32] = (b[n/32] ^ c[n/32])&((1<<(n&31))-1);
}

void inverse(u32 *a, int n) {
    for(int i = 0; i < n/32; ++i)
        a[i] = ~a[i];
    if(n&31)
        a[n/32] ^= ((1<<(n&31))-1);
}

void findSumCross(int n, int m)  {
    memset(sumHor, 0, sizeof(sumHor));
    memset(sumVert, 0, sizeof(sumVert));
    for (int i = 0; i < n; i++) {
        sumHor[i] = popcnt(a[i], m);
        xor2(sumVert, a[i], m);
    }
    for (int i = 0; i < n; i++) {
        xor3(sumCross[i], a[i], sumVert, m);
        if(sumHor[i]&1)
            inverse(sumCross[i], m);
    }
}
void quit(int x) {
    cout << x << "\n";
    exit(0);
}
int main() {
    read();
    if (n == 1 || m == 1) {
        int kol[2] = {0, 0};
        for (int i = 0; i < n; i++) {
            int x = popcnt(a[i], m);
            kol[0] += m - x;
            kol[1] += x;
        }
        if (kol[0] && kol[1])
            quit(-1);
        else if (kol[0])
            quit(0);
        else
            quit(1);
    }
    if (!(n&1) && !(m&1)) {
        findSumCross(n, m);
        int ans = 0;
        for (int i = 0; i < n; i++)
            ans += popcnt(sumCross[i], m);
        quit(ans);
    }
    if (!(n&1) && (m&1)) {
        findSumCross(n, m-1);
        int kolOdd[n];
        memset(kolOdd, 0, sizeof(kolOdd));
        for (int i = 0; i < n; i++)
            kolOdd[i] += popcnt(sumCross[i], m - 1);
        int kolEq[2] = {0, 0};
        for (int i = 0; i < n; i++)
            kolEq[(kolOdd[i]&1)^get(a[i],m-1)]++;
        if (kolEq[0] && kolEq[1])
            quit(-1);
        vector<int> deltas;
        int ans = 1000000000;
        int ans1 = 0;
        for (int i = 0; i < n; i++)
            if (kolEq[0]) {
                ans1 += kolOdd[i];
                int d = m - 1 - 2*kolOdd[i] + 1;
                deltas.push_back(d);
            } else {
                ans1 += m - 1 - kolOdd[i];
                int d = 1 + 2*kolOdd[i] - m + 1;
                deltas.push_back(d);
            }
        if (kolEq[0])
            ans = min(ans, ans1);
        sort(deltas.begin(), deltas.end());
        for (int i = 0; i < n; i++) {
            ans1 += deltas[i];
            if (kolEq[(i+1)&1])
                ans = min(ans, ans1);
        }
        quit(ans);
    }
    if( (n&1) && !(m&1) ) {
        findSumCross(n-1, m);
        u32 kolOdd[m];
        memset(kolOdd, 0, sizeof(kolOdd));
        for (int i = 0; i+1 < n; i++)
            for (int j = 0; j < m; ++j)
                kolOdd[j] += get(sumCross[i], j);
        int kolEq[2] = {0, 0};
        for (int j = 0; j < m; j++)
            kolEq[(kolOdd[j]&1)^get(a[n-1],j)]++;
        if (kolEq[0] && kolEq[1])
            quit(-1);
        vector<int> deltas;
        int ans = 1000000000;
        int ans1 = 0;
        for (int j = 0; j < m; j++)
            if (kolEq[0]) {
                ans1 += kolOdd[j];
                int d = n - 1 - 2*kolOdd[j] + 1;
                deltas.push_back(d);
            } else {
                ans1 += n - 1 - kolOdd[j];
                int d = 1 + 2*kolOdd[j] - n + 1;
                deltas.push_back(d);
            }
        if (kolEq[0])
            ans = min(ans, ans1);
        sort(deltas.begin(), deltas.end());
        for (int i = 0; i < m; i++) {
            ans1 += deltas[i];
            if (kolEq[(i+1)&1])
                ans = min(ans, ans1);
        }
        quit(ans);
    }
    return 0;
}