QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#863086#7141. Power of threeC1942huangjiaxuAC ✓176ms17788kbC++141.2kb2025-01-19 12:59:512025-01-19 13:00:00

Judging History

This is the latest submission verdict.

  • [2025-01-19 13:00:00]
  • Judged
  • Verdict: AC
  • Time: 176ms
  • Memory: 17788kb
  • [2025-01-19 12:59:51]
  • Submitted

answer

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5,M=71;
typedef long long ll;
typedef bitset<M> info;
char s[N][M];
int n,m,a[M],b[M];
ll pw[37],ans;
info p[M],A;
int main(){
	scanf("%d%d",&n,&m);
	pw[0]=1;
	for(int i=1;i<=35;++i)pw[i]=3ll*pw[i-1];
	for(int i=1;i<=n;++i)scanf("%s",s[i]);
	for(int i=0;i<m;++i)scanf("%d%d",&a[i],&b[i]);
	for(int i=1;i<=n;++i){
		info v;
		for(int j=0;j<m;++j)if(s[i][j]=='1'){
			if(a[j]<0)v.set(2*b[j]-2);
			else v.set(2*b[j]-1);
		}
		for(int j=69;~j;--j)if(v.test(j)){
			if(!p[j].test(j)){
				p[j]=v;
				break;
			}
			v^=p[j];
		}
	}
	for(int j=69;~j;--j)if(p[j].test(j)){
		if(!(j&1)){
			if(A.test(j))A^=p[j];
			continue;
		}
		if(!p[j].test(j-1)){
			if(!A.test(j))A^=p[j];
			continue;
		}
		if(p[j-1].test(j-1)){
			if(!A.test(j))A^=p[j];
			continue;
		}
		if(A.test(j)!=A.test(j-1)){
			if(!A.test(j))A^=p[j];
			continue;
		}
		p[j].reset(j),p[j].reset(j-1);
		for(int k=j-2;~k;--k)if(p[j].test(k)){
			if(!p[k].test(k)){
				p[k]=p[j];
				break;
			}
			p[j]^=p[k];
		}
	}
	for(int i=1;i<=35;++i){
		if(A.test(2*i-1))ans+=pw[i];
		if(A.test(2*i-2))ans-=pw[i];
	}
	printf("%lld\n",ans);
	return 0;
}

这程序好像有点Bug,我给组数据试试?

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 1ms
memory: 3840kb

input:

2 4
1101
0010
-1 1
-1 2
1 1
1 2

output:

3

result:

ok 1 number(s): "3"

Test #2:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

1 1
1
-1 1

output:

0

result:

ok 1 number(s): "0"

Test #3:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 8
00011101
11000001
11111101
11001111
01001000
1 3
1 5
-1 1
-1 2
1 4
-1 4
1 2
-1 5

output:

324

result:

ok 1 number(s): "324"

Test #4:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 9
111111111
100101111
011011110
000101110
110101100
-1 4
1 3
-1 1
1 2
1 1
-1 3
1 4
-1 2
-1 5

output:

81

result:

ok 1 number(s): "81"

Test #5:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 8
10010000
11101001
11100111
01011110
11110000
1 4
1 2
-1 1
1 3
-1 3
-1 5
1 5
1 1

output:

120

result:

ok 1 number(s): "120"

Test #6:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 10
1101101110
1000100110
1011100111
0100011010
0010100010
1 2
1 3
1 4
-1 3
1 5
-1 2
-1 1
-1 4
1 1
-1 5

output:

339

result:

ok 1 number(s): "339"

Test #7:

score: 0
Accepted
time: 1ms
memory: 3840kb

input:

5 5
00101
00110
01110
00100
01011
-1 1
-1 3
1 5
-1 5
1 4

output:

324

result:

ok 1 number(s): "324"

Test #8:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 8
01000011
00101101
01101001
10111100
10011111
-1 2
-1 5
1 5
1 1
-1 4
-1 1
1 4
1 3

output:

351

result:

ok 1 number(s): "351"

Test #9:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 9
100010101
010011110
010111011
100011001
101011000
1 3
-1 5
-1 1
1 2
-1 4
1 4
1 1
-1 2
-1 3

output:

87

result:

ok 1 number(s): "87"

Test #10:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 10
1110110111
0001000101
1011000010
0100110011
0100011100
-1 5
-1 1
1 1
1 4
-1 2
1 5
-1 4
1 3
-1 3
1 2

output:

348

result:

ok 1 number(s): "348"

Test #11:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 10
0000011010
0010100110
1110101111
1001100001
1101110000
1 3
-1 2
-1 1
1 1
1 4
-1 5
1 5
1 2
-1 4
-1 3

output:

318

result:

ok 1 number(s): "318"

Test #12:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 9
111001110
001111100
101101001
110101010
100110010
-1 5
-1 3
1 4
1 3
1 2
-1 4
-1 1
1 5
1 1

output:

327

result:

ok 1 number(s): "327"

Test #13:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 20
11000001101001011000
11111111111011101011
00110110000111000110
10011010100010010101
00011010011111101010
-1 10
-1 4
1 10
1 9
-1 9
1 4
1 2
-1 7
1 7
-1 3
-1 5
1 8
1 5
1 3
-1 1
-1 8
-1 6
-1 2
1 1
1 6

output:

85647

result:

ok 1 number(s): "85647"

Test #14:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 17
00010111010000111
11100010100110001
10000010111111100
10101111001001110
11110010111000110
-1 8
1 5
-1 3
-1 7
-1 5
1 6
1 4
1 2
-1 4
-1 1
1 8
-1 6
-1 2
1 7
1 9
1 10
-1 10

output:

81468

result:

ok 1 number(s): "81468"

Test #15:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 18
110000011100100100
000101101110000011
100001010000010011
111101100111111001
010001111101111000
1 8
1 1
-1 2
1 6
-1 7
-1 10
-1 5
-1 9
1 10
-1 1
-1 6
1 3
1 7
1 5
-1 8
1 2
1 9
1 4

output:

81183

result:

ok 1 number(s): "81183"

Test #16:

score: 0
Accepted
time: 0ms
memory: 3712kb

input:

5 19
0000101101001000010
0101100011110101111
1001010111110100010
0010101101111111001
0001110111111011000
1 6
1 2
-1 3
1 10
-1 7
-1 5
1 7
-1 9
-1 6
-1 1
-1 2
1 3
1 8
1 5
-1 10
1 9
1 1
-1 4
1 4

output:

85437

result:

ok 1 number(s): "85437"

Test #17:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 12
100111011100
010111000111
110100110010
100100111000
000110100101
-1 9
1 6
-1 4
-1 1
1 10
1 9
-1 5
-1 8
1 3
-1 7
-1 3
1 4

output:

77325

result:

ok 1 number(s): "77325"

Test #18:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 17
01101011111011011
01010110101110101
00001011010000110
00100001001110010
10000101000001011
1 2
1 1
-1 5
1 8
-1 4
-1 6
-1 7
-1 8
1 10
1 5
1 6
-1 9
1 4
-1 2
-1 10
1 3
1 7

output:

66990

result:

ok 1 number(s): "66990"

Test #19:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 20
10101101011011111000
01011010111111101000
01100111111101010000
10100111011110111000
00111110111110011100
1 8
-1 9
-1 7
1 10
1 5
-1 6
-1 2
-1 3
1 3
-1 10
-1 5
-1 8
1 1
-1 1
1 7
1 2
1 4
1 9
1 6
-1 4

output:

87723

result:

ok 1 number(s): "87723"

Test #20:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 14
00111011111001
00011110011001
00110001001110
01000001010101
10110110101000
-1 3
-1 4
1 7
-1 8
1 5
1 9
1 10
-1 2
1 2
-1 10
-1 9
-1 1
-1 6
1 1

output:

80352

result:

ok 1 number(s): "80352"

Test #21:

score: 0
Accepted
time: 0ms
memory: 3712kb

input:

5 15
011001010010010
000010111001011
100010010110100
111011111000111
110000011111000
-1 3
-1 9
1 6
-1 5
1 5
1 10
-1 10
1 9
1 2
1 7
-1 4
-1 2
1 1
-1 6
-1 1

output:

81579

result:

ok 1 number(s): "81579"

Test #22:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 16
0000001011011110
0000101110101110
1100001011000111
1101100100110110
0100000000110000
-1 4
1 2
-1 8
1 9
1 6
1 1
1 8
1 3
1 10
-1 5
1 4
-1 2
1 5
1 7
-1 10
-1 1

output:

86058

result:

ok 1 number(s): "86058"

Test #23:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 67
1000000110000010111010111111111100110011101011100010001100000001010
1101100101011111111110000101010011111000001001011011001111111100111
0001010010000101110110101100101010100100111101110100001100010011111
1010100001011001100001010010110010101011010001010111001010001100111
10111010101010011011010...

output:

55307021622455322

result:

ok 1 number(s): "55307021622455322"

Test #24:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 55
1000111100000101010111011010010000001111001011110100010
1110011010111110010010111111010110011110101101010100111
0000001011101010000011110011011000100000110110001001000
0010111000111110100011101101101001010111010010111011111
0001011101101000010111111110011101010000110000110100110
-1 7
-1 20
1 16...

output:

68513636343149073

result:

ok 1 number(s): "68513636343149073"

Test #25:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 49
0101100110001101010010111001111101001110000101001
1100011110111100010111110111011010011100000000010
1111111010010111100001100000010010111100001000001
1010000101100011001101011000101111010001001111101
0010100000100101011001100100111000111000111000011
1 23
-1 17
1 27
1 3
-1 11
-1 14
-1 15
-1 26
-...

output:

52807105893004452

result:

ok 1 number(s): "52807105893004452"

Test #26:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 42
100010110000011110110100110001000111101010
001100101000100001000101111000010110111100
011101100111110100010110000010000000110110
001111101000000110001111000111101010010010
001111100010010000011000001001000010111011
-1 10
1 18
-1 33
1 29
1 22
1 10
-1 15
-1 27
1 16
1 30
-1 12
1 9
-1 23
1 33
1 15
...

output:

20388054796742595

result:

ok 1 number(s): "20388054796742595"

Test #27:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 46
0100110010100100100000101010111000100001001001
1101101001110100100010100111010100010111111000
1100001010010111000110001110110110010110100011
1000110101011011101000110101101100101101011100
1110110001100100111100100010100001111101010001
-1 17
1 14
1 29
-1 14
1 26
-1 9
1 13
-1 32
-1 33
1 19
1 18
-...

output:

66480531054337620

result:

ok 1 number(s): "66480531054337620"

Test #28:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 42
111110101010111010010000111101111000010110
101001101101111001111100011110001100000011
110001011011110000101110110011101101100000
101101010110110110010011011000101000110110
000100101110010010111110011100100001011011
-1 15
1 22
-1 29
1 23
-1 32
-1 22
1 25
-1 35
-1 10
-1 21
1 14
1 27
1 12
1 11
1 3...

output:

57857563155193362

result:

ok 1 number(s): "57857563155193362"

Test #29:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 64
0011010001101001001011111010110011010100010011100100111000000010
0101110110011100101100110001101000010010001111111100011111111100
0011100000000000110101101110100101100000100000101101011011010010
1111011011100101100100111100011011001101100000111011001010101101
10001000100100001100000111001010011...

output:

72336612421884744

result:

ok 1 number(s): "72336612421884744"

Test #30:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 50
11100010111000010101100111010111101000001110100110
01111101000110100000000101111000010111101011111101
11100111001011000110111110010010111110000010011010
11000100000000010101010110101011011100110011111111
10100111111010100010111001001001000011001010101000
1 11
-1 28
1 33
1 24
1 4
-1 9
1 3
-1 21
...

output:

55476232350502116

result:

ok 1 number(s): "55476232350502116"

Test #31:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 58
0011011001101010110011101000110110101010010110000100101011
0010011101001111110010100000001001010010100011111100110101
0000101000100110011111111001010011111001001100111000110110
1011000011111100100010010110111101100001001011010100011110
0000011011011011000100111100010010111111111100111010010111
...

output:

57244651078302210

result:

ok 1 number(s): "57244651078302210"

Test #32:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

5 63
111110111001110000010110100111001111110110100001000111100110010
101011001010001001100010101101100110001001001010111110101011011
111111000001111101010011011110001000010101100000011111100101001
000001001001100100001010000000110100000111110001110000101110011
110001100001001001011001110110001100110...

output:

73314178211708121

result:

ok 1 number(s): "73314178211708121"

Test #33:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

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

output:

27

result:

ok 1 number(s): "27"

Test #34:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 10
0000000100
1100011101
1110100110
1110000100
1100010101
1010100100
1101010010
0010101010
1011100001
0100001111
1110010110
0101001010
1010011000
1100101010
1111010110
1111001101
0011111010
0100011101
1111111110
0010110111
0011000110
1000010010
1011000110
0110100001
1111101110
1110010010
101110...

output:

363

result:

ok 1 number(s): "363"

Test #35:

score: 0
Accepted
time: 1ms
memory: 3712kb

input:

1000 10
1100101010
0000000110
1011001111
1000010100
0111110000
0010001001
1100100111
1000101110
1100011110
1001001101
1011110100
1000110000
1011111100
1001100010
0111110001
1011111001
0001101110
1110000101
1001001101
0001110101
1100011100
1000000111
1100111010
0100010001
1100100001
0001010010
100000...

output:

363

result:

ok 1 number(s): "363"

Test #36:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 8
10010000
01011110
00101100
00011000
11000110
00000100
01101011
10101110
00111100
00101111
00000001
11110111
01111011
00101011
11000011
10011101
10001100
00101100
11011011
10100010
11001011
00100111
11101100
01011100
01110101
11001101
00000001
01010011
00010000
01111110
10001001
00100110
01001...

output:

354

result:

ok 1 number(s): "354"

Test #37:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 8
10101010
00011111
01011001
01110110
11100010
10110111
01001110
11111101
10100101
01011011
10101110
10101011
00100101
01100011
00011111
10010001
01011000
01001110
00010011
10101011
11101010
10111010
01000100
11000000
01010100
00100001
11101011
11101111
00000111
00001000
10110010
00100111
10000...

output:

363

result:

ok 1 number(s): "363"

Test #38:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 10
1111001010
0001101001
1011111010
1111100101
0011001011
0101101111
0100011110
0001110010
1001010001
1111100101
1100110000
0000111011
1110111000
0111100011
0010110011
1100011111
0110100111
1111001010
0000101100
0111010000
1000001001
1001110000
0101010010
0011101100
0101000111
0010011001
100010...

output:

363

result:

ok 1 number(s): "363"

Test #39:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 9
101000000
111000000
001110010
110010101
011010000
111000101
000101110
100011100
111010101
110010101
100110111
100001010
011111010
101000111
101111000
001100101
010111110
001100010
111011001
110111010
100101111
000010111
001110101
010011101
111010101
010000101
101101100
110000101
110010010
101...

output:

363

result:

ok 1 number(s): "363"

Test #40:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 8
10111010
00100001
11101011
11100011
00010000
11111111
01000101
11111100
01110001
11010011
01100101
00011001
10110101
11100111
10101110
10001100
01110000
01100010
10110100
01000100
00111111
11110110
01011000
01010000
10100010
10110011
10001000
10101010
00011100
01101010
11011011
00110110
10110...

output:

360

result:

ok 1 number(s): "360"

Test #41:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

1000 6
111000
000011
100010
001000
000001
101111
010010
100011
100110
100011
101110
000100
000111
001101
101010
010011
001011
100100
111010
011100
001011
011011
011001
001011
011000
110110
001100
010101
010011
110011
011101
000111
110011
011000
001010
100000
100011
001000
111000
010000
011011
011010...

output:

333

result:

ok 1 number(s): "333"

Test #42:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 8
11011110
10011000
00011001
00001101
10000111
10101111
01001111
10001111
10001101
00010101
11110000
10100100
01101111
01110011
10111001
01000011
11001101
11010000
10101100
10110001
10001111
00111011
10111111
00100010
00000000
10001100
10101110
11000110
00011101
00000111
11110011
11011110
11000...

output:

120

result:

ok 1 number(s): "120"

Test #43:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

1000 20
00010110010010010101
10011001011111101010
00010001101110110001
01111011111001101101
10101000001000011100
01010001000101110000
10110011001011010010
00100000001100100000
01011101111110000110
10011101011001010100
11101001001000111000
10000010000010010011
00100000101101010100
0011111011100110010...

output:

88572

result:

ok 1 number(s): "88572"

Test #44:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 20
11101010010110011010
11000000100011100010
01101101001101111110
11010110101110101110
11100101110111000001
01000101101100101110
00011000011001000011
01110010001000010010
10011111100100100010
11000100000010101000
00101011101011100010
11001000110010001011
00000100110100100000
0000011011100001010...

output:

88572

result:

ok 1 number(s): "88572"

Test #45:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 20
01111000000001100001
10111110100100101001
00110000100001111101
11100101111100111010
10011001000010000101
00100000101110111110
00011001110100010101
11111101101001111001
11000011100111000001
11100101010000001100
10010000111001010001
01001010011101111110
00111011110101000001
1011110010111000011...

output:

88572

result:

ok 1 number(s): "88572"

Test #46:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 9
010111010
110111101
011100101
111000100
100001110
101110100
101001010
001101010
010110010
100111011
011010111
101001001
110001100
000110011
001000110
011111001
000100101
100000010
001001110
011011001
011010000
010001001
011101111
100011011
000110101
100001111
111001100
110110001
000111110
100...

output:

7326

result:

ok 1 number(s): "7326"

Test #47:

score: 0
Accepted
time: 1ms
memory: 3840kb

input:

1000 9
111010010
111111010
110111110
110010111
010110111
000101100
011100011
100101001
100011111
111000101
101110000
000100001
001100001
101011111
011101011
111110100
011001100
110100011
111011001
101101110
100111100
100011111
010110010
011110001
111000010
101111011
100000000
101110111
000000111
101...

output:

360

result:

ok 1 number(s): "360"

Test #48:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 20
01011101001010101110
11000110100101000101
00010010111000101011
00100010111101010100
10110111111101111110
00000111000010100111
10111011011100001000
00111000110101010000
01111110001000001010
01011010111111101000
01011001010111100111
11110011110101110110
11010000100001100010
1110011100011000111...

output:

88572

result:

ok 1 number(s): "88572"

Test #49:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 17
00101001001110010
01011001101010110
01101101001110110
10100100110000001
01111000101110111
00000010101000101
10010001100110001
00110011000100010
00100101010110100
01010100111010000
00101101100100011
00100000100011010
11011101111111100
01001001011101111
11111100011000110
01101001101000111
1010...

output:

87816

result:

ok 1 number(s): "87816"

Test #50:

score: 0
Accepted
time: 0ms
memory: 3712kb

input:

1000 17
10011100010001011
00010110110011010
11110101100010011
11110111100100110
01011010001011010
00110100110001100
00110101111110001
00011000000111000
01011101110011001
11000110101100110
11001111001100010
00111011000100100
10001011000000100
01011110100000011
11010000011000010
01101110101000001
0011...

output:

88491

result:

ok 1 number(s): "88491"

Test #51:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 19
0000100000010100001
0111011010010111101
0010011101110000111
0001110100101110000
0111100111011010110
0100101100011001111
0111111101000111111
0110001101101010011
1111001111000100110
0000100010101001111
1001111000111011001
1010000010011011001
0111011111011110011
0001011100100011011
100001000011...

output:

88572

result:

ok 1 number(s): "88572"

Test #52:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

1000 17
00010000101111001
11110111101001111
01011110111100010
01101110101101010
01010000110001001
00111001100010010
10000100011000001
01110011001000111
01111110010111000
10101011111111111
00110110011011000
11111101111011101
00000101001110010
11010111101100011
11011010100010110
00101000101010011
1011...

output:

88491

result:

ok 1 number(s): "88491"

Test #53:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 68
00001101000011110111100111010001110100000001010111001110100111101111
10111010010110111100110000010101001101011011110111101110011110010011
11110101100000010111111010100001101101101101001000010111101011101110
10101000110001000101100100000111010000101001101100101100100011010110
0001111010011100...

output:

75047317648499559

result:

ok 1 number(s): "75047317648499559"

Test #54:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

1000 36
001110010101111011011011000001010101
101000110111110001110110011101001111
000000100011001011111101110100101101
100100011110101001110110001001000000
001000001101011111000011000110111010
111111010100010110100110000001101111
101111111110111011011110001001010010
100100111110101011101111111100110...

output:

72337655988445023

result:

ok 1 number(s): "72337655988445023"

Test #55:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 47
10101001010000000110000011011110111100111000110
10000100101011001110000001100010000100000010100
00100000100101011011010110000010010000100101111
00111010101010111001100001110011111100100001010
10101001111001010111111001110100010101010111111
01101011000101100110010000011101000000011011001
1011...

output:

52799766577669917

result:

ok 1 number(s): "52799766577669917"

Test #56:

score: 0
Accepted
time: 1ms
memory: 3712kb

input:

1000 70
0101110100010001110100100000010011001110100101111000111110000001001111
0111110100000011011000101111100111010111001110000001100100100011111111
1001110000111100011110111011100111010111000010000100110010000010110000
1001110010000101100011110011001010100110100001001000111100010011100101
00011010...

output:

75047317648499559

result:

ok 1 number(s): "75047317648499559"

Test #57:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 35
01101000001111000000101111000101000
10110101100000100011111011010111000
01001001101001100001101000101110100
01101011101000010100011001101110111
00001101001100010000101110100100000
00100100101101011010011110010110100
00000110100001101100110001111000100
01111100001001011110000000000011110
0011...

output:

2702320716145386

result:

ok 1 number(s): "2702320716145386"

Test #58:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 57
110011000110111010111001001111111010011111100111000111001
110000011001110100101111110001110111011101101010010100101
111011000010110010000100100101101111001000111101101101001
000011010001110000110101010001011100011111100100011100111
110010010000101100100101100000100010111110001101001100101
11...

output:

73171420136280741

result:

ok 1 number(s): "73171420136280741"

Test #59:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 23
01110010001101110000101
11100010101001101111000
00110101110111010010100
11110001111001010010001
01011101001111100110100
01101100100011010001110
01000101110011011011110
01011010011011001001100
10011110010000011110111
11001011011010010001110
11010100001000110111000
01001011110100010001000
0110...

output:

99415598610708

result:

ok 1 number(s): "99415598610708"

Test #60:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 60
010001100010001011110000001110000101001100101010001110101100
010011101000110000101110101111111011000110001011100101110000
111010101011011010100100011101100111010101100100011110101000
011100011100101110011101110010000011010010001000000111101001
001110000001011101010010110001001100000111011111...

output:

69487409792803122

result:

ok 1 number(s): "69487409792803122"

Test #61:

score: 0
Accepted
time: 1ms
memory: 3968kb

input:

1000 51
100100100101100011000010111110111101111100100101110
011010100011101110101101001100100011011110000101000
011001100111011011001010000000101010111111110111110
111110001100110000001000110011101011000111011101110
101100001011101101011010101010000100101010101011101
01110000110011111000000011101011...

output:

69465369786030102

result:

ok 1 number(s): "69465369786030102"

Test #62:

score: 0
Accepted
time: 0ms
memory: 3968kb

input:

1000 56
10001001111110100101100011010011110000001110110111110011
11000011011111001011001101101001011100101000111010011001
10011000101011000010010111011100110111000010011101010001
01111101101011011011101000000100000000010010110000100001
10110011011101110001101111110000011111110101011111110001
0000011...

output:

75047316079508310

result:

ok 1 number(s): "75047316079508310"

Test #63:

score: 0
Accepted
time: 40ms
memory: 17760kb

input:

200000 10
0111110011
1100000101
0000011001
0100111000
1111010001
0011101000
0011111001
1000101001
1010010011
1100001000
0101100111
0000001101
1111101000
0010010111
1011001100
1110101100
0010011001
0110100111
0101100100
0010111010
1100111000
0001100110
1010001111
0110011110
0110001001
0001000010
0000...

output:

363

result:

ok 1 number(s): "363"

Test #64:

score: 0
Accepted
time: 40ms
memory: 17776kb

input:

200000 10
0101110001
1101101001
1100101000
1111110001
0000010110
0011011000
1000011010
0000110101
0001101101
1011001100
0111100010
1101111111
1111110010
0100110010
0010010000
1111001101
1011101010
1011110100
1110001000
1010011110
1000101101
0001111001
0011101011
1111111000
0010100111
1101000000
1100...

output:

363

result:

ok 1 number(s): "363"

Test #65:

score: 0
Accepted
time: 24ms
memory: 17692kb

input:

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

output:

333

result:

ok 1 number(s): "333"

Test #66:

score: 0
Accepted
time: 40ms
memory: 17672kb

input:

200000 10
0101110010
0000101011
1100111111
0101111110
1000110101
0000011000
0001011100
0011000011
0110101000
0110101001
0100000111
0000010001
1010101011
1011011001
1101000110
1000010011
0111101101
1010000000
1010110000
1011101000
1001011000
1010111010
0100111101
1101101111
0000011110
1100000011
0010...

output:

363

result:

ok 1 number(s): "363"

Test #67:

score: 0
Accepted
time: 41ms
memory: 17740kb

input:

200000 10
1001010010
1011010101
0010101000
1000010111
0110101011
0111000101
0010101010
0001010101
0101000110
0001100001
0010110110
1101110011
0011100001
1101110010
1100011000
0001010101
1110001110
0010000010
1000001100
0110100000
0101100100
0110101101
0011001001
0110001111
1000101110
0001101010
1110...

output:

363

result:

ok 1 number(s): "363"

Test #68:

score: 0
Accepted
time: 37ms
memory: 17716kb

input:

200000 9
111110100
011101110
110100010
001100100
110010111
101000101
100101110
100001010
000010101
111110100
101100011
010011101
001000100
110101010
001101001
010001000
000000000
001011100
011101010
100100000
110000001
101010011
011000001
001011110
011101111
010101100
101011001
000001101
111011101
0...

output:

363

result:

ok 1 number(s): "363"

Test #69:

score: 0
Accepted
time: 40ms
memory: 17676kb

input:

200000 10
1001001011
0110010101
1010100111
0010001010
1001111101
0100000110
1010010101
0100010011
0010000101
1100101101
0010110011
0001111001
1100011010
1010111001
0101001110
0110001011
0000101100
0011111011
1000111100
0001111110
0010010111
1101111111
0100011101
0000010010
0000000100
0000111101
0100...

output:

363

result:

ok 1 number(s): "363"

Test #70:

score: 0
Accepted
time: 39ms
memory: 17684kb

input:

200000 9
101110101
100011010
111100000
101001101
011101111
101110110
100110010
000011011
010011101
011110110
011100101
001000111
111011110
010111001
001110111
100110000
001011111
111110010
011011100
011100110
111110011
100110110
011110001
111011010
011011101
010101111
010011001
100000000
111100010
0...

output:

363

result:

ok 1 number(s): "363"

Test #71:

score: 0
Accepted
time: 33ms
memory: 17768kb

input:

200000 7
1100101
0100000
0111101
1011000
0110000
0100100
0011100
0100001
0001101
0000011
0110111
0001010
0111110
0101100
0000110
1110001
0000000
0000110
0110101
0100110
1000011
0111101
1101111
0011100
0101101
0000010
0010000
0111101
1111100
1101111
1110001
1011000
0110100
0010111
0011100
1110111
000...

output:

111

result:

ok 1 number(s): "111"

Test #72:

score: 0
Accepted
time: 33ms
memory: 17768kb

input:

200000 7
0111010
0011011
1110101
1010010
1101011
1101110
1011011
1000000
0100111
1000000
1000011
0001011
0000010
1000110
0110110
0100000
0001110
1101010
1111101
1000110
0011011
0011111
1011101
0101110
0110101
1000101
1000111
0100110
1101100
1110010
0101001
1100111
1001100
0011010
0011011
1010101
000...

output:

282

result:

ok 1 number(s): "282"

Test #73:

score: 0
Accepted
time: 64ms
memory: 17768kb

input:

200000 20
11000101100111001010
00001111011010111110
01110101100101100110
00001000010100111111
00001110111000111011
11001010000101000010
11001000111101111101
10011110101110011001
10101110111101101100
11000001100111100010
00110110010101001111
11011000011001010010
11111000000001011010
11101110111100101...

output:

88572

result:

ok 1 number(s): "88572"

Test #74:

score: 0
Accepted
time: 64ms
memory: 17708kb

input:

200000 20
00010100110111100110
11100011001011010010
10000111010101011011
10010110000101110101
10101001000111101111
00011100011000010001
11101011011001001010
11000000101001010000
10110100110011101010
00000101010001110001
01011001111100110111
10110011110011100010
00000000100010001000
00000110111001000...

output:

88572

result:

ok 1 number(s): "88572"

Test #75:

score: 0
Accepted
time: 64ms
memory: 17628kb

input:

200000 20
11000000000100001000
10001110111111100010
01111111101001010110
00101011011100000111
10010010011010110111
01001010110010001110
11101111010100011010
10100011011011011000
11110101001001110000
00000010111100000010
01010000110110011100
10111100001100000101
10010001110110011110
11000011100010000...

output:

88572

result:

ok 1 number(s): "88572"

Test #76:

score: 0
Accepted
time: 36ms
memory: 17744kb

input:

200000 9
000110010
100111110
101100110
101100011
010100110
001111111
110101001
001010000
111100100
111001101
001100101
110110111
001111000
001011010
010101110
010110011
011011011
101100000
010011100
010111101
011110101
101000001
011101000
000000110
101010100
110010011
010000000
101001010
111111000
1...

output:

28755

result:

ok 1 number(s): "28755"

Test #77:

score: 0
Accepted
time: 53ms
memory: 17788kb

input:

200000 16
1100100001100101
0100000000110000
0101100110111111
1001000011010001
0000000010001010
0010000011011000
1111000110000111
1101011001000011
1000100011011110
0100101111111100
0011001010110001
0111111111011111
0011011010111100
0001100010010011
1000010100001110
1111001001000000
1010010111111011
0...

output:

68880

result:

ok 1 number(s): "68880"

Test #78:

score: 0
Accepted
time: 58ms
memory: 17784kb

input:

200000 18
000110000001001111
010110110001000100
000001001010001010
010011000001010010
001101110010101110
000010011011011011
000101111101101001
101110111011111111
101011101011111100
101111001010110000
101101011000001110
011000110000000001
111010001101010100
010110000111011010
011011110100011100
10101...

output:

68889

result:

ok 1 number(s): "68889"

Test #79:

score: 0
Accepted
time: 61ms
memory: 17652kb

input:

200000 18
010110011101110101
001000000011010110
101100000000001110
101011101111100100
101100111001111011
101001001001001111
000110001011100010
001010000010011010
110101110010011100
000111011110000110
001111100110010111
011011010001011000
101011011000101011
000101111111110001
001101000000011100
11101...

output:

87843

result:

ok 1 number(s): "87843"

Test #80:

score: 0
Accepted
time: 57ms
memory: 17696kb

input:

200000 17
10001100101111101
00111101001101101
01111110110010110
10111000101110011
10111101011010111
01001000111101100
11001111111010110
10101110110001010
10011100010101001
11000001101010011
11001101110011000
00011111101100111
11100011101000010
00111101110001011
01100011000101001
00011101011011100
00...

output:

88563

result:

ok 1 number(s): "88563"

Test #81:

score: 0
Accepted
time: 52ms
memory: 17768kb

input:

200000 15
010111001110100
010000000010101
010100011001000
000001110001011
110110100111010
001100000000110
011110010110011
111011001111110
101111101000010
111110110001111
011000010111101
010101111111100
111000011010011
000110010011101
000001010001100
100111011110110
001110011101001
010001101010000
11...

output:

82011

result:

ok 1 number(s): "82011"

Test #82:

score: 0
Accepted
time: 41ms
memory: 17560kb

input:

200000 11
00101110010
10110010001
00100011001
11101011101
10010010011
01010011100
00011000010
10111101101
11110000011
01000011111
01110000000
00101110110
10001010100
01101000000
10011100100
00101010111
10101000000
00000100100
11010110010
00010111111
00111011001
10101110101
11101011000
10110110101
00...

output:

87597

result:

ok 1 number(s): "87597"

Test #83:

score: 0
Accepted
time: 104ms
memory: 17664kb

input:

200000 37
1101010111111000110100010110001101111
1000111011100000001100101100111000111
0010100000000100110110111110111001100
1010101010011100110110110011100011101
1000010000100101101111101001101010010
1010001111111101101000000000110111011
0111100111100101001100110000010110110
001110000110011111001110...

output:

74946955968975627

result:

ok 1 number(s): "74946955968975627"

Test #84:

score: 0
Accepted
time: 176ms
memory: 17712kb

input:

200000 67
0000010110011010000110100000101001001111011000110111010001111111000
0110101000011101001011110011010010101100100100001011010111111010000
0001101101011011011011110111100000110110101000100111101110110010011
1111010011001011110111001011000010010001110110111011110101101101111
011011011100110111...

output:

75047317646905227

result:

ok 1 number(s): "75047317646905227"

Test #85:

score: 0
Accepted
time: 97ms
memory: 17532kb

input:

200000 36
010100000101010111110101001111001001
101000011100100100100000010011111000
001001101010011000010000000010001000
000010001000100010001110000000110110
000001100100111010010100000100001011
100100111010101100001101011111111110
001110100101011110111000110111001011
0011101000001000111010111101010...

output:

55873143853813407

result:

ok 1 number(s): "55873143853813407"

Test #86:

score: 0
Accepted
time: 123ms
memory: 17724kb

input:

200000 44
10000000011000110011111001110110100000110011
01011101001101101010100000011000001111010101
01101100010110101110100000000110001001000111
01100011100110101001001110000101001011001001
10100110010101111000100111110011000110011111
00001110100101100000111011011010000111111000
11011010010111000011...

output:

69416770506074064

result:

ok 1 number(s): "69416770506074064"

Test #87:

score: 0
Accepted
time: 171ms
memory: 17704kb

input:

200000 63
010100010010000111110101000100100011011101101100010101010100000
000100101000101101111101011001000100001001010001011110100101101
100010100101000100011111001111100001101000011000011000100010101
010101010110010001100011000111111011011010011100100110011110010
0001011000011101010110110100110011...

output:

74978655759340581

result:

ok 1 number(s): "74978655759340581"

Test #88:

score: 0
Accepted
time: 69ms
memory: 17712kb

input:

200000 23
10000000010111000001101
01111001001001000001000
10101001011001000010100
01101110001001100001101
00110010011110100111110
00000011001100000000110
10110110110101011000011
00100001110110011000101
01110100111011011010101
01000110101110001000101
11100111011011110001001
10001100101011110101111
10...

output:

55690587033606081

result:

ok 1 number(s): "55690587033606081"

Test #89:

score: 0
Accepted
time: 168ms
memory: 17724kb

input:

200000 61
0101010010011010010100010101011111010000011101001010110011010
0101010100001001000110010100000110111011001111000100100100100
1011001101001101100101110101110101100101010010100011111100000
1001110111100100010100011111000000110000011000100101100010101
111001101101101010001010110111110111000111...

output:

75044772295886505

result:

ok 1 number(s): "75044772295886505"

Test #90:

score: 0
Accepted
time: 115ms
memory: 17700kb

input:

200000 42
110101011111100010011110000001111100001011
011000001010010101100111011101010110000111
101111000110101000000110110001011111010000
010101011001000110111001001110101000100111
101001001000110001010100011011001101110101
110100001111101100100000111011101101011011
00101000010000101010110010011110...

output:

23063619545512677

result:

ok 1 number(s): "23063619545512677"

Test #91:

score: 0
Accepted
time: 90ms
memory: 17640kb

input:

200000 31
1000110111100110001101010110100
0111010010010011101000000001111
1011000011100101011011001000111
1101110010010000010011110000100
0011101100010100101111000000010
1000111111011010011110010011100
1110001101100101000000011110101
1101011101010110110000000010001
1110001110000110100110110000111
00...

output:

5844078604407042

result:

ok 1 number(s): "5844078604407042"

Test #92:

score: 0
Accepted
time: 153ms
memory: 17756kb

input:

200000 56
10110110001011010111010101001001010110011011101100110110
01101110001101110000011001110111111100100000101011100100
01111010010110011101110011010111101011110011111111100100
11010110110001001011000101010001010110101001100010101000
00100010100010101100010011010000000011110100111001011101
10010...

output:

74772792637729326

result:

ok 1 number(s): "74772792637729326"

Extra Test:

score: 0
Extra Test Passed