QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#218207#6552. Good and Lucky MatriceszhouhuanyiAC ✓387ms5628kbC++142.4kb2023-10-17 20:32:022023-10-17 20:32:03

Judging History

你现在查看的是最新测评结果

  • [2023-10-17 20:32:03]
  • 评测
  • 测评结果:AC
  • 用时:387ms
  • 内存:5628kb
  • [2023-10-17 20:32:02]
  • 提交

answer

#include<iostream>
#include<cstdio>
#include<bitset>
#define N 2000
using namespace std;
int read()
{
	char c=0;
	int sum=0;
	while (c<'0'||c>'9') c=getchar();
	while ('0'<=c&&c<='9') sum=sum*10+c-'0',c=getchar();
	return sum;
}
int T,n,num[N+1],tong[N+1],length,tong2[N+1],length2;
bitset<N+1>B[N+1];
bitset<N+1>B2[N+1];
bitset<N+1>c[N+1];
bool used[N+1],vis[N+1];
void insert(bitset<N+1>st)
{
	for (int i=n;i>=1;--i)
		if (st[i])
		{
			if (!c[i][i])
			{
				c[i]=st;
				return;
			}
			else st^=c[i];
		}
	return;
}
void solve(bitset<N+1>st)
{
	for (int i=n;i>=1;--i)
		if (st[i])
		{
			vis[i]=1;
			if (!c[i][i]) st[i]=0;
			else st^=c[i];
		}
	return;
}
int main()
{
	string s;
	int ps,ps2;
	char cs;
	T=read();
	while (T--)
	{
		cin>>s,n=read();
		for (int i=1;i<=n;++i)
		{
			for (int j=1;j<=n;++j) cin>>cs,B[i][j]=cs-'0';
			B2[i].reset(),c[i].reset();
		}
		if (s=="lucky")
		{
			for (int i=1;i<=n;++i) used[i]=0;
			for (int i=1;i<=n;++i)
			{
				length=length2=ps=ps2=0;
				for (int j=1;j<=n;++j)
				{
					if (c[j][j]) tong[++length]=j;
					else tong2[++length2]=j;
				}
				for (int j=1;j<=n;++j)
				{
					if (used[j])
					{
						++ps;
						if (B[i][j]) B2[i]^=c[tong[ps]];
					}
					else
					{
						++ps2;
						if (B[i][j]) B2[i][tong2[ps2]]=B2[i][tong2[ps2]]^1;
					}
				}
				for (int j=1;j<=n;++j)
					if (B[i][j]&&!used[j])
					{
						used[j]=1;
						break;
					}
				insert(B2[i]);
			}
			printf("%d\n",n);
			for (int i=1;i<=n;++i)
			{
				for (int j=1;j<=n;++j) printf("%d",(int)(B2[i][j]));
				puts("");
			}
		}
		else
		{
			for (int i=1;i<=n;++i) used[i]=0;
			for (int i=1;i<=n;++i)
			{
				length=length2=ps=ps2=0;
				for (int j=1;j<=n;++j) vis[j]=0;
				for (int j=1;j<=n;++j)
				{
					if (used[j]) tong[++length]=j;
					else tong2[++length2]=j;
				}
				for (int j=1;j<=n;++j)
				{
					if (c[j][j]) num[j]=++ps;
					else num[j]=++ps2;
				}
				solve(B[i]);
				for (int j=1;j<=n;++j)
					if (vis[j])
					{
						if (c[j][j]) B2[i][tong[num[j]]]=1;
						else B2[i][tong2[num[j]]]=1;
					}
				for (int j=1;j<=n;++j)
					if (B2[i][j]&&!used[j])
					{
						used[j]=1;
						break;
					}
				insert(B[i]);
			}
			printf("%d\n",n);
			for (int i=1;i<=n;++i)
			{
				for (int j=1;j<=n;++j) printf("%d",(int)(B2[i][j]));
				puts("");
			}
		}
	}
	return 0;
}

詳細信息

Test #1:

score: 100
Accepted
time: 0ms
memory: 4040kb

First Run Input

3
lucky
2
11
11
good
2
11
01
lucky
2
01
10

First Run Output

2
11
01
2
11
11
2
01
10

Second Run Input

3
good
2
11
01
lucky
2
11
11
good
2
01
10

Second Run Output

2
11
11
2
11
01
2
01
10

result:

ok 9 lines

Test #2:

score: 100
Accepted
time: 0ms
memory: 4076kb

First Run Input

3
good
2
11
10
lucky
2
11
01
good
2
01
10

First Run Output

2
11
01
2
11
10
2
01
10

Second Run Input

3
lucky
2
11
01
good
2
11
10
lucky
2
01
10

Second Run Output

2
11
10
2
11
01
2
01
10

result:

ok 9 lines

Test #3:

score: 100
Accepted
time: 269ms
memory: 5556kb

First Run Input

1
good
2000
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #4:

score: 100
Accepted
time: 267ms
memory: 5556kb

First Run Input

1
lucky
2000
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
good
2000
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #5:

score: 100
Accepted
time: 273ms
memory: 5560kb

First Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #6:

score: 100
Accepted
time: 266ms
memory: 5524kb

First Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #7:

score: 100
Accepted
time: 322ms
memory: 5560kb

First Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #8:

score: 100
Accepted
time: 270ms
memory: 5556kb

First Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #9:

score: 100
Accepted
time: 303ms
memory: 5276kb

First Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #10:

score: 100
Accepted
time: 276ms
memory: 5332kb

First Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #11:

score: 100
Accepted
time: 275ms
memory: 5520kb

First Run Input

1
good
2000
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #12:

score: 100
Accepted
time: 270ms
memory: 5528kb

First Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #13:

score: 100
Accepted
time: 285ms
memory: 5328kb

First Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #14:

score: 100
Accepted
time: 281ms
memory: 5332kb

First Run Input

1
lucky
2000
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
good
2000
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #15:

score: 100
Accepted
time: 269ms
memory: 5268kb

First Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #16:

score: 100
Accepted
time: 267ms
memory: 5324kb

First Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #17:

score: 100
Accepted
time: 288ms
memory: 5328kb

First Run Input

1
good
2000
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

First Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Input

1
lucky
2000
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

Second Run Output

2000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

result:

ok 2001 lines

Test #18:

score: 100
Accepted
time: 288ms
memory: 5368kb

First Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #19:

score: 100
Accepted
time: 285ms
memory: 5560kb

First Run Input

1
good
2000
010011111010101111010111100111111101111000011010111101101100111111000011011101111110110111000001110111110011000010110111110101011101001101110010000011010111011010000011011111110001001111111111001110010010110101111101111011110100110000011110000001101101011011010101111001111011111110111000...

First Run Output

2000
0100111110101011110101111001111111011110000110101111011011001111110000110111011111101101110000011101111100110000101101111101010111010011011100100000110101110110100000110111111100010011111111110011100100101101011111011110111101001100000111100000011011010110110101011110011110111111101110001111110...

Second Run Input

1
lucky
2000
01001111101010111101011110011111110111100001101011110110110011111100001101110111111011011100000111011111001100001011011111010101110100110111001000001101011101101000001101111111000100111111111100111001001011010111110111101111010011000001111000000110110101101101010111100111101111111011100...

Second Run Output

2000
0100111110101011110101111001111111011110000110101111011011001111110000110111011111101101110000011101111100110000101101111101010111010011011100100000110101110110100000110111111100010011111111110011100100101101011111011110111101001100000111100000011011010110110101011110011110111111101110001111110...

result:

ok 2001 lines

Test #20:

score: 100
Accepted
time: 270ms
memory: 5328kb

First Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #21:

score: 100
Accepted
time: 266ms
memory: 5328kb

First Run Input

1
lucky
2000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

First Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Input

1
good
2000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

Second Run Output

2000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

ok 2001 lines

Test #22:

score: 100
Accepted
time: 2ms
memory: 3836kb

First Run Input

591
good
1
1
lucky
1
1
good
2
01
10
lucky
2
01
10
good
2
11
10
good
2
10
01
lucky
2
10
01
good
2
11
01
lucky
2
11
01
good
2
10
11
lucky
2
10
11
good
2
01
11
lucky
2
01
11
lucky
2
11
11
good
3
001
010
100
lucky
3
001
010
100
good
3
101
010
100
good
3
011
010
100
good
3
111
010
100
good
3
001
110
100
...

First Run Output

1
1
1
1
2
01
10
2
01
10
2
11
01
2
10
01
2
10
01
2
11
11
2
11
10
2
10
11
2
10
11
2
01
11
2
01
11
2
11
01
3
001
010
100
3
001
010
100
3
101
001
010
3
011
001
100
3
111
001
010
3
001
110
010
3
101
011
001
3
011
101
001
3
111
011
001
3
010
001
100
3
010
001
100
3
110
001
010
3
011
011
100
3
011
010
100
...

Second Run Input

591
lucky
1
1
good
1
1
lucky
2
01
10
good
2
01
10
lucky
2
11
01
lucky
2
10
01
good
2
10
01
lucky
2
11
11
good
2
11
10
lucky
2
10
11
good
2
10
11
lucky
2
01
11
good
2
01
11
good
2
11
01
lucky
3
001
010
100
good
3
001
010
100
lucky
3
101
001
010
lucky
3
011
001
100
lucky
3
111
001
010
lucky
3
001
110
...

Second Run Output

1
1
1
1
2
01
10
2
01
10
2
11
10
2
10
01
2
10
01
2
11
01
2
11
01
2
10
11
2
10
11
2
01
11
2
01
11
2
11
11
3
001
010
100
3
001
010
100
3
101
010
100
3
011
010
100
3
111
010
100
3
001
110
100
3
101
110
100
3
011
110
100
3
111
110
100
3
010
001
100
3
010
001
100
3
110
001
100
3
011
001
100
3
011
001
100
...

result:

ok 2589 lines

Test #23:

score: 100
Accepted
time: 2ms
memory: 3828kb

First Run Input

500
good
4
0001
0010
0100
1000
lucky
4
0001
0010
0100
1000
good
4
1001
0010
0100
1000
good
4
0101
0010
0100
1000
good
4
1101
0010
0100
1000
good
4
0011
0010
0100
1000
good
4
1011
0010
0100
1000
good
4
0111
0010
0100
1000
good
4
1111
0010
0100
1000
good
4
0001
1010
0100
1000
good
4
1001
1010
0100
100...

First Run Output

4
0001
0010
0100
1000
4
0001
0010
0100
1000
4
1001
0001
0010
0100
4
0101
0001
0010
1000
4
1101
0001
0010
0100
4
0011
0001
0100
1000
4
1011
0001
0010
0100
4
0111
0001
0010
1000
4
1111
0001
0010
0100
4
0001
1010
0010
0100
4
1001
0101
0001
0010
4
0101
1001
0001
0010
4
1101
0101
0001
0010
4
0011
1001
00...

Second Run Input

500
lucky
4
0001
0010
0100
1000
good
4
0001
0010
0100
1000
lucky
4
1001
0001
0010
0100
lucky
4
0101
0001
0010
1000
lucky
4
1101
0001
0010
0100
lucky
4
0011
0001
0100
1000
lucky
4
1011
0001
0010
0100
lucky
4
0111
0001
0010
1000
lucky
4
1111
0001
0010
0100
lucky
4
0001
1010
0010
0100
lucky
4
1001
0101...

Second Run Output

4
0001
0010
0100
1000
4
0001
0010
0100
1000
4
1001
0010
0100
1000
4
0101
0010
0100
1000
4
1101
0010
0100
1000
4
0011
0010
0100
1000
4
1011
0010
0100
1000
4
0111
0010
0100
1000
4
1111
0010
0100
1000
4
0001
1010
0100
1000
4
1001
1010
0100
1000
4
0101
1010
0100
1000
4
1101
1010
0100
1000
4
0011
1010
01...

result:

ok 2500 lines

Test #24:

score: 100
Accepted
time: 2ms
memory: 3836kb

First Run Input

400
good
5
00001
00010
00100
01000
10000
lucky
5
00001
00010
00100
01000
10000
good
5
10001
00010
00100
01000
10000
good
5
01001
00010
00100
01000
10000
good
5
11001
00010
00100
01000
10000
good
5
00101
00010
00100
01000
10000
good
5
10101
00010
00100
01000
10000
good
5
01101
00010
00100
01000
10000...

First Run Output

5
00001
00010
00100
01000
10000
5
00001
00010
00100
01000
10000
5
10001
00001
00010
00100
01000
5
01001
00001
00010
00100
10000
5
11001
00001
00010
00100
01000
5
00101
00001
00010
01000
10000
5
10101
00001
00010
00100
01000
5
01101
00001
00010
00100
10000
5
11101
00001
00010
00100
01000
5
00011
0000...

Second Run Input

400
lucky
5
00001
00010
00100
01000
10000
good
5
00001
00010
00100
01000
10000
lucky
5
10001
00001
00010
00100
01000
lucky
5
01001
00001
00010
00100
10000
lucky
5
11001
00001
00010
00100
01000
lucky
5
00101
00001
00010
01000
10000
lucky
5
10101
00001
00010
00100
01000
lucky
5
01101
00001
00010
00100...

Second Run Output

5
00001
00010
00100
01000
10000
5
00001
00010
00100
01000
10000
5
10001
00010
00100
01000
10000
5
01001
00010
00100
01000
10000
5
11001
00010
00100
01000
10000
5
00101
00010
00100
01000
10000
5
10101
00010
00100
01000
10000
5
01101
00010
00100
01000
10000
5
11101
00010
00100
01000
10000
5
00011
0001...

result:

ok 2400 lines

Test #25:

score: 100
Accepted
time: 2ms
memory: 4064kb

First Run Input

500
good
4
0101
1101
1010
1001
good
4
1110
1010
0101
1101
good
4
0101
1010
1011
0110
good
4
1011
1110
0011
0111
good
4
0101
1000
1110
0010
good
4
1110
1111
1011
0011
good
4
0011
1101
0010
0101
good
4
1101
0111
1111
0001
good
4
0110
1001
0111
1100
good
4
1011
0010
0110
0011
good
4
1100
0100
0111
1001...

First Run Output

4
0101
1100
1001
1011
4
1110
1010
1001
0101
4
0101
1001
1101
1110
4
1011
0111
0110
1011
4
0101
1000
1011
1101
4
1110
1001
0011
1101
4
0011
1111
1101
0111
4
1101
1101
1110
1011
4
0110
1001
1110
1001
4
1011
0001
1010
0101
4
1100
1100
1111
0111
4
1101
1111
1101
1111
4
0100
0010
1100
0111
4
1111
0010
11...

Second Run Input

500
lucky
4
0101
1100
1001
1011
lucky
4
1110
1010
1001
0101
lucky
4
0101
1001
1101
1110
lucky
4
1011
0111
0110
1011
lucky
4
0101
1000
1011
1101
lucky
4
1110
1001
0011
1101
lucky
4
0011
1111
1101
0111
lucky
4
1101
1101
1110
1011
lucky
4
0110
1001
1110
1001
lucky
4
1011
0001
1010
0101
lucky
4
1100
110...

Second Run Output

4
0101
1101
1010
1001
4
1110
1010
0101
1101
4
0101
1010
1011
0110
4
1011
1110
0011
0111
4
0101
1000
1110
0010
4
1110
1111
1011
0011
4
0011
1101
0010
0101
4
1101
0111
1111
0001
4
0110
1001
0111
1100
4
1011
0010
0110
0011
4
1100
0100
0111
1001
4
1101
0011
0111
1111
4
0100
0010
1100
0111
4
1111
0100
00...

result:

ok 2500 lines

Test #26:

score: 100
Accepted
time: 2ms
memory: 3828kb

First Run Input

500
lucky
4
1001
1100
1011
0101
lucky
4
0110
1110
1110
0111
lucky
4
1001
0101
0110
0001
lucky
4
0110
1111
1111
1101
lucky
4
1000
0111
0010
1111
lucky
4
0011
0111
1010
1001
lucky
4
1010
0010
1100
1101
lucky
4
1111
0011
0100
1101
lucky
4
1110
0111
0111
0011
lucky
4
1000
1010
0101
1111
lucky
4
0100
110...

First Run Output

4
1001
0001
1110
1010
4
0110
1010
0010
1011
4
1001
1010
0001
0100
4
0110
1011
0001
0010
4
1000
0111
0100
1001
4
0011
0101
1011
1100
4
1010
0100
1100
1101
4
1111
0110
1000
1010
4
1110
1101
0001
0101
4
1000
1010
0101
0011
4
0100
1101
1111
1110
4
1110
1010
0110
0011
4
1110
1000
1010
0011
4
0011
0111
10...

Second Run Input

500
good
4
1001
0001
1110
1010
good
4
0110
1010
0010
1011
good
4
1001
1010
0001
0100
good
4
0110
1011
0001
0010
good
4
1000
0111
0100
1001
good
4
0011
0101
1011
1100
good
4
1010
0100
1100
1101
good
4
1111
0110
1000
1010
good
4
1110
1101
0001
0101
good
4
1000
1010
0101
0011
good
4
0100
1101
1111
1110...

Second Run Output

4
1001
1100
1011
0101
4
0110
1110
1110
0111
4
1001
0101
0110
0001
4
0110
1111
1111
1101
4
1000
0111
0010
1111
4
0011
0111
1010
1001
4
1010
0010
1100
1101
4
1111
0011
0100
1101
4
1110
0111
0111
0011
4
1000
1010
0101
1111
4
0100
1101
0101
1110
4
1110
1010
0110
1111
4
1110
0100
0110
1111
4
0011
0110
10...

result:

ok 2500 lines

Test #27:

score: 100
Accepted
time: 2ms
memory: 4060kb

First Run Input

400
good
5
00011
10010
11110
10101
11011
good
5
11011
11000
10011
10100
00101
good
5
10110
01001
01111
11110
01010
good
5
01111
00111
10110
11111
00010
good
5
10101
11111
10011
11011
11100
good
5
11011
01000
11010
10110
01111
good
5
10001
10100
10000
11000
10110
good
5
10110
00100
01001
10101
10000
...

First Run Output

5
00011
10001
10101
10111
11001
5
11011
01100
11100
10010
11111
5
10110
00101
11100
01010
11101
5
01111
01100
10011
00110
10101
5
10101
10101
10111
10111
01100
5
11011
00100
11001
11001
11011
5
10001
01010
00100
10010
00101
5
10110
00010
00101
11011
00001
5
10010
01001
00111
00101
10110
5
10011
0010...

Second Run Input

400
lucky
5
00011
10001
10101
10111
11001
lucky
5
11011
01100
11100
10010
11111
lucky
5
10110
00101
11100
01010
11101
lucky
5
01111
01100
10011
00110
10101
lucky
5
10101
10101
10111
10111
01100
lucky
5
11011
00100
11001
11001
11011
lucky
5
10001
01010
00100
10010
00101
lucky
5
10110
00010
00101
1101...

Second Run Output

5
00011
10010
11110
10101
11011
5
11011
11000
10011
10100
00101
5
10110
01001
01111
11110
01010
5
01111
00111
10110
11111
00010
5
10101
11111
10011
11011
11100
5
11011
01000
11010
10110
01111
5
10001
10100
10000
11000
10110
5
10110
00100
01001
10101
10000
5
10010
10001
11100
11001
01010
5
10011
0100...

result:

ok 2400 lines

Test #28:

score: 100
Accepted
time: 2ms
memory: 3836kb

First Run Input

400
lucky
5
11001
01111
00101
11111
10111
lucky
5
01010
11001
10011
10100
01001
lucky
5
00111
11000
01101
00001
00110
lucky
5
00101
10000
11001
01010
00111
lucky
5
01101
00001
10111
00011
11100
lucky
5
01010
00111
11001
11001
10011
lucky
5
10100
10111
10110
01001
11001
lucky
5
01001
11101
10110
0111...

First Run Output

5
11001
11110
10100
01011
01111
5
01010
11011
00110
11100
00100
5
00111
11000
10101
00100
00010
5
00101
10000
11010
10010
11011
5
01101
00010
10001
00101
00100
5
01010
01101
11110
10110
10101
5
10100
11111
00011
10010
01100
5
01001
10011
00010
00111
11110
5
11101
01100
10101
01010
10100
5
11100
1101...

Second Run Input

400
good
5
11001
11110
10100
01011
01111
good
5
01010
11011
00110
11100
00100
good
5
00111
11000
10101
00100
00010
good
5
00101
10000
11010
10010
11011
good
5
01101
00010
10001
00101
00100
good
5
01010
01101
11110
10110
10101
good
5
10100
11111
00011
10010
01100
good
5
01001
10011
00010
00111
11110
...

Second Run Output

5
11001
01111
00101
11111
10111
5
01010
11001
10011
10100
01001
5
00111
11000
01101
00001
00110
5
00101
10000
11001
01010
00111
5
01101
00001
10111
00011
11100
5
01010
00111
11001
11001
10011
5
10100
10111
10110
01001
11001
5
01001
11101
10110
01111
01101
5
11101
00110
00110
10001
11100
5
11100
0111...

result:

ok 2400 lines

Test #29:

score: 100
Accepted
time: 2ms
memory: 4064kb

First Run Input

333
good
6
110110
101001
100011
001100
101100
110010
good
6
100000
011111
011011
010001
011110
111100
good
6
111011
011111
101100
010011
101110
110100
good
6
100001
110100
011001
000101
001101
111111
good
6
010010
000101
101010
101000
100001
100101
good
6
111110
111001
101010
111100
011101
001010
go...

First Run Output

6
110110
010101
111111
100110
110010
011101
6
100000
011111
010010
010111
001100
111001
6
111011
110010
100010
101010
011001
001100
6
100001
011010
011110
011010
011110
011111
6
010010
000011
111100
100100
001011
000011
6
111110
011101
100101
101001
010111
001101
6
110101
010110
110001
100010
011101...

Second Run Input

333
lucky
6
110110
010101
111111
100110
110010
011101
lucky
6
100000
011111
010010
010111
001100
111001
lucky
6
111011
110010
100010
101010
011001
001100
lucky
6
100001
011010
011110
011010
011110
011111
lucky
6
010010
000011
111100
100100
001011
000011
lucky
6
111110
011101
100101
101001
010111
001...

Second Run Output

6
110110
101001
100011
001100
101100
110010
6
100000
011111
011011
010001
011110
111100
6
111011
011111
101100
010011
101110
110100
6
100001
110100
011001
000101
001101
111111
6
010010
000101
101010
101000
100001
100101
6
111110
111001
101010
111100
011101
001010
6
110101
101100
011011
100100
101001...

result:

ok 2331 lines

Test #30:

score: 100
Accepted
time: 2ms
memory: 3832kb

First Run Input

333
lucky
6
111011
010000
000010
101111
110001
111100
lucky
6
000010
101001
011100
101111
100011
001101
lucky
6
111100
000010
101111
101101
111100
010011
lucky
6
010110
000101
111011
111110
010010
101101
lucky
6
110000
001010
101010
100111
000011
010011
lucky
6
000110
000010
010110
110110
111001
001...

First Run Output

6
111011
100000
000100
000001
101100
011100
6
000010
101001
111000
100101
000001
000101
6
111100
000010
100111
100110
000110
101111
6
010110
001001
101010
010011
011100
000010
6
110000
001010
111110
110011
111011
011001
6
000110
000100
010010
110010
111001
001010
6
110101
110000
110001
001000
001011...

Second Run Input

333
good
6
111011
100000
000100
000001
101100
011100
good
6
000010
101001
111000
100101
000001
000101
good
6
111100
000010
100111
100110
000110
101111
good
6
010110
001001
101010
010011
011100
000010
good
6
110000
001010
111110
110011
111011
011001
good
6
000110
000100
010010
110010
111001
001010
go...

Second Run Output

6
111011
010000
000010
101111
110001
111100
6
000010
101001
011100
101111
100011
001101
6
111100
000010
101111
101101
111100
010011
6
010110
000101
111011
111110
010010
101101
6
110000
001010
101010
100111
000011
010011
6
000110
000010
010110
110110
111001
001101
6
110101
011000
010010
000100
110111...

result:

ok 2331 lines

Test #31:

score: 100
Accepted
time: 2ms
memory: 4020kb

First Run Input

285
good
7
0011101
1110111
0000011
1011011
1011100
1001010
0000101
good
7
1111100
1101000
0001100
1000100
0101111
0110000
1110010
good
7
1010010
0110010
0001100
1010100
0010111
1011111
1010110
good
7
0110000
0110111
1100101
0111010
1000111
1011011
1001100
good
7
0100010
1010111
0111000
0000010
10000...

First Run Output

7
0011101
1110101
1111101
1111011
1100111
0001001
0010011
7
1111100
0110100
0111100
1110100
1100111
0101000
0010001
7
1010010
1110000
0000110
0111010
0110111
0100011
0111110
7
0110000
0100111
1110101
0111010
1001100
0010101
0001010
7
0100010
1111011
0001110
0100100
0000111
1011011
0011101
7
1110101
...

Second Run Input

285
lucky
7
0011101
1110101
1111101
1111011
1100111
0001001
0010011
lucky
7
1111100
0110100
0111100
1110100
1100111
0101000
0010001
lucky
7
1010010
1110000
0000110
0111010
0110111
0100011
0111110
lucky
7
0110000
0100111
1110101
0111010
1001100
0010101
0001010
lucky
7
0100010
1111011
0001110
0100100
...

Second Run Output

7
0011101
1110111
0000011
1011011
1011100
1001010
0000101
7
1111100
1101000
0001100
1000100
0101111
0110000
1110010
7
1010010
0110010
0001100
1010100
0010111
1011111
1010110
7
0110000
0110111
1100101
0111010
1000111
1011011
1001100
7
0100010
1010111
0111000
0000010
1000011
0110011
1001110
7
1110101
...

result:

ok 2280 lines

Test #32:

score: 100
Accepted
time: 2ms
memory: 4064kb

First Run Input

285
lucky
7
0010000
1000111
1001011
0101100
0010011
1010111
1110011
lucky
7
0010101
1010011
1011001
1011111
0010101
1101000
1010011
lucky
7
0100100
1011010
0111010
1000001
1011100
0001101
0010110
lucky
7
1010001
0100101
0100111
1001000
1010010
1110011
1010001
lucky
7
1001111
0001010
1111101
1110011
...

First Run Output

7
0010000
1000111
0110110
0100111
0111010
1100011
1011111
7
0010101
1010011
1110111
1001111
0100001
1110100
1001101
7
0100100
1110010
0011010
1101001
1111010
1011011
0001010
7
1010001
1001010
1001101
0111100
1110000
0000100
1111000
7
1001111
0010100
0101001
0101010
0100100
0111010
1011101
7
1001101
...

Second Run Input

285
good
7
0010000
1000111
0110110
0100111
0111010
1100011
1011111
good
7
0010101
1010011
1110111
1001111
0100001
1110100
1001101
good
7
0100100
1110010
0011010
1101001
1111010
1011011
0001010
good
7
1010001
1001010
1001101
0111100
1110000
0000100
1111000
good
7
1001111
0010100
0101001
0101010
01001...

Second Run Output

7
0010000
1000111
1001011
0101100
0010011
1010111
1110011
7
0010101
1010011
1011001
1011111
0010101
1101000
1010011
7
0100100
1011010
0111010
1000001
1011100
0001101
0010110
7
1010001
0100101
0100111
1001000
1010010
1110011
1010001
7
1001111
0001010
1111101
1110011
0100011
1111001
1001111
7
1001101
...

result:

ok 2280 lines

Test #33:

score: 100
Accepted
time: 2ms
memory: 4132kb

First Run Input

250
good
8
11000001
10100001
11000011
10001101
11100100
11011100
11101010
00000011
good
8
01001001
01111111
01110010
10101010
11110100
10010100
00110111
11010111
good
8
01100110
00100000
01111110
01110101
10111110
00110100
11101110
01000000
good
8
10101011
10010111
11100010
10101110
11010111
1011111...

First Run Output

8
11000001
10110000
00100001
00010111
11101010
00101010
00101010
10000111
8
01001001
01011011
01100001
11101011
01001011
10100011
11101011
10110111
8
01100110
00010000
00011100
01100111
10110100
01000011
00101101
10000001
8
10101011
10011110
01101001
11001110
01001100
00010111
00001111
10110111
8
11...

Second Run Input

250
lucky
8
11000001
10110000
00100001
00010111
11101010
00101010
00101010
10000111
lucky
8
01001001
01011011
01100001
11101011
01001011
10100011
11101011
10110111
lucky
8
01100110
00010000
00011100
01100111
10110100
01000011
00101101
10000001
lucky
8
10101011
10011110
01101001
11001110
01001100
000...

Second Run Output

8
11000001
10100001
11000011
10001101
11100100
11011100
11101010
00000011
8
01001001
01111111
01110010
10101010
11110100
10010100
00110111
11010111
8
01100110
00100000
01111110
01110101
10111110
00110100
11101110
01000000
8
10101011
10010111
11100010
10101110
11010111
10111111
01010101
11000101
8
11...

result:

ok 2250 lines

Test #34:

score: 100
Accepted
time: 3ms
memory: 4056kb

First Run Input

250
lucky
8
11100100
00101001
10001001
01001000
11100011
00111010
01100100
10101111
lucky
8
01110110
10111011
10100110
00111110
10010110
00101011
11110101
01011011
lucky
8
01000001
01100111
11110010
01010110
00001011
11100110
00000010
10000111
lucky
8
01001101
10101101
10111010
01111011
10001110
011...

First Run Output

8
11100100
01010001
11000110
11010001
10111010
00110011
11111000
10000011
8
01110110
11110101
11101110
00000101
01100101
01011100
11100001
11010001
8
01000001
00001111
11000111
11111110
10100100
00011100
10000000
10101111
8
01001101
11011010
00110010
01000011
00001000
00101100
10000110
11000000
8
11...

Second Run Input

250
good
8
11100100
01010001
11000110
11010001
10111010
00110011
11111000
10000011
good
8
01110110
11110101
11101110
00000101
01100101
01011100
11100001
11010001
good
8
01000001
00001111
11000111
11111110
10100100
00011100
10000000
10101111
good
8
01001101
11011010
00110010
01000011
00001000
0010110...

Second Run Output

8
11100100
00101001
10001001
01001000
11100011
00111010
01100100
10101111
8
01110110
10111011
10100110
00111110
10010110
00101011
11110101
01011011
8
01000001
01100111
11110010
01010110
00001011
11100110
00000010
10000111
8
01001101
10101101
10111010
01111011
10001110
01100001
10111100
10000010
8
11...

result:

ok 2250 lines

Test #35:

score: 100
Accepted
time: 3ms
memory: 3772kb

First Run Input

222
good
9
111101010
011101000
011101011
011101100
010011101
011100111
100101011
111100000
010101011
good
9
111000110
111011101
110000111
100010110
101011010
000110000
010001001
100110101
001110110
good
9
111010101
101011010
000011100
000111110
000111100
111000000
001110100
111110010
111000001
good
...

First Run Output

9
111101010
001110100
011000001
100000001
011101111
001001111
000010111
010000100
110000011
9
111000110
011101111
111100111
010011010
011100000
010001110
000101111
010100111
101100101
9
111010101
010101101
000000111
111011011
010000010
000111000
001110001
101101100
111111011
9
101100111
101100111
01...

Second Run Input

222
lucky
9
111101010
001110100
011000001
100000001
011101111
001001111
000010111
010000100
110000011
lucky
9
111000110
011101111
111100111
010011010
011100000
010001110
000101111
010100111
101100101
lucky
9
111010101
010101101
000000111
111011011
010000010
000111000
001110001
101101100
111111011
lu...

Second Run Output

9
111101010
011101000
011101011
011101100
010011101
011100111
100101011
111100000
010101011
9
111000110
111011101
110000111
100010110
101011010
000110000
010001001
100110101
001110110
9
111010101
101011010
000011100
000111110
000111100
111000000
001110100
111110010
111000001
9
101100111
110101001
10...

result:

ok 2220 lines

Test #36:

score: 100
Accepted
time: 3ms
memory: 4132kb

First Run Input

222
lucky
9
101101101
111010101
001100000
101011101
011010111
110110011
010101011
110110110
100111001
lucky
9
111101111
000010101
010011100
111101111
001000100
100101100
000001010
111000110
010101111
lucky
9
110000000
110100111
110100100
101101011
001110000
000000100
101100001
001010011
000011111
lu...

First Run Output

9
101101101
011000111
110000000
010011001
100001011
100100010
000100100
101000001
000111100
9
111101111
000101010
011011111
011110110
001101010
000101111
100100000
000001111
110110001
9
110000000
010100111
101101111
000000001
100000001
000100000
011101100
001111011
101100101
9
110010010
001010101
01...

Second Run Input

222
good
9
101101101
011000111
110000000
010011001
100001011
100100010
000100100
101000001
000111100
good
9
111101111
000101010
011011111
011110110
001101010
000101111
100100000
000001111
110110001
good
9
110000000
010100111
101101111
000000001
100000001
000100000
011101100
001111011
101100101
good
...

Second Run Output

9
101101101
111010101
001100000
101011101
011010111
110110011
010101011
110110110
100111001
9
111101111
000010101
010011100
111101111
001000100
100101100
000001010
111000110
010101111
9
110000000
110100111
110100100
101101011
001110000
000000100
101100001
001010011
000011111
9
110010010
000101011
11...

result:

ok 2220 lines

Test #37:

score: 100
Accepted
time: 3ms
memory: 4140kb

First Run Input

200
good
10
0010110100
1011111011
1010001110
0011101010
0000011011
0110101010
0101101111
0000101101
1000000011
1000010100
good
10
1110001011
0001000001
0011000100
0001101001
0011111011
0000001101
1000010011
1010100010
1010110110
0001110010
good
10
0101001011
0100101011
1101110001
0000011111
01011101...

First Run Output

10
0010110100
1001111111
1100001111
1101011010
0001101110
0111001010
1101001010
1001011011
0110100111
1011001001
10
1110001011
1111100101
0000110001
0100100101
0011001111
0110101101
0111000111
1001011011
1111111011
1111110101
10
0101001011
0100110000
1100111101
0001101101
1100000100
1001001011
10001...

Second Run Input

200
lucky
10
0010110100
1001111111
1100001111
1101011010
0001101110
0111001010
1101001010
1001011011
0110100111
1011001001
lucky
10
1110001011
1111100101
0000110001
0100100101
0011001111
0110101101
0111000111
1001011011
1111111011
1111110101
lucky
10
0101001011
0100110000
1100111101
0001101101
11000...

Second Run Output

10
0010110100
1011111011
1010001110
0011101010
0000011011
0110101010
0101101111
0000101101
1000000011
1000010100
10
1110001011
0001000001
0011000100
0001101001
0011111011
0000001101
1000010011
1010100010
1010110110
0001110010
10
0101001011
0100101011
1101110001
0000011111
0101110100
0110001100
01010...

result:

ok 2200 lines

Test #38:

score: 100
Accepted
time: 3ms
memory: 4032kb

First Run Input

200
lucky
10
0111011110
1110010101
0010100111
0101011000
0110000100
1101101011
0001110100
1110001101
0100011011
0011010011
lucky
10
1101011111
0100010001
1110111100
0111000101
0100110010
0111111111
0010011011
0111001011
0111110110
0001000101
lucky
10
1111100011
0010101011
1101000101
0110011111
10001...

First Run Output

10
0111011110
1011110111
1010011100
1100011110
1101100010
0110100110
1110110101
1100000111
0000000010
0101101111
10
1101011111
1000100010
1110001101
1101011001
0100000100
1001100001
0010100111
1000110111
0101010011
0000000010
10
1111100011
0101010110
1001000010
1001001101
1010111011
1000101001
10001...

Second Run Input

200
good
10
0111011110
1011110111
1010011100
1100011110
1101100010
0110100110
1110110101
1100000111
0000000010
0101101111
good
10
1101011111
1000100010
1110001101
1101011001
0100000100
1001100001
0010100111
1000110111
0101010011
0000000010
good
10
1111100011
0101010110
1001000010
1001001101
10101110...

Second Run Output

10
0111011110
1110010101
0010100111
0101011000
0110000100
1101101011
0001110100
1110001101
0100011011
0011010011
10
1101011111
0100010001
1110111100
0111000101
0100110010
0111111111
0010011011
0111001011
0111110110
0001000101
10
1111100011
0010101011
1101000101
0110011111
1000111010
1111110111
11000...

result:

ok 2200 lines

Test #39:

score: 100
Accepted
time: 383ms
memory: 5332kb

First Run Input

1
good
2000
100001001000010100100100001000010011000001111101001110100100001010101010100101100010111101010111011011010111111000101101000001001000011001101110000111110001000111001011000001011110010110111111100011101010010011111010001010111101100011010011011000011010111001111011100010100011010011111101...

First Run Output

2000
1000010010000101001001000010000100110000011111010011101001000010101010101001011000101111010101110110110101111110001011010000010010000110011011100001111100010001110010110000010111100101101111111000111010100100111110100010101111011000110100110110000110101110011110111000101000110100111111011100100...

Second Run Input

1
lucky
2000
10000100100001010010010000100001001100000111110100111010010000101010101010010110001011110101011101101101011111100010110100000100100001100110111000011111000100011100101100000101111001011011111110001110101001001111101000101011110110001101001101100001101011100111101110001010001101001111110...

Second Run Output

2000
1000010010000101001001000010000100110000011111010011101001000010101010101001011000101111010101110110110101111110001011010000010010000110011011100001111100010001110010110000010111100101101111111000111010100100111110100010101111011000110100110110000110101110011110111000101000110100111111011100100...

result:

ok 2001 lines

Test #40:

score: 100
Accepted
time: 382ms
memory: 5292kb

First Run Input

1
lucky
2000
00110110010101000101000101011010110011100110001100001110011101001011001111100100100110111100001000101010101110100000011101111001001010010100110110101100101100010111000001001010101001000111010100010011111100110101101111100101000101111100000101011111000101010011011000111100100001111011101...

First Run Output

2000
0011011001010100010100010101101011001110011000110000111001110100101100111110010010011011110000100010101010111010000001110111100100101001010011011010110010110001011100000100101010100100011101010001001111110011010110111110010100010111110000010101111100010101001101100011110010000111101110100111011...

Second Run Input

1
good
2000
001101100101010001010001010110101100111001100011000011100111010010110011111001001001101111000010001010101011101000000111011110010010100101001101101011001011000101110000010010101010010001110101000100111111001101011011111001010001011111000001010111110001010100110110001111001000011110111010...

Second Run Output

2000
0011011001010100010100010101101011001110011000110000111001110100101100111110010010011011110000100010101010111010000001110111100100101001010011011010110010110001011100000100101010100100011101010001001111110011010110111110010100010111110000010101111100010101001101100011110010000111101110100111011...

result:

ok 2001 lines

Test #41:

score: 100
Accepted
time: 374ms
memory: 5628kb

First Run Input

1
good
2000
100110101100100011010110110000001100111111110110110100111011001100101101011010110011101011011001010110101100000011101110111000000110100010100111001010101110000001111010001010000101101001011010101001001101000011010000010010001101101101100100001100110001111101010111011011101110110001001001...

First Run Output

2000
1001101011001000110101101100000011001111111101101101001110110011001011010110101100111010110110010101101011000000111011101110000001101000101001110010101011100000011110100010100001011010010110101010010011010000110100000100100011011011011001000011001100011111010101110110111011101100010010011100000...

Second Run Input

1
lucky
2000
10011010110010001101011011000000110011111111011011010011101100110010110101101011001110101101100101011010110000001110111011100000011010001010011100101010111000000111101000101000010110100101101010100100110100001101000001001000110110110110010000110011000111110101011101101110111011000100100...

Second Run Output

2000
1001101011001000110101101100000011001111111101101101001110110011001011010110101100111010110110010101101011000000111011101110000001101000101001110010101011100000011110100010100001011010010110101010010011010000110100000100100011011011011001000011001100011111010101110110111011101100010010011100000...

result:

ok 2001 lines

Test #42:

score: 100
Accepted
time: 370ms
memory: 5268kb

First Run Input

1
lucky
2000
01100000110000110011111000110100010111010001100011111011001010000001111001011111000100111110001000100010100011111101010101011110001100011000011111100110100001000111000011111001101111010111010101101010101111111100110101000110100100011010110011010001000111000101010010010110000100000011000...

First Run Output

2000
0110000011000011001111100011010001011101000110001111101100101000000111100101111100010011111000100010001010001111110101010101111000110001100001111110011010000100011100001111100110111101011101010110101010111111110011010100011010010001101011001101000100011100010101001001011000010000001100011100001...

Second Run Input

1
good
2000
011000001100001100111110001101000101110100011000111110110010100000011110010111110001001111100010001000101000111111010101010111100011000110000111111001101000010001110000111110011011110101110101011010101011111111001101010001101001000110101100110100010001110001010100100101100001000000110001...

Second Run Output

2000
0110000011000011001111100011010001011101000110001111101100101000000111100101111100010011111000100010001010001111110101010101111000110001100001111110011010000100011100001111100110111101011101010110101010111111110011010100011010010001101011001101000100011100010101001001011000010000001100011100001...

result:

ok 2001 lines

Test #43:

score: 100
Accepted
time: 381ms
memory: 5276kb

First Run Input

1
good
2000
000011011000000111011101000011101110010001010001101001100000010110100001010110000011010101000100101111011101111100011011011011011110011000111001000100110010011110100000000010111010010010101001000000101000111101011000100101101011011111001100110111101011010101010011001010001010011000111100...

First Run Output

2000
0000110110000001110111010000111011100100010100011010011000000101101000010101100000110101010001001011110111011111000110110110110111100110001110010001001100100111101000000000101110100100101010010000001010001111010110001001011010110111110011001101111010110101010100110010100010100110001111001100110...

Second Run Input

1
lucky
2000
00001101100000011101110100001110111001000101000110100110000001011010000101011000001101010100010010111101110111110001101101101101111001100011100100010011001001111010000000001011101001001010100100000010100011110101100010010110101101111100110011011110101101010101001100101000101001100011110...

Second Run Output

2000
0000110110000001110111010000111011100100010100011010011000000101101000010101100000110101010001001011110111011111000110110110110111100110001110010001001100100111101000000000101110100100101010010000001010001111010110001001011010110111110011001101111010110101010100110010100010100110001111001100110...

result:

ok 2001 lines

Test #44:

score: 100
Accepted
time: 380ms
memory: 5560kb

First Run Input

1
lucky
2000
00110110010111110100100000101000101011100010101010111001100011100001111000001001100001101011011111101011100100100000000100001000000110000011111011001001110110010110100101110110111001100100000101111011010110111001111101011010101100001001000101000011010101000111000110110010100100100100000...

First Run Output

2000
0011011001011111010010000010100010101110001010101011100110001110000111100000100110000110101101111110101110010010000000010000100000011000001111101100100111011001011010010111011011100110010000010111101101011011100111110101101010110000100100010100001101010100011100011011001010010010010000001100010...

Second Run Input

1
good
2000
001101100101111101001000001010001010111000101010101110011000111000011110000010011000011010110111111010111001001000000001000010000001100000111110110010011101100101101001011101101110011001000001011110110101101110011111010110101011000010010001010000110101010001110001101100101001001001000000...

Second Run Output

2000
0011011001011111010010000010100010101110001010101011100110001110000111100000100110000110101101111110101110010010000000010000100000011000001111101100100111011001011010010111011011100110010000010111101101011011100111110101101010110000100100010100001101010100011100011011001010010010010000001100010...

result:

ok 2001 lines

Test #45:

score: 100
Accepted
time: 368ms
memory: 5324kb

First Run Input

1
good
2000
000101111001110001101101101010110111011111100111110010001000110101101011010111000010010011111110010100110011100010100101111110011100010110010111011010111100000010011110000011001001000001111110100001110000000111100101100000000011110010001010110001001101000001011111100111101000001001000100...

First Run Output

2000
0001011110011100011011011010101101110111111001111100100010001101011010110101110000100100111111100101001100111000101001011111100111000101100101110110101111000000100111100000110010010000011111101000011100000001111001011000000000111100100010101100010011010000010111111001111010000010010001000100100...

Second Run Input

1
lucky
2000
00010111100111000110110110101011011101111110011111001000100011010110101101011100001001001111111001010011001110001010010111111001110001011001011101101011110000001001111000001100100100000111111010000111000000011110010110000000001111001000101011000100110100000101111110011110100000100100010...

Second Run Output

2000
0001011110011100011011011010101101110111111001111100100010001101011010110101110000100100111111100101001100111000101001011111100111000101100101110110101111000000100111100000110010010000011111101000011100000001111001011000000000111100100010101100010011010000010111111001111010000010010001000100100...

result:

ok 2001 lines

Test #46:

score: 100
Accepted
time: 377ms
memory: 5332kb

First Run Input

1
lucky
2000
11101001011011111101111110111011001011100011110000100110010010000101010100001001000010010111011011101001001000100101001101010111010100001101100100101010001100110010101100111111111111111010001111000000110100010110111101110010011001001011001011001110110100101101010100010100000000000110100...

First Run Output

2000
1110100101101111110111111011101100101110001111000010011001001000010101010000100100001001011101101110100100100010010100110101011101010000110110010010101000110011001010110011111111111111101000111100000011010001011011110111001001100100101100101100111011010010110101010001010000000000011010001010011...

Second Run Input

1
good
2000
111010010110111111011111101110110010111000111100001001100100100001010101000010010000100101110110111010010010001001010011010101110101000011011001001010100011001100101011001111111111111110100011110000001101000101101111011100100110010010110010110011101101001011010101000101000000000001101000...

Second Run Output

2000
1110100101101111110111111011101100101110001111000010011001001000010101010000100100001001011101101110100100100010010100110101011101010000110110010010101000110011001010110011111111111111101000111100000011010001011011110111001001100100101100101100111011010010110101010001010000000000011010001010011...

result:

ok 2001 lines

Test #47:

score: 100
Accepted
time: 378ms
memory: 5332kb

First Run Input

1
good
2000
000011101110001110101101110000100110011010010000001000101111101110010100111100101001010010000001010000101100010101010100010101110011111001110110000100011000101000001001000100000001011011001010111001000111100000100001000100000111101001001010001011111101101111011100011110110111111110011101...

First Run Output

2000
0000111011100011101011011100001001100110100100000010001011111011100101001111001010010100100000010100001011000101010101000101011100111110011101100001000110001010000010010001000000010110110010101110010001111000001000010001000001111010010010100010111111011011110111000111101101111111100111011010110...

Second Run Input

1
lucky
2000
00001110111000111010110111000010011001101001000000100010111110111001010011110010100101001000000101000010110001010101010001010111001111100111011000010001100010100000100100010000000101101100101011100100011110000010000100010000011110100100101000101111110110111101110001111011011111111001110...

Second Run Output

2000
0000111011100011101011011100001001100110100100000010001011111011100101001111001010010100100000010100001011000101010101000101011100111110011101100001000110001010000010010001000000010110110010101110010001111000001000010001000001111010010010100010111111011011110111000111101101111111100111011010110...

result:

ok 2001 lines

Test #48:

score: 100
Accepted
time: 386ms
memory: 5552kb

First Run Input

1
lucky
2000
00110000101011000110101101110010001111101110000011100001010101000011101101001001111000101110001101110000011010111110011110100111100110011010011110011101111111100001011001101111100010001000100011101100101001111101110010101001100110101010010110011000101000011111011000011001100110111001001...

First Run Output

2000
0011000010101100011010110111001000111110111000001110000101010100001110110100100111100010111000110111000001101011111001111010011110011001101001111001110111111110000101100110111110001000100010001110110010100111110111001010100110011010101001011001100010100001111101100001100110011011100100100101110...

Second Run Input

1
good
2000
001100001010110001101011011100100011111011100000111000010101010000111011010010011110001011100011011100000110101111100111101001111001100110100111100111011111111000010110011011111000100010001000111011001010011111011100101010011001101010100101100110001010000111110110000110011001101110010010...

Second Run Output

2000
0011000010101100011010110111001000111110111000001110000101010100001110110100100111100010111000110111000001101011111001111010011110011001101001111001110111111110000101100110111110001000100010001110110010100111110111001010100110011010101001011001100010100001111101100001100110011011100100100101110...

result:

ok 2001 lines

Test #49:

score: 100
Accepted
time: 387ms
memory: 5280kb

First Run Input

1
good
2000
000101000011000110101111011111110101111100101000100100001111011000100011110111011111110100110011110110000000111001100110110100110111111110111001101100011100010100100001001100101010100001010110000011110010100101001101011011011100101110001010001110111011000100001110101100110100110101000101...

First Run Output

2000
0001010000110001101011110111111101011111001010001001000011110110001000111101110111111101001100111101100000001110011001101101001101111111101110011011000111000101001000010011001010101000010101100000111100101001010011010110110111001011100010100011101110110001000011101011001101001101010001010010100...

Second Run Input

1
lucky
2000
00010100001100011010111101111111010111110010100010010000111101100010001111011101111111010011001111011000000011100110011011010011011111111011100110110001110001010010000100110010101010000101011000001111001010010100110101101101110010111000101000111011101100010000111010110011010011010100010...

Second Run Output

2000
0001010000110001101011110111111101011111001010001001000011110110001000111101110111111101001100111101100000001110011001101101001101111111101110011011000111000101001000010011001010101000010101100000111100101001010011010110110111001011100010100011101110110001000011101011001101001101010001010010100...

result:

ok 2001 lines

Test #50:

score: 100
Accepted
time: 381ms
memory: 5332kb

First Run Input

1
lucky
2000
10001111011011101100010001110001111111100101110001001110111100000110101010110110111110101010111010100010100110110101100010001000101110111000100111101101001101000001101000110101000100011011000101000011010000110011111100010111011001010011011110101010110011110101101111000010111011110110110...

First Run Output

2000
1000111101101110110001000111000111111110010111000100111011110000011010101011011011111010101011101010001010011011010110001000100010111011100010011110110100110100000110100011010100010001101100010100001101000011001111110001011101100101001101111010101011001111010110111100001011101111011011011011101...

Second Run Input

1
good
2000
100011110110111011000100011100011111111001011100010011101111000001101010101101101111101010101110101000101001101101011000100010001011101110001001111011010011010000011010001101010001000110110001010000110100001100111111000101110110010100110111101010101100111101011011110000101110111101101101...

Second Run Output

2000
1000111101101110110001000111000111111110010111000100111011110000011010101011011011111010101011101010001010011011010110001000100010111011100010011110110100110100000110100011010100010001101100010100001101000011001111110001011101100101001101111010101011001111010110111100001011101111011011011011101...

result:

ok 2001 lines