stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <queue>

#include <string>

#include <cmath>

#include <sstream>

#include <algorithm>



using namespace std;

vector<vector<int> > senbei;

int H, W;





int main() {

	while (1) {

		cin >> H >> W;

		if (H + W == 0) break;

		senbei.resize(H);

		vector<int> b;

		b.resize(H);

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

			senbei[i].resize(W);

			b[i] = 0;

		}

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

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

				cin >> senbei[i][j];

			}

		}

		int H2 = pow(2, H);

		int max = -1;

		

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

			if (i != 0) {

				for (int j = 0; j < b.size(); j++) {

					if (b[j] == 0) {

						b[j] = 1;

						break;

					}

					else {

						b[j] = 0;

					}

				}

			}

			int count = 0;



			for (int k = 0; k < W; k++) {

				int omote = 0, ura = 0;

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

					if (b[j] == senbei[j][k]) omote++;

				}

				count += omote > H-omote ? omote : H-omote;

			}

			if (max < count) max = count;

		}

		cout << max << endl;

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.204706745773418x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<queue>

#include<map>

#include<string>

#include<sstream>

#include<vector>

#include<cmath>

#include<set>

#include <bitset>

using namespace std;

const int maxn=10015,inf=0x3f3f3f3f;

int r,c,ans;

bitset<maxn> cookie[10];



void dfs(int step){	

	if(step==r){

		int sum=0,csum=0;

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

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

				csum+=cookie[j][i];

			}

			sum=sum+max(csum,r-csum);

			csum=0;

		}

		ans=max(ans,sum);

		return;//attenion return

	}

	cookie[step].flip();

	dfs(step+1);

	cookie[step].flip();

	dfs(step+1);

	

}

int main()

{

	//freopen("read.txt", "r", stdin);

	while(cin>>r>>c&&r&&c){

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

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

				bool val;

				cin>>val;

				cookie[i][j]=val;

			}

		}

		ans=0;

		dfs(0);

		cout<<ans<<endl;

	}

	//fclose(stdin);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.162328370269048x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include<algorithm>

using namespace std;

int m, n, ans = 0, temp;

int a[15][10005];

void dfs(int d)

{

	int up;

	if (d == m)

	{

		temp = 0;

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

		{

			up = 0;

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

				if (a[i][j])

					up++;

			temp += max(up, m - up);

		}

		ans = max(ans, temp);

		return;

	}

	dfs(d + 1);

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

		if (a[d][j])

			a[d][j] = 0;

		else

			a[d][j] = 1;

	dfs(d + 1);

}

int main(void)

{

	while (cin >> m >> n)

	{

		if (!m)

			break;

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

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

				cin >> a[i][j];

		dfs(1);

		cout << ans << endl;

	}

	

}

// Faster C++ solution for the same problem (measured speedup: 5.132977095290787x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include <cstdio>

#include <bitset>

#include <algorithm>

using namespace std;

int R, C, t, ans;

bitset<10005>b[15];



/*首先，翻?行列的次序不影??果，因?行的范??小，可以枚?所有行状?，即把行先翻?完?，

?于??行状?，在?列中??最?解，?行列翻?，即判断0多?是1多,1多?相当于不翻??列，

0多相当于翻??列，因此用bitset容器方便?理。*/

void dfs(int k)

{

    if(k == R)

    {

        int tmp = 0;

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

        {

            int num = 0;

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

                if(b[j][i]) num++;

            tmp += max(num, R-num);

        }

        ans = max(ans, tmp);

        return;

    }

    dfs(k+1);

    b[k].flip();

    dfs(k+1);

    //b[k].flip();

}



int main()

{

    while(~scanf("%d%d",&R,&C),R+C)

    {

        ans = -1;

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

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

            {

                scanf("%d",&t);

                b[i][j] = t;

            }

        dfs(0);

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

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.086157197755241x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
#include<algorithm>

#include<iostream>

#include<cstring>

#include<climits>

#include<cstdio>

using namespace std;

int f[15][10005];

int r,c,ans=0;

void dfs(int row)

{

    if(row==r+1)

    {

        int cont1=0;  

        for(int i=1;i<=c;i++)

        {  

            int cont2=0;

            for(int j=1;j<=r;j++)if(f[j][i]==1)cont2++;  

            cont1+=max(cont2,r-cont2);  

        }  

        ans=max(ans,cont1);  

        return ;

    }

    dfs(row+1);

    for(int i=1;i<=c;i++)

    if(f[row][i])f[row][i]=0;

    else f[row][i]=1;

    dfs(row+1);

}

int main()

{   

    while(1)

    {

        ans=0;

        scanf("%d%d",&r,&c);

        if(r==0&&c==0)break;

        for(int i=1;i<=r;i++)

            for(int j=1;j<=c;j++)

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

        dfs(1);

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

    }

}

// Faster C++ solution for the same problem (measured speedup: 5.057299006789711x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include <algorithm>

#include <queue>

#include <map>

#include <string>

#include <sstream>

#include <set>

#include <bitset>

using namespace std;



int r, c;

bitset<10000> cookie[10];



int main() {

    while (cin >> r >> c && r) {

        for (int i = 0; i < r; ++i)

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

                bool upward;

                cin >> upward;

                cookie[i][j] = upward;

            }

        int ans = 0;

        for (int i = 0; i < (1 << r); ++i) {

            for (int j = 0; j < r; ++j)

                if (i & (1 << j)) cookie[j].flip();

            int possible_ans = 0;

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

                int up_cookie_count = 0;

                for (int k = 0; k < r; ++k)

                    if (cookie[k][j]) up_cookie_count++;

                possible_ans += max(up_cookie_count, r - up_cookie_count);



            }

            ans = max(ans, possible_ans);

            for (int j = 0; j < r; ++j)

                if (i & (1 << j)) cookie[j].flip();

        }

        cout << ans << endl;

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.1686977207961435x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

int n,m;

int a[100][10010];

int maxn=0;

void dfs(int x)

{

	if(x==n+1)

	{

		int t=0;

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

		{

			int s=0;

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

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

			s++;

	    	t+=max(s,n-s);

		}

		maxn=max(maxn,t);

		return ;

	}

	dfs(x+1);

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

	{

		a[x][j]=!a[x][j];

	}

	dfs(x+1);

}

int main()

{

	while(scanf("%d%d",&n,&m)!=EOF&&(n+m))

	{

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

		{

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

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

		}

		dfs(0);

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

	}

	

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.0636581335506445x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

#define d(a) cout << #a << " is " << a << endl

using namespace std;



bool state[10][10000],rflip[10];

int ccol,nr,nc,gmin;

char cc;



int main()

{

    while (scanf("%d%d",&nr,&nc)&&nr+nc) {

        gmin=10000000;

        for(int i=0;i<nr;i++)

        for(int c=0;c<nc;c++) {

            scanf(" %c",&cc);

            state[i][c]=cc-'0';

        }

        for(int btmsk=0;btmsk<1<<nr;btmsk++) {

            //d(btmsk);

            for(int i=0;i<nr;i++) rflip[i]=btmsk>>i&1;

            int ans=0;

            for(int c=0;c<nc;c++) {

                ccol=0;

                for(int i=0;i<nr;i++)

                    ccol+=state[i][c]^rflip[i];

                ans+=min(ccol,nr-ccol);

            }

            //d(ans);

            gmin=min(gmin,ans);

        }

        printf("%d\n",nr*nc-gmin);

    }

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.053572102301877x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
//Problem:

//Date:

//Skill:



#define CLR(a) memset((a),0,sizeof(a))

#define MAX 2140000000;

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

#define RE2(i,n) for(i=1;i<=n;i++)

#include<algorithm>

#include<iostream>

#include<time.h>

#include<string.h>



using namespace std;

bool map[11][10010];

int m, n;

int add(int y)

{

	int ans(0);

	for (int i = 1; i <= m; i++)

	{

		ans += map[i][y];

	}

	//cout << max(ans, m - ans) << endl;

	return max(ans, m - ans);



}

void change(int num)

{

	int i,j;

	RE2(i, m)//第1到m位

	{

		if(num&(1<<(i-1)))

			RE2(j, n)

		{

			map[i][j] = !map[i][j];

		}

	}

}

int search()

{

	int ans(0);

	int i, j, k;

	for (i = 0; i < (1 << m); i++)//遍历每一种情况

	{

		int maxnum(0);

		change(i);



		RE2(j, n)

		{

			maxnum+= add(j);

		}

		ans = max(ans, maxnum);



		change(i);

	}

	return ans;

}



//#define LOCAL

int main()

{

#ifdef LOCAL



	freopen("C:\\Users\\VULCAN\\Desktop\\data.in", "r", stdin);

	//	freopen("C:\\Users\\VULCAN\\Desktop\\data.out", "w", stdout);

#endif

	//这是一条帅气的分界线，写程序从这里开始吧

	int i, j, k;

	

	while (cin >> m >> n,m)

	{

		RE2(i, m)RE2(j, n)

		{

			cin >> map[i][j];//输入

//			cout << map[i][j];

		}

		int ans=search();

		cout << ans << endl;

	}

















	//这是一条可爱的分界线

#ifdef LOCAL

	printf("用时%.3f秒\n", (double)clock() / CLOCKS_PER_SEC);

#endif

	return 0;

}












// Faster C++ solution for the same problem (measured speedup: 5.1385552267414445x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

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

#include<algorithm>

using namespace std;

bool s[15][10005] = { 0 };

int ans = 0, n, m;

void dfs(int x)

{

	if (x == n)

	{

		int sum = 0, temp = 0;

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

		{

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

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

					temp++;

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

			temp = 0;

		}

		ans = max(ans, sum);

		return;

	 }

	dfs(x + 1);

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

		s[x][i] = !s[x][i];

	dfs(x + 1);

}

int main()

{

	while (cin >> n >> m, n, m)

	{

		ans = 0;

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

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

				cin >> s[i][j];

		dfs(0);

		cout << ans << endl;

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.134703042761578x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
#include <algorithm>

#include <cstring>

#include <map>

#include <iostream>



using namespace std;



bool maps[12][10002];

bool row[12];

int ans=0x7fffffff;

int r,c;

int r_c;

map<string,bool>prow;



int dfs(int st)

{

    for(int i=st;i<r;++i)

    {

        if(row[i])continue;

        else

        {

            row[i]=true;

            string str1="0000000000",str2="0000000000";

            for(int j=0;j<r;++j)

            {

                str1[j]=row[j]+'0';

                str2[j]=!row[j]+'0';

            }

            if(prow.count(str1)||prow.count(str2));

            else

            {

                prow[str1]=true;

                prow[str2]=true;

                int sun=0;

                for(int j=0;j<c;++j)

                {

                    int s=0;

                    for(int k=0;k<r;++k)

                        s+=(maps[k][j]^row[k]);

                    sun+=min(s,r-s);

                    if(sun>ans)break;

                }

                ans=min(ans,sun);

            }

            dfs(st+1);

            row[i]=false;

        }

    }

    return 0;

}



int main()

{

    while(scanf("%d%d",&r,&c),r+c)

    {

        r_c=r*c;

        prow.clear();

        memset(maps,0,sizeof(maps));

        memset(row,0,sizeof(row));

        ans=0x7fffffff;

        for(int i=0;i<r;++i)

            for(int j=0;j<c;++j)

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

        dfs(0);

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

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.864583901853072x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
// //bitset操作

// #include <iostream>

// #include <bitset>

// #include <algorithm>

 

// using namespace std;

 

// bitset<5> cookie[10]; 



// int main()

// {

 

//     int R, C;bool upwards;

// 	while(cin >> R >> C && R > 0)

// 	{

// 		int i, j;

// 		for (i = 0; i < R; ++i)

// 		{

// 			for (j = 0; j < C; ++j)

// 			{			

// 				cin >> upwards;

// 				cookie[i][j] = upwards;

// 			}

// 		}

// 		// 在横向一共有2^R种变换

// 		int permute_r = 1 << R;

// 		int result = 0;

// 		for (i = 0; i < permute_r ; ++i)

// 		{	

// 			// 完成当前的变换

// 			for (j = 0; j < R; ++j)

// 			{

// 				//cout<<cookie[j]<<endl;

// 				int temp=1<<j;

// 				cout<<endl;

// 				cout<<i<<" "<<temp<<endl;

// 				int res=i&(1<<j);

// 				cout<<res<<endl;

// 				cout<<endl;

// 				// 这一行是否应当翻个面

// 				if (i & (1 << j))

// 				{

// 					cookie[j].flip();

// 				//	cout<<cookie[j]<<endl;

// 				}

// 			}

// 			// 对每一列分别算出朝上和朝下的煎饼个数，取其最大值

// 			int possible_answer = 0;

// 			for (j = 0; j < C; ++j)

// 			{

// 				int up_cookie_count = 0;

// 				for (int k = 0; k < R; ++k)

// 				{

// 					if (cookie[k][j])

// 					{

// 						++up_cookie_count;

// 					}

// 				}

// 				possible_answer += max(up_cookie_count, R - up_cookie_count);

// 			}

// 			// 结果取最大值

// 			result = max(result, possible_answer);			

// 			for (j = 0; j < R; ++j)

// 			{

// 				if (i & (1 << j))

// 				{

// 					cookie[j].flip();

// 				}

// 			}

// 		}

// 		cout << result << endl;

// 	}

 

//     return 0;

// }

//dfs

#include<iostream>

#include<cstdio>

#include<bitset>



using namespace std;



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

int readint(){int n;scanf("%d",&n);return n;}



bitset<10000>bookie[10];

int r,c,res;



void dfs(int row)

{

	if(row==r){

		int temp=0,temp1;

		rep(i,0,c){

			temp1=0;

			rep(j,0,r){

				if(bookie[j][i]==0){

					temp1++;

				}

			}

			temp+=max(temp1,r-temp1);

		}

		if(res<temp){

			res=temp;                 

		}

		return ;

	}

	rep(i,0,2){

		if(i==0){

			dfs(row+1);

		}

		if(i==1){

			bookie[row].flip();

			dfs(row+1);

			bookie[row].flip();

		}

	}

}



int main()

{

	while(cin>>r>>c){

		if(r==0&&c==0){

			break;

		}else{

			rep(i,0,r){

				rep(j,0,c){

					bookie[i][j]=readint();

				}

			}

			res=0;

			dfs(0);

			cout<<res<<endl;

		}

	}

	return 0;

}






// Faster C++ solution for the same problem (measured speedup: 5.17407570075374x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}
// Slower C++ solution:
//============================================================================

// Name        : Osenbei

// Author      : seaupnice

// Version     :

// Copyright   : Your copyright notice

// Description : Hello World in C++, Ansi-style

//============================================================================



#include<bits/stdc++.h>

using namespace std;



const int MAX_R=10;

const int MAX_C=10000;

bitset<MAX_C> maze[MAX_R];

int R,C;

int ans;

/* dfs()全排列*/

void dfs(int k){

	if(k==C){

		int result=0;

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

			int upnum=0;

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

				if(maze[j][i]){

					upnum++;

				}

			}

			result += max(upnum,C-upnum);

		}

		ans = max(ans, result);

		return;

	}

	dfs(k+1);

	maze[k].flip();

	dfs(k+1);

}



int main(){

	while((cin >> C >> R) && C && R){

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

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

				int a;

				scanf("%d",&a);

				maze[i][j] = (a==1?true:false);

			}

		}

		ans=0;

		dfs(1);

		cout << ans << endl;

	}

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.154189610804097x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MAXM 10000

#define MAXN 10



int n,m,ans;

bool st[MAXN+3][MAXM+3];



void Dfs(int i) {

	if(i>n) {

		int tot=0;

		for(int j=1;j<=m;j++) {

			int sum=0;

			for(int k=1;k<=n;k++)

				sum+=st[k][j];

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

		}

		ans=max(ans,tot);

		return ;

	}

	Dfs(i+1);

	for(int j=1;j<=m;j++)

		st[i][j]=!st[i][j];

	Dfs(i+1);

}

int main() {

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

		ans=0;

		for(int i=1;i<=n;i++)

			for(int j=1;j<=m;j++)

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

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

	}

	return 0;

}