// Slower C++ solution:
#include <iostream>

#include <cstdio>

#include <cmath>

#include <iomanip>

#include <vector>

#include <map>

#include <cstring>

#include <algorithm>

using namespace std;



struct Coordinate{

    int row;

    int col;

};

Coordinate mov_dir[4] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}};

bool mat[11][10001], one[11];

int R, C, ans;



void dfs(int row, bool flag)

{

    if (row == 10) {

        return;

    }

    if (flag) {

        for (int j = 0; j < C; j++) {

            mat[row][j] = !mat[row][j];

        }

    }

    for (int i = 0; i < C; i++) {

        int cnt_o = 0, cnt_z = 0;

        for (int j = 0; j < R; j++) {

            if (mat[j][i] == 1) {

                cnt_o++;

            }

            else {

                cnt_z++;

            }

        } 

        if (cnt_z > cnt_o) {

            for (int j = 0; j < R; j++) {

                mat[j][i] = !mat[j][i];

            }

        }

    }

        int cnt = 0;

        for (int i = 0; i < R; i++) {

            for (int j = 0; j < C; j++) {

                if (mat[i][j]) {

                    cnt++;

                }

            }

        }

    if (ans < cnt) {

        ans = cnt;

    }    

    dfs(row + 1, true);

    dfs(row + 1, false);



}

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

    

    while (cin >> R >> C && !(R == 0 && C == 0)) {

        ans = -1;

        for (int i = 0; i < R; i++) {

            int cnt_o = 0, cnt_z = 0;

            for (int j = 0; j < C; j++) {

                cin >> mat[i][j];

            }    

        }

        dfs(0, true);

        dfs(0, false);



        cout << ans << endl;

    }

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 1.273254976185425x):
// {{{ by unolight

#include <bits/stdc++.h>

#include <unistd.h>

#pragma GCC diagnostic ignored "-Wunused-result"

#define SZ(x) ((int)(x).size())

#define ALL(x) begin(x),end(x)

#define RALL(x) rbegin(x),rend(x)

#define REP(i,n) for ( int i=0; i<int(n); i++ )

#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )

#define MP make_pair

#define PB push_back

using namespace std;

typedef int64_t LL;

typedef pair<int,int> PII;

template<class T> using V = vector<T>;

template<class T> using VV = vector<vector<T>>;



template<class T> void _R( T &x ) { cin>>x; }

void _R( int &x ) { scanf("%d",&x); }

void _R( int64_t &x ) { scanf("%" PRId64,&x); }

void _R( double &x ) { scanf("%lf",&x); }

void _R( char &x ) { scanf(" %c",&x); }

void _R( char *x ) { scanf("%s",x); }

void R() {}

template<class T, class... U> void R( T& head, U&... tail ) { _R(head); R(tail...); }



template<class T> void _W( const T &x ) { cout<<x; }

void _W( const int &x ) { printf("%d",x); }

void _W( const int64_t &x ) { printf("%" PRId64,x); }

void _W( const double &x ) { printf("%.16f\n",x); }

void _W( const char &x ) { putchar(x); }

void _W( const char *x ) { printf("%s",x); }

template<class T> void _W( const vector<T> &x ) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }

void W() {}

template<class T, class... U> void W( const T& head, const U&... tail ) { _W(head); putchar(sizeof...(tail)?' ':'\n'); W(tail...); }



template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }

template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }

template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {

    sort(begin(v),end(v),f);

    v.resize(unique(begin(v),end(v))-begin(v));

}



template<class T> using MaxHeap = priority_queue<T>;

template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;



#ifdef UNO

template<class T> void _dump(const char *s, T &&head) { cerr << s << "=" << head << endl; }

template<class T, class... Args> void _dump(const char *s, T &&head, Args &&... tail) {

    for (int c = 0; *s != ',' || c != 0; cerr << *s++) {

        if (*s == '(' || *s == '[' || *s == '{') c++;

        if (*s == ')' || *s == ']' || *s == '}') c--;

    }

    cerr << "=" << head << ", ";

    _dump(s + 1, tail...);

}

#define dump(...) do { fprintf(stderr, "%s:%d - ", __PRETTY_FUNCTION__, __LINE__); _dump(#__VA_ARGS__, __VA_ARGS__); } while (0)



template<class Iter> ostream &_out(ostream &s, Iter b, Iter e) {

    s << "[";

    for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;

    return s << "]";

}



template<class A, class B> ostream &operator<<(ostream &s, const pair<A, B> &p) { return s << "(" << p.first << "," << p.second << ")"; }

template<class T> ostream &operator<<(ostream &s, const vector<T> &c) { return _out(s, ALL(c)); }

template<class T, size_t N> ostream &operator<<(ostream &s, const array<T, N> &c) { return _out(s, ALL(c)); }

template<class T> ostream &operator<<(ostream &s, const set<T> &c) { return _out(s, ALL(c)); }

template<class A, class B> ostream &operator<<(ostream &s, const map<A, B> &c) { return _out(s, ALL(c)); }

#else

#define dump(...)

#endif

// }}}



const int MAX_N=11,MAX_M=10001;

int n,m;

int a[MAX_N][MAX_M];



void flip( int i ) {

    REP(j,m) a[i][j]^=1;

}



void solve() {

    int ans=0;

    REP(mask,1<<n) {

        REP(i,n) if ( mask>>i&1 ) flip(i);

        int res=0;

        REP(j,m) {

            int cnt=0;

            REP(i,n) if ( a[i][j] ) cnt++;

            res+=max(cnt,n-cnt);

        }

        chmax(ans,res);

        REP(i,n) if ( mask>>i&1 ) flip(i);

    }

    W(ans);

}

int main() {

    while ( 1 ) {

        R(n,m);

        if ( n==0&&m==0 ) break;

        REP(i,n) REP(j,m) R(a[i][j]);

        solve();

    }

    return 0;

}