Problem:
博士の光電管
博士 :   ピーター君。やったよ。
ピーター : またですか。今度はどんなくだらない発明ですか。
博士 :   あの幻の素粒子アキシオンの検出器を発明したんじゃ。
ピーター : アキシオンといえば、欧州合同原子核研究機構 (CERN) をはじめとする研究者たちが血眼で追っかけているという、あれですよね。本当ですかぁ?
博士 :   本当だってばよ。細かい説明は省くが、非常に強力な磁場を内蔵する特殊な光電管が光ることによって、通過するアキシオンを検出する。
ピーター : 他 に先んじて検出すれば、小柴先生のニュートリノ検出に匹敵するノーベル賞級の研究ですよ。
       これで役立たずの研究ばかりしている「ダメ研究室」などという汚名も返上できますね。
博士 :   そうだとも。小柴先生の「スーパーカミオカンデ」にあやかって、この装置を、(悪口言ったら)「タダジャオカンデ」と命名した。
ピーター : ちょっと苦しいって言うか、卑屈って言うか・・・。
博士 :   それはいいとして、この装置ちょっとした癖があるんじゃよ。
       アキシオン粒子がある光電管を通過すると、感度の関係でその光電管と隣接する上下左右の光電管が反応する。
図1
図2
★
●
●
●
●
●
●
●
★
●
●
●
●
●
●
●
●
●
●
●
●
●
★
●
●
→
○
○
●
○
●
○
●
○
○
○
●
●
●
○
●
●
●
○
●
●
●
○
○
○
●
●
○
○
●
○
○
★
★
○
☆
●
●
○
●
●
○
●
●
○
●
●
○
○
○
●
→
●
●
●
●
●
●
●
●
○
●
●
○
●
●
○
○
●
●
○
●
●
○
○
○
●
ピーター : つまり、図1の左側★印の光電管を粒子が通過した場合、
       右側のように点灯すると言うことですね。
       (図は 5 × 5 の例。黒は消灯・白は点灯状態。以下同じ。)
博士 :   また反応とは、光電管の状態が反転する。つまり消えている光電管は光り、
       光っている光電管は消える。
ピーター : つまり、図2の左側の★印や☆印を粒子が通過した場合、右側のような状態になると。
博士 :   これを正方形になんと 100 個 (10 × 10) 配置して待ち受けるわけだ。
ピーター : これだけの大発明、ノーベル賞選考委員会も「ホッチャオカンデ」なんて。
博士 :   おぉピーター君、君も我が研究室の作風になじんできたようだね。いい感じだ。
       では、早速実験を始めよう。まずはこの装置、現在ランダムに光電管が点いているので、
       実験が始められるように全部消えた状態にリセットしてくれたまえ。
       なあに、どの光電管にアキシオン粒子を当てれば全部消えるか考えればいいだけじゃよ。
       簡単だろう?
ピーター : 考えるのはいいんですが博士。当てるためには、
       幻のアキシオン粒子を発生させて打ち込める装置がないといけないんじゃないですか。
博士 :   ・・・。
博士とピータ      (同時に)コリャアカンデ!だははは・・・・。
ー:
ということで、本日も和気あいあいと暮れてゆく博士の研究室ですが、例によって話は全く進みそうもありません。しょうがないので、ピーター君に代わってプログラムを作成してあげてください。
プログラムは次のようなものになります。
A. 装置の光電管の状態を 10 × 10 の配列として入力します。0は消灯中、1は点灯中を表します。
    0 と 1 以外のデータは含まれません。
B. 入力した装置の状態をすべて消灯にするために、アキシオン粒子を通過させる位置を計算して出力します。これは、入力と同じ 10 × 10の配列で光電管の位置を表します。「0 は通過させない」、「1 は通過させる」ことを表します。すべてを消灯する方法は必ず 1 通りだけ存在するものとします。
Input
複数のデータセットが与えられます。１行目にデータセットの数
n
(
n
≤ 20) が与えられます。各データセットは以下の形式で与えられます。
a
1,1
a
1,2
...
a
1,10
a
2,1
a
2,2
...
a
2,10
:
a
10,1
a
10,2
...
a
10,10
a
i,j
は装置の
i
行目
j
列目の光電管の状態を示す整数 (0 または 1) を表します。
Output
各データセットについて、粒子を通過させる位置を以下の形式で出力してください。
b
1,1
b
1,2
...
b
1,10
b
2,1
b
2,2
...
b
2,10
:
b
10,1
b
10,2
...
b
10,10
b
i,j
は装置の
i
行目
j
列目の光電管に粒子を通過させるかいなかを示す整数 (0 または 1) を表します。
Sample Input
1
0 1 0 0 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 0 1 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 1 0
Output for the Sample Input
0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0

Submitted solutions:

code_snippet: #include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define Inf32 1000000001
#define Inf64 2000000000000000001

void go(vector<vector<int>> &a,int x,int y){
	rep(i,10){
		rep(j,10){
			if(abs(x-i)+abs(y-j)<=1)a[i][j] ^= 1;
		}
	}
}

int main(){
	int n;
	cin>>n;
	rep(_,n){
		
		vector a(10,vector<int>(10));
		rep(i,10){
			rep(j,10){
				cin>>a[i][j];
			}
		}
		
		rep(i,1<<10){
			auto b = a;
			vector ans(10,vector<int>(10,0));
			rep(j,10){
				if((i>>j)&1){
					go(b,0,j);
					ans[0][j] = 1;
				}
			}
			for(int j=1;j<10;j++){
				rep(k,10){
					if(b[j-1][k]){
						go(b,j,k);
						ans[j][k] = 1;
					}
				}
			}
			if(b.back()==vector<int>(10,0)){
				rep(j,10){
					rep(k,10){
						if(k!=0)cout<<' ';
						cout<<ans[j][k];
					}
					cout<<endl;
				}
				break;
			}
		}
		
	}
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3356
final_rank: 18

code_snippet: #pragma region Macros
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define rep(i, n) for(ll i = 0; i < n; ++i)
#define drep(i,n) for(ll i = n-1;i >= 0;i--)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define vll vector<ll>
#define vpi vector<pii>
#define vpll vector<pll>
#define endl '\n'
#define overload2(_1, _2, name, ...) name
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size)\
    vector<type> name(size);\
    IN(name)
#define vv(type, name, h, ...) vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w)\
    vector<vector<type>> name(h, vector<type>(w));\
    IN(name)
#define vvv(type, name, h, w, ...) vector<vector<vector<type>>> name(h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)\
    vector<vector<vector<vector<type>>>> name(a, vector<vector<vector<type>>>(b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))
#define fi first
#define se second
#define all(c) begin(c), end(c)
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
using namespace std;
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
#define si(c) (int)(c).size()
#define INT(...)\
    int __VA_ARGS__;\
    IN(__VA_ARGS__)
#define LL(...)\
    ll __VA_ARGS__;\
    IN(__VA_ARGS__)
#define STR(...)\
    string __VA_ARGS__;\
    IN(__VA_ARGS__)
#define CHR(...)\
    char __VA_ARGS__;\
    IN(__VA_ARGS__)
#define DBL(...)\
    double __VA_ARGS__;\
    IN(__VA_ARGS__)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S> void scan(pair<T, S> &p) { scan(p.first), scan(p.second); }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
    for(auto &i : a) scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &... tail) {
    scan(head);
    IN(tail...);
}
template <class T, class S> inline bool chmax(T &a, S b) {
    if(a < b) {
        a = b;
        return 1;
    }
    return 0;
}
template <class T, class S> inline bool chmin(T &a, S b) {
    if(a > b) {
        a = b;
        return 1;
    }
    return 0;
}
vi iota(int n) {
    vi a(n);
    iota(all(a), 0);
    return a;
}
template <typename T> vi iota(vector<T> &a, bool greater = false) {
    vi res(a.size());
    iota(all(res), 0);
    sort(all(res), [&](int i, int j) {
        if(greater) return a[i] > a[j];
        return a[i] < a[j];
    });
    return res;
}
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
template <class T> T POW(T x, int n) {
    T res = 1;
    for(; n; n >>= 1, x *= x)
        if(n & 1) res *= x;
    return res;
}
vector<pll> factor(ll x) {
    vector<pll> ans;
    for(ll i = 2; i * i <= x; i++)
        if(x % i == 0) {
            ans.push_back({i, 1});
            while((x /= i) % i == 0) ans.back().second++;
        }
    if(x != 1) ans.push_back({x, 1});
    return ans;
}
template <class T> vector<T> divisor(T x) {
    vector<T> ans;
    for(T i = 1; i * i <= x; i++)
        if(x % i == 0) {
            ans.pb(i);
            if(i * i != x) ans.pb(x / i);
        }
    return ans;
}
template <typename T> void zip(vector<T> &x) {
    vector<T> y = x;
    sort(all(y));
    for(int i = 0; i < x.size(); ++i) { x[i] = lb(y, x[i]); }
}
int popcount(ll x) { return __builtin_popcountll(x); }
int in() {
    int x;
    cin >> x;
    return x;
}
ll lin() {
    unsigned long long x;
    cin >> x;
    return x;
}
template <typename T> struct edge {
    int from, to;
    T cost;
    int id;
    edge(int to, T cost) : from(-1), to(to), cost(cost) {}
    edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
    edge(int from, int to, T cost, int id) : from(from), to(to), cost(cost), id(id) {}
    edge &operator=(const int &x) {
        to = x;
        return *this;
    }
    operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
using Tree = vector<vector<int>>;
using Graph = vector<vector<int>>;
template <class T> using Wgraph = vector<vector<edge<T>>>;
Graph getG(int n, int m = -1, bool directed = false, int margin = 1) {
    Tree res(n);
    if(m == -1) m = n - 1;
    while(m--) {
        int a, b;
        cin >> a >> b;
        a -= margin, b -= margin;
        res[a].emplace_back(b);
        if(!directed) res[b].emplace_back(a);
    }
    return move(res);
}
template <class T> Wgraph<T> getWg(int n, int m = -1, bool directed = false, int margin = 1) {
    Wgraph<T> res(n);
    if(m == -1) m = n - 1;
    while(m--) {
        int a, b;
        T c;
        cin >> a >> b >> c;
        a -= margin, b -= margin;
        res[a].emplace_back(b, c);
        if(!directed) res[b].emplace_back(a, c);
    }
    return move(res);
}
#define i128 __int128_t
#define ull unsigned long long int
template <typename T> static constexpr T inf = numeric_limits<T>::max() / 2;
struct Setup_io {
    Setup_io() {
        ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
        cout << fixed << setprecision(15);
    }
} setup_io;
template <typename A, typename B>
ostream& operator <<(ostream& out, const pair<A, B>& a) {
out << "(" << a.first << "," << a.second << ")";
return out;
}
template <typename T, size_t N>
ostream& operator <<(ostream& out, const array<T, N>& a) {
out << "["; bool first = true;
for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
return out;
}
template <typename T>
ostream& operator <<(ostream& out, const vector<T>& a) {
out << "["; bool first = true;
for (auto& v : a) { out << (first ? "" : ", "); out << v; first = 0;} out << "]";
return out;
}
template <typename T, class Cmp>
ostream& operator <<(ostream& out, const set<T, Cmp>& a) {
out << "{"; bool first = true;
for (auto& v : a) { out << (first ? "" :", "); out << v; first = 0;} out << "}";
return out;
}
template <typename U, typename T, class Cmp>
ostream& operator <<(ostream& out, const map<U, T, Cmp>& a) {
out << "{"; bool first = true;
for (auto& p : a) { out << (first ? "" : ", "); out << p.first << ":" << p.second; first = 0;} out << "}";
return out;
}
#define LOCAL
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
#pragma endregion
//#include<atcoder/all>
//using namespace atcoder;
bool all_zero(vector<vector<int>> &f){
    rep(i,10)rep(j,10){
        if(f[i][j])return false;
    }
    return true;
}
vector<pii> vec = {{0,-1},{-1,0},{1,0},{0,1}};
bool valid(int x,int y){return x >= 0 && y >= 0 && x < 10 && y < 10;}
int main(){
    INT(n);
    while(n--){
        VV(int,f,10,10);
        rep(mask,1<<10){
            vv(int,ret,10,10);
            vector<vector<int>> tmp = f;
            rep(i,10){
                if(mask>>i&1){
                    ret[0][i] = 1;
                    tmp[0][i] ^=1;
                    for(auto [dx,dy]:vec){
                        int nx = 0+dx,ny = i+dy;
                        if(!valid(nx,ny))continue;
                        tmp[nx][ny] ^= 1;
                    }
                }
            }
            rep(i,10)rep(j,10){
                if(i == 0)continue;
                if(tmp[i-1][j] == 0)continue;
                //oku
                ret[i][j] = 1;
                tmp[i][j] ^=1;
                for(auto [dx,dy]:vec){
                    int nx = i+dx,ny = j+dy;
                    if(!valid(nx,ny))continue;
                    tmp[nx][ny] ^= 1;
                }
            }
            //check
            if(all_zero(tmp)){
                rep(i,10){
                    rep(j,10){
                        if(j)cout << " ";
                        cout << ret[i][j];
                    }
                    cout << endl;
                }
            }
        }
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3152
final_rank: 17

code_snippet: #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>

using namespace std;

#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)

#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
typedef vector<vi> vvi;

int gcd(int a, int b){
    if(b==0) return a;
    return gcd(b,a%b);
}
int lcm(int a, int b){
    return a/gcd(a,b)*b;
}
int n = 10;
bool in(int a, int b){
    if(a < 0 || a >= n || b < 0 || b >= n)return false;
    return true;
}
int dx[] = {0,0,1,0,-1};
int dy[] = {0,1,0,-1,0};

signed main(void) {
    int num;
    cin >> num;
    while(num--){
        vvi a(n,vi(n));
        rep(i,n)rep(j,n)cin >> a[i][j];
        rep(bit, 1<<n){
            vvi t = a;
            vvi ans(n,vi(n,0));
            rep(i,n)if(bit&(1<<i)){
                ans[0][i]++;
                rep(j,5){
                    int x = 0 + dx[j];
                    int y = i + dy[j];
                    if(in(x,y))t[x][y] ^= 1;
                }
            }
            rep(i,n-1)rep(j,n)if(t[i][j]){
                ans[i+1][j]++;
                rep(k,5){
                    int x = i+1 + dx[k];
                    int y = j + dy[k];
                    if(in(x,y))t[x][y] ^= 1;
                }
            }
            bool c = true;
            rep(j,n)if(t[n-1][j])c = false;
            if(c){
                rep(i,n)rep(j,n)cout << ans[i][j] << " \n"[j == n-1];
            }
        }
        vvi ans(n,vi(n,0));
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3104
final_rank: 15

code_snippet: #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES

#include <stdio.h>
#include <ctype.h>
#include <string>
#include <iostream>
#include <vector>
#include <stack>
#include <fstream>
#include <sstream>
#include <queue>
#include <exception>
#include <cmath>
#include <numeric>
#include <map>
#include <algorithm>
#include <bitset>
#include <set>
#include <functional>

#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)

using namespace std;
typedef long long int lint;
typedef vector<vector<int> > matrix;

int dy[5] = { -1, 0, 0, 0, 1 };
int dx[5] = { 0, -1, 0, 1, 0 };

void print(matrix& mat) {
	REP(y, 10) {
		REP(x, 10) {
			if (x) cout << " ";
			cout << mat[y][x];
		}
		cout << endl;
	}
}

matrix mk_matrix(int n) {
	matrix mat(n);
	REP(i, n) {
		mat[i] = vector<int>(10, 0);
	}
	return mat;
}

void push(matrix& mat, int y, int x) {
	REP(i, 5) {
		int nx = x + dx[i];
		if (nx < 0 || nx >= 10) continue;
		int ny = y + dy[i];
		if (ny < 0 || ny >= 10) continue;
		mat[ny][nx] ^= 1;
	}
}

void solve(matrix& mat) {
	//?????????????????¨????????????????????????
	REP(i, 1024) {
		matrix mat_tmp = mat;
		matrix pushed = mk_matrix(10);
		int tmp = i;
		REP(j, 10) {
			if (!tmp) break;
			if (tmp & 1) {
				push(mat_tmp, 0, j);
				pushed[0][j] = 1;
				//print(mat_tmp);
			}
			tmp >>= 1;
		}

		FOR(y, 1, 10) {
			REP(x, 10) {
				if (mat_tmp[y - 1][x]) {
					push(mat_tmp, y, x);
					pushed[y][x] = 1;
					//print(mat_tmp);
				}
			}
		}
		//cout << i << endl;
		//print(mat_tmp);
		if (find(mat_tmp[9].begin(), mat_tmp[9].end(), 1) == mat_tmp[9].end()) {
			print(pushed);
			//cout << "solved." << endl;
			return;
		}
	}
}

bool AOJ0131()
{
	matrix mat = mk_matrix(10);
	REP(i, 10) {
		REP(j, 10) {
			cin >> mat[i][j];
		}
	}

	solve(mat);

	return true;
}

int main()
{
	int n;
	cin >> n;
	REP(i, n) AOJ0131();

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3128
final_rank: 16

code_snippet: #include "bits/stdc++.h"
using namespace std;
int a[10][10],b[10][10],ans[10][10];
int dx[]={1,0,-1,0,0},dy[]={0,1,0,-1,0};

void init(void){for(int i=0;i<10;i++){for(int j=0;j<10;j++){b[i][j]=a[i][j];ans[i][j]=0;}}}

void rev(int x, int y){for(int k=0;k<5;k++){int ny=y+dy[k],nx=x+dx[k];
    if( 0<=ny && 0<=nx && ny<10 && nx<10)b[ny][nx]=!b[ny][nx];}}

int ok(void){for(int i=0;i<10;i++)for(int j=0;j<10;j++)if(b[i][j])return 0;return 1;}

void solve(int p[]){
  init();for(int i=0;i<10;i++){if(p[i])rev(i,0);ans[0][i]=p[i];}
  for(int i=1;i<10;i++){for(int j=0;j<10;j++){if(b[i-1][j]){rev(j,i);ans[i][j]=1;}}}
  if(ok()){for(int i=0;i<10;i++){for(int j=0;j<10;j++){	cout << ans[i][j];if(j<9)cout << " ";}cout << endl;}}}

void func(int p[], int cnt){if(9<cnt)solve(p);else {p[cnt]=0;func(p,cnt+1);p[cnt]=1;func(p,cnt+1);}}

int main(void){
  int n;cin >> n;
  while(n--){for(int i=0;i<10;i++)for(int j=0;j<10;j++)cin >> a[i][j];
    int p[10]={0};func(p,0);
  }return 0;}
accuracy: 1
time_ms: 10
memory_kb: 3016
final_rank: 13

code_snippet: #include "bits/stdc++.h"
using namespace std;


const int mod = 2;
struct Mod {
public:
	int num;
	Mod() : Mod(0) { ; }
	Mod(long long int n) : num((n % mod + mod) % mod) {
		static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
	}
	Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
	operator int() { return num; }
};

Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator+(const Mod a, const long long int  b) { return b + a; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
	if (n == 0) return Mod(1);
	Mod res = (a * a) ^ (n / 2);
	if (n % 2) res = res * a;
	return res;
}
Mod mod_pow(const Mod a, const long long  int n) {
	if (n == 0) return Mod(1);
	Mod res = mod_pow((a * a), (n / 2));
	if (n % 2) res = res * a;
	return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
	assert(b.num != 0);
	return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
	return Mod(a) / b;
}
Mod operator/=(Mod &a, const Mod b) {
	return a = a / b;
}

#define MAX_MOD_N 1024000

Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
void init(const int amax = MAX_MOD_N) {
	fact[0] = Mod(1); factinv[0] = 1;
	for (int i = 0; i < amax - 1; ++i) {
		fact[i + 1] = fact[i] * Mod(i + 1);
		factinv[i + 1] = factinv[i] / Mod(i + 1);
	}
}
Mod comb(const int a, const int b) {
	return fact[a] * factinv[b] * factinv[a - b];
}

/* verified AOJ1327 One-Dimensional Cellular Automaton
~Matrix~
??????????°????????¨?????????§??????
vector iostream cmath cassert ??????
Matrix a(VV), b(VV);
?????????:a*b
????????????:l*a
???:a+b
???:a-b
??¢???:a.transport()
?????????:a.cofactor()
?????????:a.det()
a???i???j??????:a.get(i,j)???
a???i??????j?????????k?????£??\:set(i,j,k)
????????????a[i][j] (a[i][j]=k)
a???x???:a.pow(x)
n*n?????¬??????E:Matrix(n)
m*n 0??????:Matrix(m,n)
m*n ??¨????´????p?????????:Matrix(m,n,p)
Row???row??§????????????(m*1??????):Matrix(row)
**(??´??°??????)**
????§????:a.triangulate()
?????????:a.rank()
?????????:a.inverse()
//(????????????a.det()?????????a.pre_inverse()??§?±??????? ??´??°???)
??¬??????????¶???????:a.rowReduction()
//??£???????¬?????¨????????§£??????
***
*/

#include <vector>
#include <iostream>
#include <cmath>
#include <cassert>
using namespace std;

typedef Mod Elem;
typedef vector<Elem> Row;
typedef vector<Row> VV;

typedef long double ld;
const ld EPS = 1e-11;

const bool isZero(const Elem e) {
	return e.num == 0;
}

struct Matrix {
	VV matrix;
	int n, m;

	Matrix(const VV &matrix_);
	explicit Matrix(int n_);
	explicit Matrix(const Row &row);
	Matrix(int m_, int n_);
	Matrix(int m_, int n_, Elem e);

	const Elem get(const int i, const int j) const;
	void set(const int x, const int y, const Elem k);

	const Matrix operator + (const Matrix &rhs) const;
	const Matrix operator * (const Matrix &rhs) const;
	const Matrix operator - (const Matrix &rhs) const;
	Matrix &operator += (const Matrix &rhs);
	Matrix &operator *= (const Matrix &rhs);
	Matrix &operator -= (const Matrix &rhs);

	Row &operator[](const int x);

	const Matrix transport() const;
	const Matrix pow(int x) const;
	const Matrix cofactor(int x, int y) const;
	const Elem det() const;

	const Matrix triangulate() const;
	const int rank() const;

	//?????????????????¨????????°???(?????????)*(?????????)?????????
	//A:matrix,return det A * A^-1
	const Matrix pre_inverse() const;
	const Matrix inverse() const;
	const Matrix rowReduction() const;
};

const Matrix operator * (const Elem lambda, const Matrix &rhs) {
	Matrix tmp(rhs);
	for (int i = 0; i < rhs.m; i++)
		for (int j = 0; j < rhs.n; j++)
			tmp.set(i, j, tmp.get(i, j) * lambda);
	return tmp;
}

Matrix::Matrix(const VV &matrix_) : matrix(matrix_) {
	m = matrix_.size();
	if (m == 0) n = 0;
	else n = matrix_[0].size();
}
Matrix::Matrix(int n_) : m(n_), n(n_) {
	matrix = VV(n, Row(n, 0));
	for (int i = 0; i < n; ++i)
		set(i, i, 1);
}
Matrix::Matrix(const Row &row) : m(1), n(row.size()), matrix(VV(1, row)) {
	//size???m???vector<Elem>??????mx1???????????????
	(*this) = transport();
}
Matrix::Matrix(int m_, int n_) : m(m_), n(n_) {
	matrix = VV(m, Row(n, 0));
}
Matrix::Matrix(int m_, int n_, Elem e) : m(m_), n(n_) {
	matrix = VV(m, Row(n, e));
}

const Elem Matrix::get(const int i, const int j) const {
	if (0 <= i && i < m && 0 <= j && j < n)
		return matrix[i][j];

	cerr << "get(" << i << "," << j << ")is not exist." << endl;
	throw;
}
void Matrix::set(const int i, const int j, const Elem k) {
	if (0 <= i && i < m && 0 <= j && j < n) {
		*(matrix[i].begin() + j) = k;
		return;
	}
	cerr << "set(" << i << "," << j << ")is not exist." << endl;
	throw;
}

const Matrix Matrix::operator + (const Matrix &rhs) const {
	assert(m == rhs.m && n == rhs.n);

	Matrix tmp(m, n, 0);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			tmp.set(i, j, get(i, j) + rhs.get(i, j));
		}
	}
	return tmp;
}

const Matrix Matrix::operator * (const Matrix &rhs) const {
	assert(n == rhs.m);

	Matrix tmp(m, rhs.n, 0);
	Elem sum;
	for (int i = 0; i < m; i++)
		for (int j = 0; j < rhs.n; j++) {
			sum = 0;
			for (int k = 0; k < n; k++) {
				sum += get(i, k) * rhs.get(k, j);
			}
			tmp.set(i, j, sum);
		}
	return tmp;
}

const Matrix Matrix::operator - (const Matrix &rhs) const {
	return *this + ((Elem)-1 * rhs);
}

Matrix &Matrix::operator += (const Matrix &rhs) {
	return *this = *this + rhs;
}

Matrix &Matrix::operator *= (const Matrix &rhs) {
	return *this = *this * rhs;;
}

Matrix &Matrix::operator -= (const Matrix &rhs) {
	return *this = *this - rhs;
}

Row &Matrix::operator[](const int x) {
	return matrix[x];
}

const Matrix Matrix::transport() const {
	VV tmp;
	for (int i = 0; i < n; i++) {
		Row row;
		for (int j = 0; j < m; j++)
			row.push_back(get(j, i));
		tmp.push_back(row);
	}
	return tmp;
}

const Matrix Matrix::pow(int x) const {
	Matrix tmp(*this), e(m);
	for (int i = 1; i <= x; i <<= 1) {
		if ((x & i) > 0)
			e = e * tmp;
		tmp = tmp * tmp;
	}
	return e;
}

const Matrix Matrix::cofactor(int x, int y) const {
	VV tmp;
	for (int i = 0; i < m; i++) {
		if (x == i) continue;
		Row row;
		for (int j = 0; j < n; j++) {
			if (y == j) continue;
			row.push_back(get(i, j));
		}
		tmp.push_back(row);
	}
	return Matrix(tmp);
}

const Elem Matrix::det() const {
	assert(n == m);

	if (m == 1)
		return get(0, 0);
	Elem sum = 0;
	for (int i = 0; i < m; i++) {
		sum += ((i % 2 == 0 ? 1 : -1) * get(i, 0)) * Matrix(cofactor(i, 0)).det();
	}
	return sum;
}

const Matrix Matrix::triangulate() const {
	Matrix tmp(*this);
	Elem e;
	int p = 0;
	for (int i = 0; i < m && p < n; i++, p++) {
		if (isZero(tmp.get(i, p))) {
			tmp.set(i, p, 0);
			bool flag = true;
			for (int j = i + 1; j < m; j++)
				if (!isZero(tmp.get(j, p))) {
					for (int k = 0; k < n; k++)
						tmp.set(i, k, tmp.get(i, k) + tmp.get(j, k));
					//tmp[i].swap(tmp[j]);
					flag = false;
					break;
				}
			if (flag) {
				i--;
				continue;
			}
		}
		for (int j = i + 1; j < m; j++) {
			e = tmp.get(j, p) / tmp.get(i, p);
			for (int k = 0; k < n; k++)
				tmp.set(j, k, tmp.get(j, k) - tmp.get(i, k) * e);
		}
	}
	return tmp;
}

const int Matrix::rank() const {
	Matrix tmp(triangulate());
	for (int i = min(tmp.m - 1, tmp.n - 1); i >= 0; i--) {
		for (int j = tmp.n - 1; j >= i; j--)
			if (isZero(tmp.get(i, j)))
				continue;
			else
				return i + 1;
	}
	return 0;
}

const Matrix Matrix::pre_inverse() const {
	assert(m == n);

	Matrix tmp(m, n, 0);
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			tmp.set(i, j, ((i + j) % 2 == 0 ? 1 : -1)*cofactor(i, j).det());
	return tmp.transport();
}

/*O(n!)????£?
const Matrix Matrix::inverse() const {
Matrix tmp(pre_inverse());
Elem e = det();
assert(!isZero(e));
tmp = 1 / e * tmp;
return tmp.transport();
}*/

const Matrix Matrix::inverse() const {
	assert(m == n);

	Matrix tmp(m, n * 2), tmp2(m, n);
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			tmp.set(i, j, get(i, j));
	for (int i = 0; i < m; i++)
		tmp.set(i, i + n, 1);

	tmp = tmp.rowReduction();

	//?????????????????¨??????????????????????????§??????
	for (int i = 0; i < m; i++)
		assert(isZero(tmp.get(i, i) - 1));

	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			tmp2.set(i, j, tmp.get(i, j + n));

	return tmp2;
}

/*
a b c j
d e f k
g h i l

ax+by+cz=j;
dx+ey+fz=k;
gx+hy+iz=l;

|
V

1 0 0 x
0 1 0 y
0 0 1 z
???????????????
*/
const Matrix Matrix::rowReduction() const {
	Matrix tmp(*this);
	Elem e;
	int p = 0;
	for (int i = 0; i < m && p < n; i++, p++) {
		if (isZero(tmp.get(i, p))) {
			tmp.set(i, p, 0);
			bool flag = true;
			for (int j = i + 1; j < m; j++)
				if (!isZero(tmp.get(j, p))) {
					for (int k = 0; k < n; k++)
						tmp.set(i, k, tmp.get(i, k) + tmp.get(j, k));
					//tmp[i].swap(tmp[j]);
					flag = false;
					break;
				}
			if (flag) {
				i--;
				continue;
			}
		}
		e = 1 / tmp.get(i, p);
		tmp.set(i, p, 1);
		for (int k = i + 1; k < n; k++)
			tmp.set(i, k, tmp.get(i, k)*e);
		for (int j = 0; j < m; j++) {
			if (i == j) continue;
			e = tmp.get(j, p);
			for (int k = 0; k < n; k++)
				tmp.set(j, k, tmp.get(j, k) - tmp.get(i, k) * e);
		}
	}
	return tmp;
}

const int dx[] = { 0,-1,0,1,0 };
const int dy[] = {0, 0,1,0,-1 };
int main() {
	int N; cin >> N;
	while (N--) {
		Matrix mat(100, 101);
		for (int y = 0; y < 10; ++y) {
			for (int x = 0; x < 10; ++x) {
				int num = y * 10 + x;
				int a; cin >> a;
				for (int k = 0; k < 5; ++k) {
					int nextx = x + dx[k];
					int nexty = y + dy[k];
					if (nextx>=0&&nextx<10&&nexty>=0&&nexty<10) {
						int nextnum = nexty * 10 + nextx;
						mat[num][nextnum] = 1;
					}
				}
				mat[num][100] = a;
			}
		}
		Matrix ans = mat.rowReduction();
		for (int i = 0; i < 10; ++i) {
			for (int j = 0; j < 10; ++j) {
				if (ans[i * 10 + j][100]) {
					cout << 1;
				}
				else {
					cout << 0;
				}
				if (j == 9)cout << endl;
				else cout << " ";
			}
		}
	}
	return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 11096
final_rank: 20

code_snippet: #include<iostream>
using namespace std;
int x[12][12];
int T[12][12], V[12][12];
void compute(int X, int Y) {
	int dx[5] = { -1,0,0,0,1 }, dy[5] = { 0,-1,0,1,0 };
	for (int i = 0; i < 5; i++) { T[X + dx[i]][Y + dy[i]]++; T[X + dx[i]][Y + dy[i]] %= 2; }
}
int main() {
	int n; cin >> n;
	for (int h = 0; h < n; h++) {
		for (int i = 1; i <= 10; i++) {
			for (int j = 1; j <= 10; j++)cin >> x[i][j];
		}

		for (int i = 0; i < (1 << 10); i++) {
			int bit[11]; for (int j = 0; j < 10; j++)bit[j + 1] = (i / (1 << j)) % 2;
			for (int j = 0; j < 12; j++) {
				for (int k = 0; k < 12; k++) { T[j][k] = 0; V[j][k] = 0; }
			}

			for (int j = 1; j <= 10; j++) {
				if (bit[j] == 1) {
					compute(1, j);
					V[1][j] = 1;
				}
			}
			for (int j = 2; j <= 10; j++) {
				for (int k = 1; k <= 10; k++) {
					if (T[j - 1][k] != x[j - 1][k]) {
						compute(j, k);
						V[j][k] = 1;
					}
				}
			}
			bool OK = true; for (int k = 1; k <= 10; k++) { if (T[10][k] != x[10][k])OK = false; }
			if (OK == true) {
				for (int j = 1; j <= 10; j++) {
					for (int k = 1; k <= 10; k++) {
						if (k >= 2)cout << ' '; cout << V[j][k];
					}
					cout << endl;
				}
			}
		}
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

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

void turn(int x, int y, int data[10][10]) {
	int dx[5] = {0,1,0,-1,0};
	int dy[5] = {0,0,1,0,-1};
	
	REP(i, 5) {
		int nx = x + dx[i], ny = y + dy[i];
		if (!(nx >= 0 && nx < 10 && ny >= 0 && ny < 10)) continue;
		data[ny][nx]++;
	}
}

bool check(int data[10][10]) {
	bool res = true;
	
	REP(i, 10) if (data[9][i] & 1) res = false;
	
	return res;
}

int main() {
	int n;
	cin >> n;
	while (n--) {
		int in[10][10];
		REP(i, 10) REP(j, 10) scanf("%d", &in[i][j]);
		
		bool ans[10][10];
		int data[10][10];
		
		REP(i, 1<<10) {
			memset(ans, 0, sizeof(ans));
			memcpy(data, in, sizeof(in));
			
			REP(j, 10) if ((i >> j) & 1) {
				ans[0][j] = true;
				turn(j, 0, data);
			}
			FOR(j, 1, 10) REP(k, 10) {	
				if (data[j - 1][k] & 1) {
					ans[j][k] = true;
					turn(k, j, data);
				}
			}
			
			if (check(data)) break;
		}
		
		REP(j, 10) REP(k, 10)
			printf("%d%c", ans[j][k] ? 1 : 0, k == 9 ? '\n' : ' ');
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1228
final_rank: 11

code_snippet: #include <bits/stdc++.h>
 
using namespace std;
 
const int dx[5] = {-1, 0, 0, 0, 1};
const int dy[5] = {0, -1, 0, 1, 0};
 
int arr[10][10];
int ans[10][10], flip[10][10];
 
int get(int x, int y)
{
    int c = arr[x][y];
    for (int d = 0; d < 5; d++) {
	int x2 = x + dx[d], y2 = y + dy[d];
	if (0 <= x2 && x2 < 10 && 0 <= y2 && y2 < 10) {
	    c += flip[x2][y2];
	}
    }
    return c % 2;
}
 
int calc()
{
    for (int i = 1; i < 10; i++) {
	for(int j = 0; j < 10; j++) {
	    if (get(i-1, j) != 0) {
		flip[i][j] = 1;
	    }
	}
    }
 
    for (int j = 0; j < 10; j++) {
	if (get(9, j) != 0) {
	    return -1;
	}
    }
 
    int res = 0;
    for (int i = 0; i < 10; i++) {
	for (int j = 0; j < 10; j++) {
	    res += flip[i][j];
	}
    }
    return res;
}
 
void solve()
{
    int res = -1;
 
    for (int i = 0; i < (1<<10); i++) { 
	memset(flip, 0, sizeof(flip));
	for (int j = 0; j < 10; j++) {
	    flip[0][10-j-1] = i >> j & 1;
	}
	int num = calc();
	if (num >= 0 && (res < 0 || res > num)) {
	    res = num;
	    memcpy(ans, flip, sizeof(ans));   
	}
    }
 
    for (int i = 0; i < 10; i++) {
	for (int j = 0; j < 10; j++) {
	    printf("%d%c", ans[i][j], j+1 == 10 ? '\n' : ' ');
	}
    }
}
 
int main()
{
    int Tc;
    cin >> Tc;
    while (Tc--) {
	for (int i = 0; i < 10; i++) {
	    for (int j = 0; j < 10; j++) {
		cin >> arr[i][j];
	    }
	}
	solve();
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3060
final_rank: 14

code_snippet: #include <bits/stdc++.h>
using namespace std;
int mp[10][10],b[10][10];

void mark(int y,int x){
  int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
  for(int i=0;i<4;i++) {
    int nx=x+dx[i],ny=y+dy[i];
    if(nx<0||ny<0||nx>=10||ny>=10)continue;
    mp[ny][nx]=!mp[ny][nx];
  }
  mp[y][x]=!mp[y][x];
}

bool check(){
  for(int i=0;i<10;i++)
    for(int j=0;j<10;j++)if(mp[i][j])return 0;
  return 1;
}

void copy(int a[10][10],int b[10][10]){
  for(int i=0;i<10;i++)for(int j=0;j<10;j++)a[i][j]=b[i][j];
}

int main(){
  int q;
  cin>>q;
  while(q--){
    for(int i=0;i<10;i++)for(int j=0;j<10;j++)cin>>mp[i][j];
    copy(b,mp);
    int ans[10][10]={};
    for(int i=0;!check();i++){
      copy(mp,b),copy(b,mp);
      for(int j=0;j<10;j++)if((ans[0][j]=(i>>j)%2))mark(0,j);
      
      for(int j=1;j<10;j++)
	for(int k=0;k<10;k++)
	  if((ans[j][k]=mp[j-1][k]))mark(j,k);
    }

    for(int i=0;i<10;i++){
      for(int j=0;j<10;j++){
	if(j) cout <<" ";
	cout << ans[i][j];
      }
      cout <<endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;


void mark(int mp[10][10],int y,int x){
  int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
  for(int i=0;i<4;i++) {
    int nx=x+dx[i],ny=y+dy[i];
    if(nx<0||ny<0||nx>=10||ny>=10)continue;
    mp[ny][nx]=!mp[ny][nx];
  }
  mp[y][x]=!mp[y][x];
}

bool check(int mp[10][10]){
  for(int i=0;i<10;i++)
    for(int j=0;j<10;j++)if(mp[i][j])return 0;
  return 1;
}

void copy(int a[10][10],int b[10][10]){
  for(int i=0;i<10;i++)for(int j=0;j<10;j++)a[i][j]=b[i][j];
}

int main(){
  int q;
  cin>>q;
  while(q--){
    int mp[10][10],b[10][10];
    for(int i=0;i<10;i++)for(int j=0;j<10;j++)cin>>mp[i][j];

    copy(b,mp);
    int ans[10][10]={};
    for(int i=0;!check(mp);i++){
      copy(mp,b),copy(b,mp);
      for(int j=0;j<10;j++)if((ans[0][j]=((i>>j)%2)))mark(mp,0,j);
      for(int j=1;j<10;j++)
	for(int k=0;k<10;k++)
	  if((ans[j][k]=mp[j-1][k]))mark(mp,j,k);
    }

    for(int i=0;i<10;i++){
      for(int j=0;j<10;j++){
	if(j) cout <<" ";
	cout << ans[i][j];
      }
      cout <<endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;


void mark(int mp[10][10],int y,int x){
  int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
  for(int i=0;i<4;i++) {
    int nx=x+dx[i],ny=y+dy[i];
    if(nx<0||ny<0||nx>=10||ny>=10)continue;
    mp[ny][nx]=!mp[ny][nx];
  }
  mp[y][x]=!mp[y][x];
}

bool check(int mp[10][10]){
  for(int i=0;i<10;i++)
    for(int j=0;j<10;j++)if(mp[i][j])return 0;
  return 1;
}

int main(){
  int q;
  cin>>q;
  while(q--){
    int mp[10][10],b[10][10];
    for(int i=0;i<10;i++)for(int j=0;j<10;j++)cin>>mp[i][j],b[i][j]=mp[i][j];

    int ans[10][10]={};
    for(int i=0;!check(mp);i++){
      for(int j=0;j<10;j++)for(int k=0;k<10;k++) mp[j][k]=b[j][k];
      for(int j=0;j<10;j++)for(int k=0;k<10;k++) b[j][k]=mp[j][k];

      for(int j=0;j<10;j++)if((ans[0][j]=((i>>j)%2)))mark(mp,0,j);
      for(int j=1;j<10;j++)
	for(int k=0;k<10;k++)
	  if((ans[j][k]=mp[j-1][k]))mark(mp,j,k);
    }

    for(int i=0;i<10;i++){
      for(int j=0;j<10;j++){
	if(j) cout <<" ";
	cout << ans[i][j];
	assert(ans[i][j]==0||ans[i][j]==1);
      }
      cout <<endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <bits/stdc++.h>

using namespace std;

int main()
{
  int n;
  cin >> n;
  while(n--){
    int dtct[10][10];
    int dx[] = {-1, 0, 1, 0};
    int dy[] = {0, 0, 0, 1};
    for(int i = 0; i < 10; i++){
      for(int j = 0; j < 10; j++){
	cin >> dtct[i][j];
      }
    }
    
    for(int i = 0; i < 1 << 10; i++){
      int axi[10][10] = {{0}};
      int tmp[10][10] = {{0}};
      for(int j = 0; j < 10; j++){
	axi[0][j] = (i >> j) & 1;
	if(axi[0][j] == 0) continue;
	for(int k = 0; k < 4; k++){
	  int nx = j + dx[k], ny = dy[k];
	  if(nx < 0 || 10 <= nx || ny < 0 || 10 <= ny) continue;
	  tmp[ny][nx]++;
	}
      }
      for(int j = 1; j < 10; j++){
	for(int k = 0; k < 10; k++){
	  if((dtct[j-1][k]+tmp[j-1][k])%2 == 1){
	    axi[j][k] = 1;
	    for(int l = 0; l < 4; l++){
	      int nx = k + dx[l], ny = j + dy[l];
	      if(nx < 0 || 10 <= nx || ny < 0 || 10 <= ny) continue;
	      tmp[ny][nx]++;
	    }
	  }
	}
      }
      bool flag = true;
      for(int j = 0; j < 10; j++){
	if((tmp[9][j]+dtct[9][j])%2 == 1) flag = false;
      }
      if(flag){
	for(int j = 0; j < 10; j++){
	  for(int k = 0; k < 10; k++) cout << axi[j][k] << (k == 9 ? "\n":" ");
	}
	break;
      }
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main(){
  int n;
  cin>>n;
  while(n--){
    int mp[12][12],ans[12][12];
    for(int i=1;i<=10;i++)for(int j=1;j<=10;j++) cin>>mp[i][j];
    int cp[12][12];

    for(int i=0;i<(1<<10);i++){
      
      for(int j=1;j<=10;j++)
	for(int k=1;k<=10;k++)cp[j][k]=mp[j][k],ans[j][k]=0;
      for(int j=0;j<10;j++){
	if(i&(1<<j)){
	  cp[1][j+1]=!cp[1][j+1];
	  cp[1][j]=!cp[1][j];
	  cp[1][j+2]=!cp[1][j+2];
	  cp[2][j+1]=!cp[2][j+1];
	  ans[1][j+1]=1;
	}
      }
      for(int j=2;j<=10;j++){
	for(int k=1;k<=10;k++){
	  if(cp[j-1][k]){
	    cp[j-1][k]=!cp[j-1][k];
	    cp[j][k]=!cp[j][k];
	    cp[j][k-1]=!cp[j][k-1];
	    cp[j][k+1]=!cp[j][k+1];
	    cp[j+1][k]=!cp[j+1][k];
	    ans[j][k]=1;
	  }
	}
      }
      int f=0;
      for(int j=1;j<=10;j++)
	for(int k=1;k<=10;k++)
	  if(cp[j][k])f=1;
      if(!f)break;
    }

    for(int i=1;i<=10;i++){
      for(int j=1;j<=10;j++){
	if(j!=1)cout<<' ';
	cout<<ans[i][j];
      }
      cout<<endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <algorithm>
#include <math.h>
#include <map>
#include <functional>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <typeinfo>
#define PI 3.14159265359
#define INF 99999999
#define rep(i, n) for(int i=0; i<n; i++)
#define REP(n) rep(i, n)
#define pb push_back
#define mp make_pair
typedef long long ll;
using namespace std;
typedef pair<int, int> P;
 
int n;
const int dx[5] = {-1, 0, 0, 0, 1};
const int dy[5] = {0, -1, 0, 1, 0};
int tile[10][10];
int flip[10][10];

int get(int x, int y)
{
	int c = tile[y][x];
	rep(d, 5)
	{
		int x2 = x + dx[d];
		int y2 = y + dy[d];
		if (0 <= x2 && x2 < 10 && 0 <= y2 && y2 < 10)
		{
			c += flip[y2][x2];
		}
	}
	return c % 2;
}

void print()
{
	rep(i, 10)
	{
		rep(j, 10)
		{
			if (j == 9)
			{
				printf("%d\n", flip[i][j]);
			} else {
				printf("%d ", flip[i][j]);
			}
		}
	}
}

bool calc()
{
	for (int i=1; i<10; i++)
	{
		for (int j=0; j<10; j++)
		{
			if (get(j, i-1) != 0)
			{
				flip[i][j] = 1;
			}
		}
	}

	for (int j=0; j<10; j++)
	{
		if (get(j, 9) != 0)
		{
			return false;
		}
	}

	return true;
}

int main()
{
	cin >> n;

	REP(n)
	{
		rep(j, 10)
		{
			rep(k, 10)
			{
				cin >> tile[j][k];
			}
		}

		for (int j=0; j<(1<<10); j++)
		{
			memset(flip, 0, sizeof(flip));
			for (int k=0; k<10; k++)
			{
				flip[0][10-k-1] = j >> k & 1;
			}
			
			if (calc())
			{
				print();
				break;
			}
		}

		/*
		//デバッグ
		rep(j, 10)
		{
			rep(k, 10)
			{
				printf("%d ", tile[j][k]);	
			}
			printf("\n");
		}
		*/
	}

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1144
final_rank: 1

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

void frip(int y, int x, int map[10][10]){
	if(y < 0 || x < 0 || y >= 10 || x >= 10){
		return;
	}else{
		map[y][x] = !map[y][x];
	}
}

void frips(int y, int x, int map[10][10]){
	frip(y - 1, x, map);
	frip(y + 1, x, map);
	frip(y, x, map);
	frip(y, x - 1, map);
	frip(y, x + 1, map);
}

int main(){
	
	int n;
	
	int origin[10][10];
	
	int f_point[10][10];
	
	int map[10][10];
	
	bool checker;
	
	cin >> n;
	
	int N = 10;

	for(int loop = 0; loop < n; loop++){
		
		for(int i = 0; i < N; i++){
			for(int j = 0; j < N; j++){
				cin >> origin[i][j];
			}
		}
		
		for(int i = 0; i < (1 << N); i++){
			
			for(int x = 0; x < N; x++){
				for(int y = 0; y < N; y++){
					map[y][x] = origin[y][x];
					f_point[y][x] = 0;
				}
			}
			
			for (int x = 0; x < N; x++){
				if((i & (1 << (N - x - 1))) != 0){
					frips(0, x, map);
					f_point[0][x] = 1;
				}else{
				}
			}
			
			for(int y = 1; y < N; y++){
				for(int x = 0; x < N; x++){
					if(map[y - 1][x]){
						frips(y, x, map);
						f_point[y][x] = 1;
					}
				}
			}
			
			checker = true;
			
			for(int x = 0; x < N; x++){
				if(map[N - 1][x]){
					checker = false;
					break;
				}
			}
			
			if(checker){
				for(int y = 0; y < N; y++){
					if(f_point[y][0]){
						printf("1");
					}else{
						printf("0");
					}
					for(int x = 1; x < N; x++){
						if(f_point[y][x]){
							printf(" 1");
						}else{
							printf(" 0");
						}
					}
					printf("\n");
				}
			}
		}
	}
	
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1132
final_rank: 12

code_snippet: #include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++) 
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
vvi out(10,vi(10)),in(10,vi(10)),tmp(10,vi(10));
vi top(10);
int dx[]={-1,0,0,0,1};
int dy[]={0,-1,0,1,0};
bool solve2(){
	rep(i,10)rep(j,10)out[i][j]=0;
	tmp=in;
	rep(i,10)if(top[i]){
		out[0][i]=1;
		rep(j,5){
			int nx=dx[j];
			int ny=i+dy[j];
			if(nx>=0&&nx<10&&ny>=0&&ny<10)tmp[nx][ny]=!tmp[nx][ny];
		}
	}
	loop(i,1,10)rep(j,10)if(tmp[i-1][j]){
		out[i][j]=1;
		rep(k,5){
			int nx=i+dx[k];
			int ny=j+dy[k];
			if(nx>=0&&nx<10&&ny>=0&&ny<10)tmp[nx][ny]=!tmp[nx][ny];
		}
	}
	bool h=true;
	rep(i,10)rep(j,10)if(tmp[i][j])h=false;
	return h;
}
bool solve(int a){
	if(a==10)if(solve2())return true;
	else return false;
	
	top[a]=1;
	if(solve(a+1))return true;
	top[a]=0;
	if(solve(a+1))return true;
	return false;
}
int main(){
	int n;
	cin>>n;
	while(n--){
		rep(i,10)top[i]=0;
		rep(i,10)rep(j,10)cin>>in[i][j];
		solve(0);
		rep(i,10){
			rep(j,9)cout<<out[i][j]<<" ";
			cout<<out[i][9]<<endl;
		}
	}
}
accuracy: 1
time_ms: 10
memory_kb: 1212
final_rank: 10

code_snippet: #include "bits/stdc++.h"

using namespace std;

typedef pair<int,int> pii;
typedef vector<int> vi;

#define dump(x)  cerr << #x << " = " << (x) << endl
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(a)  (a).begin(),(a).end()
#define pb push_back
#define INF 999999999
int ans[11][11]={};

vector<vector<int> > d(int y,int x,vector<vector<int> > t){
    int dx[]={0,0,0,-1,1};
    int dy[]={-1,0,1,0,0};
    rep(k,5){
        int ddy=y+dy[k],ddx=x+dx[k];
        if(ddx>=0&&ddy>=0&&ddx<10&&ddy<10){
            t[ddy][ddx]=!t[ddy][ddx];
        }
    }
    return t;
}

int main(){
    int n;
    cin>>n;
    rep(loop,n){
        vector<vector<int> > data;
        rep(i,10){
            vector<int> a(10);
            rep(j,10)cin>>a[j];
            data.pb(a);
        }
//        rep(i,10){rep(j,10)cout<<data[i][j]<<" ";cout<<endl;}
        rep(i,1<<10){
            vector<vector<int> > t=data;
            rep(j,11)rep(k,11)ans[j][k]=0;
            rep(j,10){
                ans[0][j]=((i&(1<<j))!=0);
                if(ans[0][j])t=d(0,j,t);
            }
            for(int j=1;j<10;j++){
                for(int k=0;k<10;k++){
                    if(t[j-1][k]==1){
                        ans[j][k]=1;
                        t=d(j,k,t);
                    }
                }
            }
            bool f=true;
            rep(j,10){
                if(t[9][j]==1)f=false;
            }
            if(f){
                rep(j,10){
                    rep(k,10){
                        if(k)cout<<" ";
                        cout<<ans[j][k];
                    }
                    cout<<endl;
                }
                break;
            }
        }
    }
}
accuracy: 1
time_ms: 350
memory_kb: 1220
final_rank: 19

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
#include<string>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstring>
#include<stack>
#include<functional>
#include<sstream>
using namespace std;
typedef long long ll;

const ll MOD = 1000000007;
int dx[5] = {0, 1, 0, -1, 0}, dy[5] = {0, 0, 1, 0, -1};
int fld[10][10];

void Reverse(int x, int y, int cnt[10][10])
{
	for(int i = 0; i < 5; i++)
	{
		int nx = x + dx[i];
		int ny = y + dy[i];
		if(0 <= nx && nx < 10 && 0 <= ny && ny < 10) cnt[ny][nx]++;
	}
}

int main(){
	int N;
	cin >> N;
	for(int c = 0; c < N; c++)
	{
		for(int i = 0; i < 10; i++)
		{
			for(int j = 0; j < 10; j++)
			{
				cin >> fld[i][j];
			}
		}

		bool ans = false;
		int out[10][10];
		for(int p = 0; p < (1 << 10); p++)
		{
			int cnt[10][10] = {};
			for(int i = 0; i < 10; i++)
			{
				out[0][i] = ((p >> i) & 1);
				if(out[0][i] == 1) Reverse(i, 0, cnt);
			}
			for(int i = 0; i < 9; i++)
			{
				for(int j = 0; j < 10; j++)
				{
					if(((fld[i][j] + cnt[i][j]) & 1) == 1)
					{
						out[i + 1][j] = 1;
						Reverse(j, i + 1, cnt);
					}
					else
					{
						out[i + 1][j] = 0;
					}
				}
			}

			ans = true;
			for(int i = 0; i < 10; i++)
			{
				if(((fld[9][i] + cnt[9][i]) & 1) == 1) ans = false;
			}
			if(ans) break;
		}

		for(int i = 0; i < 10; i++)
		{
			printf("%d", out[i][0]);
			for(int j = 1; j < 10; j++)
			{
				printf(" %d", out[i][j]);
			}
			puts("");
		}
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1148
final_rank: 2

code_snippet: #include<bits/stdc++.h>
using namespace std;

const int dx[]={-1,0,1,0,0};
const int dy[]={0,-1,0,1,0};

int ans[10][10];
int latte[10][10];

void change(int y,int x){
    for(int d=0;d<5;d++){
        int ty=y+dy[d],tx=x+dx[d];
        if(ty<0||ty>=10||tx<0||tx>=10)continue;
        latte[ty][tx]=1-latte[ty][tx];
    }
}

void solve(){
    int fld[10][10];
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            cin>>fld[i][j];
        }
    }

    for(int s=0;s<(1<<11);s++){
        fill_n(*ans,100,0);

        for(int i=0;i<10;i++)
            for(int j=0;j<10;j++)
                latte[i][j]=fld[i][j];

        for(int i=0;i<10;i++){
            if((s>>i)&1){
                ans[0][i]=1;
                change(0,i);
            }
        }

        for(int i=1;i<10;i++){
            for(int j=0;j<10;j++){
                if(latte[i-1][j]){
                    ans[i][j]=1;
                    change(i,j);
                }
            }
        }

        bool f=true;
        for(int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(latte[i][j])f=false;
            }
        }

        if(f){
            for(int i=0;i<10;i++){
                for(int j=0;j<10;j++){
                    if(j)cout<<" ";
                    cout<<ans[i][j];
                }
                cout<<endl;
            }
            return;
        }
    }
}

int main(){
    int N;
    cin>>N;
    while(N--)solve();
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 3