Orig Description
Score : 800 points
Problem StatementThere 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.
InputInput is given from Standard Input in the following format:
N M
a_{11} ... a_{1M}
:
a_{N1} ... a_{NM}
OutputPrint 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 12 2
0 1
1 0
Sample Output 16
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 22 3
0 0 0
0 1 0
Sample Output 28
Extracted Specification
An integer N (1 ≤ N ≤ 300), representing some quantity or size.
An integer M (1 ≤ M ≤ 300), representing another quantity or size.
A 2D list of integers A of size NxM, where each integer is either 0 or 1.
### Example Input:
```
2 2
0 1
1 0
```
### Function Signature:
Write a function f(N, M, A) that takes in the input.
def f(N: int, M: int, A: List[List[int]]):
'''
N: an integer
M: an integer
A: a 2D list of integers
'''
Test Case Generator
Certainly! To generate test cases for the given problem, we can create a function that generates random values for \( N \) and \( M \), and then fills the grid with random 0s and 1s. Here's a sample test case generator for the given problem statement:
```python
import random
def tcgen():
# Define the constraints
N = random.randint(1, 300)
M = random.randint(1, 300)
# Generate the grid with random 0s and 1s
grid = []
for _ in range(N):
row = [random.randint(0, 1) for _ in range(M)]
grid.append(row)
return N, M, grid
# Example usage
N, M, grid = tcgen()
print(N, M)
for row in grid:
print(' '.join(map(str, row)))
```
### Explanation:
1. **Constraints**: We generate \( N \) and \( M \) within the allowed range [1, 300].
2. **Grid Generation**: We create a grid of size \( N \times M \) where each cell contains either 0 or 1, chosen randomly.
3. **Output**: The function returns \( N \), \( M \), and the generated grid.
### Example Output:
Here’s an example of what the output might look like when you run the generator:
```
3 4
1 0 1 1
0 1 0 0
1 1 0 1
```
You can use this output to manually check or integrate with your testing framework to validate the solutions for the problem statement.
### Note:
- The printed output format follows the one expected by the problem statement.
- You can run the `tcgen()` function multiple times to generate multiple test cases.
Extract Arguments
def extract_arguments(fh):
N, M = map(int, fh.readline().strip().split())
grid = []
for _ in range(N):
row = list(map(int, fh.readline().strip().split()))
grid.append(row)
return N, M, grid