Problem:


Making Lunch Boxes

Taro has been hooked on making lunch boxes recently.
Taro has obtained a new lunch box recipe book today, and wants to try as many of the recipes listed in the book as possible.

Enough of the ingredients for all the recipes are at hand, but they all are in vacuum packs of two.
If only one of them is used leaving the other, the leftover will be rotten easily, but making two of the same recipe is not interesting.
Thus he decided to make a set of lunch boxes, each with different recipe, that wouldn't leave any unused ingredients.

Note that the book may include recipes for different lunch boxes made of the same set of ingredients.

How many lunch box recipes can Taro try today at most following his dogma?

Input

The input consists of at most 50 datasets, each in the following format.

n m
b1,1...b1,m
...
bn,1...bn,m

The first line contains n, which is the number of recipes listed in the book, and m, which is the number of ingredients.
Both n and m are positive integers and satisfy 1 &#8804; n &#8804; 500, 1 &#8804; m &#8804; 500 and 1 &#8804; n × m &#8804; 500.
The following n lines contain the information for each recipe with the string of length m consisting of 0 or 1.
bi,j implies whether the i-th recipe needs the j-th ingredient.
1 means the ingredient is needed for the recipe and 0 means not.
Each line contains at least one 1.

The end of the input is indicated by a line containing two zeros.

Output

For each dataset, output the maximum number of recipes Taro can try.

Sample Input

4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0

Output for the Sample Input

3
6
0
6



Sample input:
4 3
110
101
011
110
7 1
1
1
1
1
1
1
1
4 5
10000
01000
00100
00010
6 6
111111
011000
100000
000010
100001
100100
0 0


Sample output:
3
6
0
6

Submission status: Wrong Answer

Solution code:
while 1:
    n, m = map(int, input().split())
    if n == m == 0:
        break
    B = [int(input(), 2) for i in range(n)]
    C = {}
    for b in B:
        D = {b: 1}
        for k in C:
            D[k ^ b] = max(D.get(k ^ b, 0), C[k] + 1)
        C = D
    print(C.get(0, 0))

Submission status: Accepted

Solution code:
while 1:
    n, m = map(int, input().split())
    if n == m == 0:
        break
    B = [int(input(), 2) for i in range(n)]
    C = {0: 0}
    for b in B:
        D = dict(C)
        for k in C:
            D[k ^ b] = max(D.get(k ^ b, 0), C[k] + 1)
        C = D
    print(C[0])

Submission status: Accepted

Solution code:
while 1:
    n, m = map(int, input().split())
    if n+m == 0:
        break
    B = [int(input(),2) for i in range(n)]
    C = {0: 0}
    for b in B:
        *D, = C.items()
        for k, v in D:
            C[k^b] = max(C.get(k^b, 0), v+1)
    print(C[0])

Submission status: Accepted

Solution code:
while 1:
    n, m = map(int, input().split())
    if n+m == 0:
        break
    B = [int(input(),2) for i in range(n)]
    C = {0: 0}
    for b in B:
        D = dict(C)
        for k, v in D.items():
            C[k^b] = max(C.get(k^b, 0), v+1)
    print(C[0])

Submission status: Accepted

Solution code:
while 1:
    n, m = map(int, input().split())
    if n+m == 0:
        break
    C = {0: 0}
    for i in range(n):
        b = int(input(), 2)
        for k, v in dict(C).items():
            if C.get(k^b, 0) < v+1:
                C[k^b] = v+1
    print(C[0])

Submission status: Accepted

Solution code:
ans = []
while 1:
    n, m = map(int, input().split())
    if n+m == 0:
        break
    C = {0: 0}
    for i in range(n):
        b = int(input(), 2)
        for k, v in dict(C).items():
            if C.get(k^b, 0) < v+1:
                C[k^b] = v+1
    ans.append(C[0])
print(*ans, sep="\n")

Submission status: Accepted

Solution code:
def make(n):
    C = {0: 0}
    for i in range(n):
        b = int(input(), 2)
        for k, v in dict(C).items():
            if C.get(k^b, 0) < v+1:
                C[k^b] = v+1
    return C
def calc(P, Q):
    yield 0
    for k, v in P.items():
        if k in Q:
            yield v + Q[k]
def solve():
    while 1:
        n, m = map(int, input().split())
        if n+m == 0:
            break
        yield max(calc(make(n//2), make(n-n//2)))
print(*solve(), sep="\n")

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random,resource

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    rr = []

    def f():
        n,m = LI()
        if n == 0:
            return

        bb = [int(S(), 2) for _ in range(n)]
        bc = collections.defaultdict(int)
        for i in bb:
            bc[i] += 1

        rt = 0
        b = []
        for k,v in bc.items():
            if v > 2:
                if v % 2 == 0:
                    rt += v - 2
                    v = 2
                else:
                    rt += v - 1
                    v = 1
            for i in range(v):
                b.append(k)

        n = len(b)
        c = collections.defaultdict(int)
        c[0] = 0
        for i in b:
            for k,v in list(c.items()):
                t = k ^ i
                if c[t] <= v:
                    c[t] = v + 1

        rr.append(c[0] + rt)
        return True

    while f():
        # print(rr)
        pass

    return JA(rr, "\n")


print(main())

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

# 各recipeを使用した結果を使用するrecipe同士のxorだと考えると
# 作れる状態数は高々2 ^ min(n, m)通り

while 1:
    n, m = LI()
    if n == 0 and m == 0:
        quit()
    recipe = []
    for _ in range(n):
        c = list(map(int, list(input())))
        s = 0
        t = 1
        for i in range(m):
            s += c[m - i - 1] * t
            t *= 2
        recipe.append(s) 
    dp = defaultdict(int)
    dp[0] = 0
    for r in recipe:
        dp1 = defaultdict(int)
        for j, k in dp.items():
            dp1[j] = k
        for j, k in dp.items():
            dp1[j ^ r] = max(dp1[j ^ r], k + 1)
        dp = dp1
    print(dp[0])

Submission status: Accepted

Solution code:
from collections import defaultdict
def main(n, m):
    b = [int('0b' + input(), 0) for i in range(n)]
    ans = 0
    d = defaultdict(int)
    d[0] = 0
    for i in b:
        nd = defaultdict(int)
        for k, v in d.items():
            nd[k] = v
        for key, value in d.items():
            nd[key ^ i] = max(nd[key ^ i], value + 1)
        d = nd
    print(d[0])
    

if __name__ == "__main__":
    while 1:
        n,m = map(int, input().split())
        if n == 0: break
        main(n,m)

Submission status: Accepted

Solution code:
#2006_D
"""
import sys
from collections import defaultdict
def dfs(d,y,x,f):
    global ans
    if d >= 10:
        return
    f_ = defaultdict(int)
    for i in f.keys():
        f_[i] = f[i]
    for t,s in vr[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if s == x+1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t,s-1,f_)
            f_[(t,s)] = 1
            break

    for t,s in vl[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if s == x-1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t,s+1,f_)
            f_[(t,s)] = 1
            break

    for t,s in vd[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if t == y+1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t-1,s,f_)
            f_[(t,s)] = 1
            break

    for t,s in vu[(y,x)]:
        if a[t][s] == 3:
            ans = min(ans,d+1)
            break
        elif f[(t,s)]:
            if t == y-1:
                break
            f_[(t,s)] = 0
            dfs(d+1,t+1,s,f_)
            f_[(t,s)] = 1
            break
    return
while 1:
    w,h = map(int, sys.stdin.readline()[:-1].split())
    if w == h == 0:
        break
    a = [list(map(int, sys.stdin.readline()[:-1].split())) for i in range(h)]
    vr = defaultdict(list)
    vl = defaultdict(list)
    vd = defaultdict(list)
    vu = defaultdict(list)
    f = defaultdict(int)
    for y in range(h):
        for x in range(w):
            if a[y][x] == 1:
                f[(y,x)] = 1
            if a[y][x] in [1,3]:
                for x_ in range(x):
                    vr[(y,x_)].append((y,x))
            elif a[y][x] == 2:
                sy,sx = y,x
    for y in range(h):
        for x in range(w)[::-1]:
            if a[y][x] in (1,3):
                for x_ in range(x+1,w):
                    vl[(y,x_)].append((y,x))
    for x in range(w):
        for y in range(h):
            if a[y][x] in (1,3):
                for y_ in range(y):
                    vd[(y_,x)].append((y,x))
    for x in range(w):
        for y in range(h)[::-1]:
            if a[y][x] in (1,3):
                for y_ in range(y+1,h):
                    vu[(y_,x)].append((y,x))
    ind = [[[0]*4 for i in range(w)] for j in range(h)]
    ans = 11
    dfs(0,sy,sx,f)
    ans = ans if ans < 11 else -1
    print(ans)
"""

#2018_D
"""
import sys
from collections import defaultdict
sys.setrecursionlimit(1000000)

def dfs(d,s,l,v,dic):
    s_ = tuple(s)
    if dic[(d,s_)] != None:
        return dic[(d,s_)]
    if d == l:
        dic[(d,s_)] = 1
        for x in s:
            if x > (n>>1):
                dic[(d,s_)] = 0
                return 0
        return 1
    else:
        res = 0
        i,j = v[d]
        if s[i] < (n>>1):
            s[i] += 1
            res += dfs(d+1,s,l,v,dic)
            s[i] -= 1
        if s[j] < (n>>1):
            s[j] += 1
            res += dfs(d+1,s,l,v,dic)
            s[j] -= 1
        dic[(d,s_)] = res
        return res

def solve(n):
    dic = defaultdict(lambda : None)
    m = int(sys.stdin.readline())
    s = [0]*n
    f = [[1]*n for i in range(n)]
    for i in range(n):
        f[i][i] = 0
    for i in range(m):
        x,y = [int(x) for x in sys.stdin.readline().split()]
        x -= 1
        y -= 1
        s[x] += 1
        f[x][y] = 0
        f[y][x] = 0
    v = []
    for i in range(n):
        for j in range(i+1,n):
            if f[i][j]:
                v.append((i,j))
    l = len(v)
    print(dfs(0,s,l,v,dic))

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)
"""
#2011_D
"""
import sys
def dfs(s,d,f,v):
    global ans
    if ans == n-n%2:
        return
    if d > ans:
        ans = d
    for i in range(n):
        if s[i] == 0:
            for j in range(i+1,n):
                if s[j] == 0:
                    if f[i] == f[j]:
                        s[i] = -1
                        s[j] = -1
                        for k in v[i]:
                            s[k] -= 1
                        for k in v[j]:
                            s[k] -= 1
                        dfs(s,d+2,f,v)
                        s[i] = 0
                        s[j] = 0
                        for k in v[i]:
                            s[k] += 1
                        for k in v[j]:
                            s[k] += 1

def solve(n):
    p = [[int(x) for x in sys.stdin.readline().split()] for i in range(n)]
    v = [[] for i in range(n)]
    f = [0]*n
    s = [0]*n
    for i in range(n):
        x,y,r,f[i] = p[i]
        for j in range(i+1,n):
            xj,yj,rj,c = p[j]
            if (x-xj)**2+(y-yj)**2 < (r+rj)**2:
                v[i].append(j)
                s[j] += 1
    dfs(s,0,f,v)
    print(ans)
while 1:
    n = int(sys.stdin.readline())
    ans = 0
    if n == 0:
        break
    solve(n)
"""

#2003_D
"""
import sys
def root(x,par):
    if par[x] == x:
        return x
    par[x] = root(par[x],par)
    return par[x]

def unite(x,y,par,rank):
    x = root(x,par)
    y = root(y,par)
    if rank[x] < rank[y]:
        par[x] = y
    else:
        par[y] = x
        if rank[x] == rank[y]:
            rank[x] += 1

def solve(n):
    p = [[float(x) for x in sys.stdin.readline().split()] for i in range(n)]
    v = []
    for i in range(n):
        for j in range(i):
            xi,yi,zi,ri = p[i]
            xj,yj,zj,rj = p[j]
            d = max(0,((xi-xj)**2+(yi-yj)**2+(zi-zj)**2)**0.5-(ri+rj))
            v.append((i,j,d))
    par = [i for i in range(n)]
    rank = [0]*n
    v.sort(key = lambda x:x[2])
    ans = 0
    for x,y,d in v:
        if root(x,par) != root(y,par):
            unite(x,y,par,rank)
            ans += d
    print("{:.3f}".format(round(ans,3)))

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)
"""

#2009_D
"""
import sys
from heapq import heappop,heappush
from collections import defaultdict
def solve(n,m):
    s,g = [int(x) for x in sys.stdin.readline().split()]
    s -= 1
    g -= 1
    e = [[] for i in range(n)]
    for i in range(m):
        a,b,d,c = [int(x) for x in sys.stdin.readline().split()]
        a -= 1
        b -= 1
        e[a].append((b,d,c))
        e[b].append((a,d,c))
    dist = defaultdict(lambda : float("inf"))
    dist[(s,0,-1)] = 0
    q = [(0,s,0,-1)]
    while q:
        dx,x,v,p = heappop(q)
        if x == g and v == 1:
            print(dx)
            return
        for i in range(-1,2):
            v_ = v+i
            if v_ < 1 :continue
            for y,d,c in e[x]:
                if p == y:
                    continue
                if v_ > c:
                    continue
                z = d/v_
                if dx+z < dist[(y,v_,x)]:
                    dist[(y,v_,x)] = dx+z
                    heappush(q,(dist[(y,v_,x)],y,v_,x))
    print("unreachable")
    return

while 1:
    n,m = [int(x) for x in sys.stdin.readline().split()]
    if n == 0:
        break
    solve(n,m)
"""

#2016_D
"""
import sys
def solve(n):
    w = [int(x) for x in sys.stdin.readline().split()]
    dp = [[0]*(n+1) for i in range(n+1)]
    for le in range(n+1):
        for l in range(n):
            r = l+le
            if r > n:break
            if not (r-l)%2 and abs(w[l]-w[r-1]) < 2:
                if dp[l+1][r-1] == r-l-2:
                    dp[l][r] = r-l
                    continue
            for k in range(l+1,r):
                if dp[l][k] + dp[k][r] > dp[l][r]:
                    dp[l][r] = dp[l][k] + dp[k][r]
    print(dp[0][n])
while 1:
    n = int(sys.stdin.readline())
    if not n:
        break
    solve(n)
"""
#2009_D
"""
alp = list("abcdefghijklmnopqrstuvwxyz")
c = {}
key = {}
for i in range(25):
    c[alp[i]] = alp[i+1]
    key[alp[i]] = i
key["z"] = 25

def dfs(i,k,f,n):
    global ans
    if i == n:
        for j in k:
            if f[key[j]]:
                break
        else:
            ans.append(k)
    else:
        dfs(i+1,k+s[i],f,n)
        if s[i] != "z" and f[key[s[i]]+1]:
            f[key[s[i]]+1] = 0
            dfs(i+1,k+c[s[i]],f,n)
            f[key[s[i]]+1] = 1

def solve(s):
    global ans
    n = len(s)
    d = {}
    for i in s:
        d[i] = 1
    f = [1]*26
    f[0] = 0
    dfs(0,"",f,n)
    ans.sort()
    print(len(ans))
    if len(ans) < 10:
        for i in ans:
            print(i)
    else:
        for i in ans[:5]:
            print(i)
        for i in ans[-5:]:
            print(i)
while 1:
    s = input()
    ans = []
    if s == "#":
        break
    solve(s)
"""

#2004_D
"""
import sys
from collections import defaultdict
while 1:
    d = defaultdict(list)
    d_ = defaultdict(list)
    n = int(sys.stdin.readline())
    if n == 0:break
    point = [[float(x) for x in sys.stdin.readline().split()] for i in range(n)]
    ans = 1
    for i in range(n):
        p,q = point[i]
        for j in range(n):
            if i == j:continue
            s,t = point[j]
            if (p-s)**2+(q-t)**2 > 4:
                continue
            d[i].append(j)
            if j > i:
                d_[i].append(j)

    for i in range(n):
        p,q = point[i]
        for j in d_[i]:
            s,t = point[j]
            v = (t-q,p-s)
            m = ((p+s)/2,(q+t)/2)
            l = 0
            r = 10000
            while r-l > 0.0001:
                k = (l+r)/2
                a,b = m[0]+k*v[0],m[1]+k*v[1]
                if (p-a)**2+(q-b)**2 < 1:
                    l = k
                else:
                    r = k
            ans_ = 2
            for l in d[i]:
                if l == j:
                    continue
                x,y = point[l]
                if (x-a)**2+(y-b)**2 < 1:
                    ans_ += 1

            if ans_ > ans:
                ans = ans_
                if ans == n:break

            k = -k
            a,b = m[0]+k*v[0],m[1]+k*v[1]
            ans_ = 2
            for l in d[i]:
                if l == j:
                    continue
                x,y = point[l]
                if (x-a)**2+(y-b)**2 < 1:
                    ans_ += 1

            if ans_ > ans:
                ans = ans_
                if ans == n:break
        if ans == n:break
    print(ans)
"""
#2010_D
"""
import sys
from collections import defaultdict,deque
d = [(1,0),(-1,0),(0,1),(0,-1)]
def bfs(b,a,k):
    q = deque([(b,a)])
    bfs_map[b][a] = k
    g = a+0.5
    p = s[b][a]
    su = 1
    while q:
        y,x = q.popleft()
        for dy,dx in d:
            y_ = y+dy
            x_ = x+dx
            if 0 <= y_ < h and 0 <= x_ < w:
                if bfs_map[y_][x_] < 0 and s[y_][x_] == p:
                    bfs_map[y_][x_] = k
                    q.append((y_,x_))
                    g += x_+0.5
                    su += 1
    f[k] = (g,su)

def dfs(x):
    if g[x] != None:
        return g[x]
    g[x] = [f[x][0],f[x][1]]
    for y in v[x]:
        g_ = dfs(y)
        g[x][0] += g_[0]
        g[x][1] += g_[1]
    return g[x]

while 1:
    w,h = [int(x) for x in sys.stdin.readline().split()]
    if w == 0:
        break
    s = [sys.stdin.readline()[:-1] for i in range(h)]
    f = defaultdict(lambda : 0)
    bfs_map = [[-1]*w for i in range(h)]
    k = 0
    for y in range(h)[::-1]:
        for x in range(w):
            if s[y][x] != "." and bfs_map[y][x] < 0:
                bfs(y,x,k)
                k += 1

    v = [[] for i in range(k)]
    l = [float("inf")]*k
    r = [0]*k
    fl = [1]*k

    for y in range(h):
        for x in range(w):
            if bfs_map[y][x] > -1:
                b = bfs_map[y][x]
                if y == h-1 or (bfs_map[y+1][x] != b and bfs_map[y+1][x] > -1):
                    l[b] = min(l[b],x)
                    r[b] = max(r[b],x+1)
                    if y < h-1 and fl[b]:
                        v[bfs_map[y+1][x]].append(b)
                        fl[b] = 0
    g = [None]*k
    for i in range(k):
        dfs(i)
        gx = g[i][0]/g[i][1]
        if gx <= l[i] or r[i] <= gx:
            print("UNSTABLE")
            break
    else:
        print("STABLE")
"""

#2015_D
"""
import sys
def solve(n):
    p = [int(sys.stdin.readline()) for i in range(n)]
    dp = [[[-1,-1] for c in range(1000)] for i in range(n)]
    dp[-1][0] = [0,0]
    for i in range(n):
        e = -p[i]%1000
        for c in range(1000):
            if dp[i-1][c][0] != -1:
                cost = 1 if c+e > 499 else 0
                k = (c+e-500)%1000 if cost else (c+e)%1000
                if dp[i][k] < [dp[i-1][c][0]+cost,dp[i-1][c][1]-p[i]]:
                    dp[i][k] = [dp[i-1][c][0]+cost,dp[i-1][c][1]-p[i]]

                if dp[i][c] < [dp[i-1][c][0],dp[i-1][c][1]]:
                    dp[i][c] = [dp[i-1][c][0],dp[i-1][c][1]]
    ans = [0,-1]
    for i in range(1000):
        if dp[-1][i] > ans:
            ans[0] = dp[-1][i][0]
            ans[1] = dp[-1][i][1]
    print(ans[0],-ans[1])
while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    solve(n)
"""
#2017_D
import sys
from collections import defaultdict

def solve(n,m):
    b = [int(sys.stdin.readline(),2) for i in range(n)]
    if n < m:
        M = 1<<n
        ans = 0
        for i in range(M):
            k = 0
            s = 0
            for j in range(n):
                if i&(1<<j):
                    k ^= b[j]
                    s += 1
            if not k:
                if s > ans:
                    ans = s
        print(ans)
    else:
        dp = defaultdict(lambda : 0)
        dp[0] = 0
        for i in b:
            d = dp.copy()
            for j in d.keys():
                j_ = i^j
                if d[j]+1 > dp[j_]:
                    dp[j_] = d[j]+1
        print(dp[0])
while 1:
    n,m = [int(x) for x in sys.stdin.readline().split()]
    if n == 0:
        break
    solve(n,m)

Submission status: Accepted

Solution code:
# This file is a "Hello, world!" in Python language by CPython for wandbox.
iipt=lambda:int(input())
miipt=lambda:list(map(int, input().split()))
from pprint import pprint
r=[]
n=m=0
def solven(k, i):
    # k: 各材料の余ってるかどうかbit
    # i: i以降のレシピを足していこう
    # return 足せるレシピ数のmax
    if i==n:
        return -1 if k else 0
    s1=solven(k^r[i], i+1)
    if s1!=-1:
        s1+=1
    return max(s1, solven(k, i+1))


while True:
    n,m=miipt()
    if n==m==0:
        break
    r=[int(input(), 2) for i in range(n)]
    #print(r)

    if n<22:
        print(solven(0,0))
    else:
        dp={} # dp[k]=材料のあまり具合kで作れるレシピ数
        dp[0]=0
        for i in range(n):
            dp_=dp.copy()
            for k, v in dp_.items():
                if k^r[i] in dp:
                    dp[k^r[i]]=max(dp[k^r[i]], v+1)
                else:
                    dp[k^r[i]]=v+1
            #pprint(dp)
        print(dp[0])

Submission status: Accepted

Solution code:
def make(n):
    C = {0: 0}
    for i in range(n):
        b = int(input(), 2)
        for k, v in dict(C).items():
            if C.get(k^b, 0) < v+1:
                C[k^b] = v+1
    return C
def calc(P, Q):
    yield 0
    for k, v in P.items():
        if k in Q:
            yield v + Q[k]
def solve():
    while 1:
        n, m = map(int, input().split())
        if n+m == 0:
            break
        yield max(calc(make(n//2), make(n-n//2)))
print(*solve(), sep="\n")

Submission status: Runtime Error

Solution code:
while 1:
    n, m = map(int, input().split())
    if n+m == 0:
        break
    B = [int(input(),2) for i in range(n)]
    C = {0: 0}
    for b in B:
        for k, v in [*C.items()]:
            C[k^b] = max(C.get(k^b, 0), v+1)
    print(C[0])

Submission status: Runtime Error

Solution code:
a=65280; b=61680; c=52428; d=43690; e=65535
QS = [[] for i in range(17)]
QS[1] = [a, b, c, d]
L = {a: 1, b: 1, c: 1, d: 1, e: 1, e: 1, 0: 1}
H = []
get = L.get
push = H.append
for l in range(1, 16):
    Q = QS[l]
    li = 13-l; l3 = l+3; l1 = l+1
    pop = Q.pop
    pushQN = QS[l1].append
    while Q:
        p = pop()
        if L[p] < l: continue
        if l < 13:
            if l1 < get(p ^ e, 17):
                L[p ^ e] = l1
                l < 12 and pushQN(p ^ e)
            for q, r in H:
                if r < li:
                    if l3+r < get(p & q, 17): L[p & q] = l3+r; QS[l3+r].append(p & q)
                    if l3+r < get(p ^ q, 17): L[p ^ q] = l3+r; QS[l3+r].append(p ^ q)
                elif r == li:
                    if p & q not in L: L[p & q] = 16
                    if p ^ q not in L: L[p ^ q] = 16
                else: break
            l < 7 and push((p, l))
        elif l1 < get(p ^ e, 17): L[p ^ e] = l1
print(*map(L.__getitem__, eval("e&"+",e&".join(open(0).read().replace(*"-~").replace(*"*&").replace(*"1e").split()[:-1]))),sep='\n')

Submission status: Runtime Error

Solution code:
a=65280; b=61680; c=52428; d=43690; e=65535
QS = [[] for i in range(17)]
QS[1] = [a, b, c, d]
L = {a: 1, b: 1, c: 1, d: 1, e: 1, e: 1, 0: 1}
H = []
get = L.get
push = H.append
for l in range(1, 16):
    Q = QS[l]
    li = 13-l; l3 = l+3; l1 = l+1
    pop = Q.pop
    pushQN = QS[l1].append
    while Q:
        p = pop()
        if L[p] < l: continue
        if l < 13:
            if l1 < get(p ^ e, 17):
                L[p ^ e] = l1
                pushQN(p ^ e)
            for q, r in H:
                if r < li:
                    if l3+r < get(p & q, 17): L[p & q] = l3+r; QS[l3+r].append(p & q)
                    if l3+r < get(p ^ q, 17): L[p ^ q] = l3+r; QS[l3+r].append(p ^ q)
                elif r == li:
                    if p & q not in L: L[p & q] = 16
                    if p ^ q not in L: L[p ^ q] = 16
                else: break
            l < 7 and push((p, l))
        elif l1 < get(p ^ e, 17): L[p ^ e] = l1
print(*map(L.__getitem__, eval("e&"+",e&".join(open(0).read().replace(*"-~").replace(*"*&").replace(*"1e").split()[:-1]))),sep='\n')

Submission status: Runtime Error

Solution code:
import itertools

def addlist(a,b,m):
    result=[0 for i in range(m)]
    for i in range(m):
        c=a[i]+b[i]
        result[i] = c%2
    return result
def sum(b):
    result=0
    for i in b:
        result += i
    return result
def make(b,m,n,l):
    sumlist=[]
    flag=False
    p=list(itertools.combinations(b,l))
    for i in p:
        ls=[0 for i in range(m)]
        for j in list(i):
            ls=addlist(ls,j,m)
        sumlist.append(ls)
    for i in sumlist:
        s=sum(i)
        if s == 0:
            flag = True
    if flag:
        return l
    else:
        l-=1
        if l<=0:
            return 0
        else:
            return make(b,m,n,l)

if __name__ == "__main__":
    boxes=[]
    while True:
        a=list(map(int,input().split()))
        n=a[0]
        m=a[1]
        if n == 0 and m == 0:
            break
        else: 
            b=[]
            for i in range(n):
                num=[]
                tmp=int(input())
                for j in range(m):    
                    num.append(tmp%10)
                    tmp = tmp//10
                num.reverse()
                b.append(num)
            boxes.append(make(b,m,n,n))
    for i in boxes:
        print(i)

Submission status: Runtime Error

Solution code:
import itertools

def addlist(a,b,m):
    result=[0 for i in range(m)]
    for i in range(m):
        c=a[i]+b[i]
        result[i] = c%2
    return result
def sum(b):
    result=0
    for i in b:
        result += i
    return result


def make(b,m,n,l):
    sumlist=[]
    flag=False
    p=list(itertools.combinations(b,l))
    for i in p:
        ls=[0 for i in range(m)]
        for j in list(i):
            ls=addlist(ls,j,m)
        sumlist.append(ls)
    for i in sumlist:
        s=sum(i)
        if s == 0:
            flag = True
    if flag:
        return l
    else:
        l-=1
        if l<=0:
            return 0
        else:
            return make(b,m,n,l)

if __name__ == "__main__":
    boxes=[]
    while True:
        a=list(map(int,input().split()))
        n=a[0]
        m=a[1]
        if n == 0 and m == 0:
            break
        else: 
            b=[]
            for i in range(n):
                num=[]
                tmp=int(input())
                for j in range(m):    
                    num.append(tmp%10)
                    tmp = tmp//10
                num.reverse()
                b.append(num)
            boxes.append(make(b,m,n,n))
    
    for i in boxes:
        print(i)