Problem:
Score : 800 points

Problem Statement

There is a square grid with N rows and M columns.
Each square contains an integer: 0 or 1. The square at the i-th row from the top and the j-th column from the left contains a_{ij}.

Among the 2^{N+M} possible pairs of a subset A of the rows and a subset B of the columns, find the number of the pairs that satisfy the following condition, modulo 998244353:

The sum of the |A||B| numbers contained in the intersection of the rows belonging to A and the columns belonging to B, is odd.

Constraints

1 \leq N,M \leq 300

0 \leq a_{i,j} \leq 1(1\leq i\leq N,1\leq j\leq M)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
a_{11} ... a_{1M}
:
a_{N1} ... a_{NM}

Output

Print the number of the pairs of a subset of the rows and a subset of the columns that satisfy the condition, modulo 998244353.

Sample Input 1

2 2
0 1
1 0

Sample Output 1

6

For example, if A consists of the first row and B consists of both columns, the sum of the numbers contained in the intersection is 0+1=1.

Sample Input 2

2 3
0 0 0
0 1 0

Sample Output 2

8

Solution in Python (3.4.3) (judge verdict: Wrong Answer)

import numpy as np
n, m = map(int, input().split())
f = n * m > 998244353
lis = []
for i in range(n):
  lis.append(list(map(int, input().split())))
arr = np.array(lis)
cache_dict = {}

def search(base, x1, x2, y1, y2):
  use_arr = arr[x1:x2+1, y1:y2+1]
  return (base + use_arr.sum()) % 2

def rec_search(base, x1, x2, y1, y2):
  cache_dict[(x1, x2, y1, y2)] = base
  if x1-1 >= 0:
    arg1 = (x1-1, x2, y1, y2)
    if not arg1 in cache_dict:
      next_base = search(base, x1-1, x1-1, y1, y2)
      cache_dict[arg1] = next_base
      rec_search(next_base, x1-1, x2, y1, y2)
  if x2+1 <= m-1:
    arg2 = (x1, x2+1, y1, y2)  
    if not arg2 in cache_dict:
      next_base = search(base, x2+1, x2+1, y1, y2)
      cache_dict[arg2] = next_base
      rec_search(next_base, x1, x2+1, y1, y2)
  if y1 - 1 >= 0:
    arg3 = (x1, x2, y1-1, y2)  
    if not arg3 in cache_dict:
      next_base = search(base, x1, x2, y1-1, y1-1)
      cache_dict[arg3] = next_base
      rec_search(next_base, x1, x2, y1-1, y2)
  if y2 + 1 <= n-1:
    arg4 = (x1, x2, y1, y2+1)  
    if not arg4 in cache_dict:
      next_base = search(base, x1, x2, y2+1, y2+1)
      cache_dict[arg4] = next_base
      rec_search(next_base, x1, x2, y1, y2+1)

point_1 = np.where(arr==1)
for ind in zip(point_1[0], point_1[1]):
  cache_dict[(ind[1], ind[1], ind[0], ind[0])] = 1
  rec_search(1, ind[1], ind[1], ind[0], ind[0])
print(sum(cache_dict.values()) % 998244353)