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

#include <cstdio>

#include <cstring>

using namespace std;

int n,m,ans;

int a[11][100001];

void dfs(int x)

{

	int i,j;

	if(x>=n)

	return;

	else

	{

		int sum=0;

		for(i=0;i<m;i++)

		{

			int count=0;

			for(j=0;j<n;j++)

			{

			  if(a[j][i]==1)

			  count++;	

			}

			

			sum+=max(count,n-count);

		}

		if(sum>ans)

		ans=sum;

		dfs(x+1);

		for(i=0;i<m;i++)

		{

			if(a[x][i]==1)

			a[x][i]=0;

			else

			a[x][i]=1;

		}

		dfs(x+1);

	   for(i=0;i<m;i++)

		{

			if(a[x][i]==1)

			a[x][i]=0;

			else

			a[x][i]=1;

		}

	}

}

int main()

{

	int i,j;

   while(~scanf("%d%d",&n,&m))

   {

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

   	break;

   	memset(a,0,sizeof(a));

   	ans=0;

   	for(i=0;i<n;i++)

   	{

   		for(j=0;j<m;j++)

   		{

   			scanf("%d",&a[i][j]);

		}

	}

	 dfs(0);

	 printf("%d\n",ans);

   }

  return 0;

}

// Faster C++ solution for the same problem (measured speedup: 10.165803376044368x):
// {{{ 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;

}