stablegradients/pie-gem5-pairs huggingface dataset:
// 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: 9.943693202254638x):
#include <bits/stdc++.h>

using namespace std;



bitset<10000> maze[10];



int main(){

    ios::sync_with_stdio(false);

    cin.tie(NULL);

    int r, c;

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

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

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

                bool tmp;

                cin >> tmp;

                maze[i][j] = tmp;

            }

        int time = 1 << r;

        int ans = 0;

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

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

                if(i & (1 << j))

                    maze[j].flip();

            int result = 0;

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

                int cntpercol = 0;

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

                    if(maze[R][C])

                        ++cntpercol;

                result += max(cntpercol, r - cntpercol);

            }

            ans = max(ans, result);

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

                if(i & (1 << j))

                    maze[j].flip();

        }

        cout << ans << endl;

    }

    return 0;

}
// 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.08857078347982x):
#include <iostream>

#include <algorithm>

#include <cstdio>

using namespace std;

#define MAX_R 10

#define MAX_C 10000

int R,C;

int res;

int G[MAX_R + 1][MAX_C + 1];

int main(){

    while(cin >> R >> C){

        if(!(R || C)) break;

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

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

                cin >> G[i][j];

        int BIT_SIZE = 1 << R;

        res = 0;

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

            int total = 0;

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

                int k = j;

                int num0 = 0,num1 = 0;

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

                    if(k & 1) G[rr][cc] ? num1++ : num0++;

                    else G[rr][cc] ? num0++ : num1++;

                    k >>= 1;

                }

                total += max(num0,num1);

            }

            res = max(res,total);

        }

        cout << res << endl;

    }

    return 0;

}
// 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: 8.900152366311124x):
#include <cstdio>

#include <iostream>

#include <cstdlib>

#include <cstring>

bool table[12][10005];

using namespace std;

int r,c;

int ans;

int ji(){

    int op=0;

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

        int a=0,b=0;

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

            if(table[i][j]) a++;

            else b++;

        }

        op+=(a>b?a:b);

    }

    return op;

}

void br(int now){

    if(now>r){

        int bi=ji();

        ans=ans>bi?ans:bi;

        return ;

    }

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

}

int main(void){

    while(cin>>r>>c){

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

        memset(table,0,sizeof(table));

        ans=-1000000;

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

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

                cin>>table[i][j];

            }

        br(1);

        cout<<ans<<endl;

    }

    return 0;

}
// 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.120646047517834x):
#include<cstdio>

#include<algorithm>

#include<cstring>

#include<iostream>

#include<bitset>



using namespace std;



const int MAXR = 15, MAXC = 10000+100;

int mapp[MAXR][MAXC];

int r, c;





int main()

{

    while(scanf("%d%d", &r, &c) == 2 && r && c)

    {

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

        {

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

            {

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

            }

        }

        int ans = 0;

        bitset<32> bs;

        for(int i=0; i<r; i++) bs[i] = 1;

        int m = bs.to_ulong();

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

        {

            bs = i;

            int cnt = 0;

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

            {

                int cnt1 = 0, cnt0 = 0;

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

                {

                    if(mapp[k][j] && bs[k]==0) cnt1++;

                    else if(!mapp[k][j] && bs[k]) cnt1++;

                    else cnt0++;

                }

                cnt+= max(cnt1, cnt0);

            }

            ans = max(ans, cnt);

        }

        cout << ans << endl;

    }





    return 0;

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

#include <iostream>

#include <cstdlib>

#include <cstring>

bool table[12][10005];

using namespace std;

int r,c;

int ans;

int ji(){

    int op=0;

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

        int a=0,b=0;

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

            if(table[i][j]) a++;

            else b++;

        }

        op+=(a>b?a:b);

    }

    return op;

}

void br(int now){

    if(now>r){

        int bi=ji();

        ans=ans>bi?ans:bi;

        return ;

    }

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

}

int main(void){

    while(cin>>r>>c){

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

        memset(table,0,sizeof(table));

        ans=-1000000;

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

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

                cin>>table[i][j];

            }

        br(1);

        cout<<ans<<endl;

    }

    return 0;

}

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

#include<algorithm>

#include<cstring>

#include<iostream>

#include<bitset>



using namespace std;



const int MAXR = 15, MAXC = 10000+100;

int mapp[MAXR][MAXC];

int r, c;





int main()

{

    while(scanf("%d%d", &r, &c) == 2 && r && c)

    {

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

        {

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

            {

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

            }

        }

        int ans = 0;

        bitset<32> bs;

        for(int i=0; i<r; i++) bs[i] = 1;

        int m = bs.to_ulong();

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

        {

            bs = i;

            int cnt = 0;

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

            {

                int cnt1 = 0, cnt0 = 0;

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

                {

                    if(mapp[k][j] && bs[k]==0) cnt1++;

                    else if(!mapp[k][j] && bs[k]) cnt1++;

                    else cnt0++;

                }

                cnt+= max(cnt1, cnt0);

            }

            ans = max(ans, cnt);

        }

        cout << ans << endl;

    }





    return 0;

}
// 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.03405725705893x):
 #include <iostream>

 #include <bitset>

 #include <algorithm>

 

 using namespace std;

 

 bitset<10000> cookie[10];

 

 int main() {

    int r;

     int c;

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

         int i, j;

         

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

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

                 bool upwards;

                 cin >> upwards;

                 cookie[i][j] = upwards;

             }

         }

         

         int result = 0;

         int permute = 1 << r;

         for (i = 0; i < permute; i++) {

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

             if (i & 1 << j) {

                 cookie[j].flip();

             }

            }

            

            int possibleResult = 0;

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

             int upCount = 0;

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

                 if (cookie[q][p]) {

                     upCount++;

                 }

             }

             possibleResult += max(upCount, r - upCount);

            }

            result = max(result, possibleResult);   

             

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

                if (i & 1 << j) {

                    cookie[j].flip();

                }

            }                                

        }

        cout << result << endl;

     }   

     return 0;

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

#include <iostream>

#include <cstdlib>

#include <cstring>

bool table[12][10005];

using namespace std;

int r,c;

int ans;

int ji(){

    int op=0;

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

        int a=0,b=0;

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

            if(table[i][j]) a++;

            else b++;

        }

        op+=(a>b?a:b);

    }

    return op;

}

void br(int now){

    if(now>r){

        int bi=ji();

        ans=ans>bi?ans:bi;

        return ;

    }

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

}

int main(void){

    while(cin>>r>>c){

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

        memset(table,0,sizeof(table));

        ans=-1000000;

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

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

                cin>>table[i][j];

            }

        br(1);

        cout<<ans<<endl;

    }

    return 0;

}

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

 #include <bitset>

 #include <algorithm>

 

 using namespace std;

 

 bitset<10000> cookie[10];

 

 int main() {

    int r;

     int c;

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

         int i, j;

         

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

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

                 bool upwards;

                 cin >> upwards;

                 cookie[i][j] = upwards;

             }

         }

         

         int result = 0;

         int permute = 1 << r;

         for (i = 0; i < permute; i++) {

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

             if (i & 1 << j) {

                 cookie[j].flip();

             }

            }

            

            int possibleResult = 0;

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

             int upCount = 0;

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

                 if (cookie[q][p]) {

                     upCount++;

                 }

             }

             possibleResult += max(upCount, r - upCount);

            }

            result = max(result, possibleResult);   

             

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

                if (i & 1 << j) {

                    cookie[j].flip();

                }

            }                                

        }

        cout << result << endl;

     }   

     return 0;

 }
// 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.07051570445277x):
#include<iostream>

#include<cstdio>

#include<cstring>

#include<bitset>

using namespace std;

bitset<10000> cookie[10];

bool now;

int main()

{

	int r,c;

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

	{

		int i,j;

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

		{

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

			{

				cin>>now;

				cookie[i][j]=now;

			}

		}

		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=0;

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

				{

					if(cookie[k][j])

					up_cookie++;

				}

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

			}

			ans=max(ans,possible_ans);

			

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

			{

				if(i & (1<<j))

				{

					cookie[j].flip();

				}

			}

			

		}

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

	}

	return 0;

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

#include <iostream>

#include <cstdlib>

#include <cstring>

bool table[12][10005];

using namespace std;

int r,c;

int ans;

int ji(){

    int op=0;

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

        int a=0,b=0;

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

            if(table[i][j]) a++;

            else b++;

        }

        op+=(a>b?a:b);

    }

    return op;

}

void br(int now){

    if(now>r){

        int bi=ji();

        ans=ans>bi?ans:bi;

        return ;

    }

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

    br(now+1);

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

        if(table[now][i]) table[now][i]=false;

        else table[now][i]=true;

}

int main(void){

    while(cin>>r>>c){

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

        memset(table,0,sizeof(table));

        ans=-1000000;

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

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

                cin>>table[i][j];

            }

        br(1);

        cout<<ans<<endl;

    }

    return 0;

}

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

#include<cstdio>

#include<cstring>

#include<bitset>

using namespace std;

bitset<10000> cookie[10];

bool now;

int main()

{

	int r,c;

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

	{

		int i,j;

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

		{

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

			{

				cin>>now;

				cookie[i][j]=now;

			}

		}

		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=0;

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

				{

					if(cookie[k][j])

					up_cookie++;

				}

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

			}

			ans=max(ans,possible_ans);

			

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

			{

				if(i & (1<<j))

				{

					cookie[j].flip();

				}

			}

			

		}

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

	}

	return 0;

}
// 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.900736431194765x):
//

// Created by Tnecesoc on 2017/4/14.

//



#include <stdio.h>

#include <bitset>



using namespace std;



const int MAX_R = 20;

const int MAX_C = 10000 + 10;



int field[MAX_R][MAX_C];



bitset<MAX_C> toast[MAX_R];



void solve(int fr, int r, int c, int &min) {



    if (fr >= r) {



        int sum = 0;



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

            int row_sum = 0;

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

                if (toast[j][i]) {

                    row_sum++;

                }

            }



            sum += row_sum < r - row_sum ? row_sum : r - row_sum;

        }



        if (min > sum) {

            min = sum;

        }



        return;

    } else {



        solve(fr + 1, r, c, min);



        toast[fr].flip();



        solve(fr + 1, r, c, min);



    }



}



int main() {

    

    int r, c;

    while (~scanf("%d %d", &r, &c), r | c) {

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

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

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

                toast[i].set((size_t) j, (bool) field[i][j]);

            }

        }



        int ans = 0x7fffffff;

        solve(0, r, c, ans);

        printf("%d\n", r * c - ans);

    }



    return 0;

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

using namespace std;



bitset<10000> maze[10];



int main(){

    ios::sync_with_stdio(false);

    cin.tie(NULL);

    int r, c;

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

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

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

                bool tmp;

                cin >> tmp;

                maze[i][j] = tmp;

            }

        int time = 1 << r;

        int ans = 0;

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

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

                if(i & (1 << j))

                    maze[j].flip();

            int result = 0;

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

                int cntpercol = 0;

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

                    if(maze[R][C])

                        ++cntpercol;

                result += max(cntpercol, r - cntpercol);

            }

            ans = max(ans, result);

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

                if(i & (1 << j))

                    maze[j].flip();

        }

        cout << ans << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.0962462547339178x):
//

// Created by Tnecesoc on 2017/4/14.

//



#include <stdio.h>

#include <bitset>



using namespace std;



const int MAX_R = 20;

const int MAX_C = 10000 + 10;



int field[MAX_R][MAX_C];



bitset<MAX_C> toast[MAX_R];



void solve(int fr, int r, int c, int &min) {



    if (fr >= r) {



        int sum = 0;



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

            int row_sum = 0;

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

                if (toast[j][i]) {

                    row_sum++;

                }

            }



            sum += row_sum < r - row_sum ? row_sum : r - row_sum;

        }



        if (min > sum) {

            min = sum;

        }



        return;

    } else {



        solve(fr + 1, r, c, min);



        toast[fr].flip();



        solve(fr + 1, r, c, min);



    }



}



int main() {

    

    int r, c;

    while (~scanf("%d %d", &r, &c), r | c) {

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

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

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

                toast[i].set((size_t) j, (bool) field[i][j]);

            }

        }



        int ans = 0x7fffffff;

        solve(0, r, c, ans);

        printf("%d\n", r * c - ans);

    }



    return 0;

}