<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

361. National Flag
Time limit per test: 0.25 second(s)
Memory limit: 65536 kilobytes
input: standard
output: standard



Series of bloody civil wars in Berland finished! After the long-awaited reunion it was decided to create new Berland flag. Berland Heraldic Council proposed following requirements:

1. Berland flag must be a rectangle of Nx M cells. Each cell must be painted with blue or red;

2. any 3x 2 or 2x 3 rectangle of the flag must have exactly two blue cells;

3. blue paint is very expensive, so the number of blue cells should as low as possible.

Write a program that creates Berland flag.

Input
Input file contains two integer numbers N and M (3 ≤ N, M ≤ 200) separated by a space.

Output
Print to the output file N lines with M characters on each line: j-th character on the i-th line must be 0 (zero) if the cell (i, j) painted with read, and "#" if it is blue. If there are several solutions output any of them. Print "No solution" (without quotes) if there is no solution.

Example(s)
sample input
sample output
3 3
#00 
00# 
0#0

<|response|>
1. Abridged Problem Statement  
Given integers N, M (3 ≤ N, M ≤ 200), color each cell of an N×M grid either red (‘0’) or blue (‘#’) so that every 3×2 or 2×3 sub‐rectangle contains exactly two blue cells. Among all valid colorings, use as few blue cells as possible. Print any one such coloring, or “No solution” if none exists.

2. Key Observations  
- If you number the rows and columns from 0, then in any 3×2 or 2×3 block the six cells have exactly two occurrences of each residue class mod 3 of (row+column).  
- Therefore, a pattern that paints exactly those cells blue for which (i + j + offset) mod 3 = 0 automatically satisfies the local constraint (every 3×2 or 2×3 contains exactly two blues).  
- There are three choices of offset (0,1,2). Each yields about ⌈N·M/3⌉ blue cells, but due to edges one offset may have slightly fewer blues than the others. We can try all three and pick the best.

3. Full Solution Approach  
a. Read N, M.  
b. For each offset in {0,1,2}:  
   i.   Count how many cells (i,j) in the N×M grid satisfy (i + j + offset) % 3 == 0.  
c. Pick the offset that gives the smallest count of blue cells.  
d. Construct the grid: for each cell (i,j), if (i + j + best_offset) % 3 == 0 print ‘#’, else print ‘0’.  
e. Output the grid.  

Time Complexity: O(3·N·M) = O(N·M), easily fits N,M ≤ 200.

4. C++ Implementation
```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n, m;

void read() { cin >> n >> m; }

void solve() {
    // Try all 3 possible diagonal patterns (offset 0, 1, 2)
    // Each pattern creates diagonal lines with period 3
    int min_count = INT_MAX;
    int best_offset = 0;

    // Test each of the 3 possible diagonal offsets
    for(int offset = 0; offset < 3; offset++) {
        int count = 0;

        // Count how many '#' symbols this offset would create
        for(int i = 0; i < n; i++) {
            // For row i, place '#' at columns: (i + offset) % 3, (i + offset) %
            // 3 + 3, (i + offset) % 3 + 6, ... This creates a diagonal pattern
            // with period 3
            for(int j = (i + offset) % 3; j < m; j += 3) {
                count++;
            }
        }

        // Keep track of the offset that minimizes the number of '#' symbols
        if(count < min_count) {
            min_count = count;
            best_offset = offset;
        }
    }

    // Create the grid using the best offset pattern
    // Use vector of strings for cleaner memory management
    vector<string> grid(n, string(m, '0'));

    // Fill the grid with '#' symbols using the optimal diagonal pattern
    for(int i = 0; i < n; i++) {
        // Place '#' at positions following the diagonal pattern
        for(int j = (i + best_offset) % 3; j < m; j += 3) {
            grid[i][j] = '#';
        }
    }

    // Output the resulting grid
    for(int i = 0; i < n; i++) {
        cout << grid[i] << endl;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

5. Python Implementation with Detailed Comments  
```python
import sys
def main():
    input = sys.stdin.readline
    N, M = map(int, input().split())

    best_offset = 0
    min_blue = N * M + 1  # larger than any possible count

    # Determine which offset yields the fewest blue cells
    for offset in range(3):
        count_blue = 0
        for i in range(N):
            for j in range(M):
                if (i + j + offset) % 3 == 0:
                    count_blue += 1
        if count_blue < min_blue:
            min_blue = count_blue
            best_offset = offset

    # Construct and print the flag
    # Blue ('#') where (i+j+best_offset)%3==0, else Red ('0')
    for i in range(N):
        row = []
        for j in range(M):
            if (i + j + best_offset) % 3 == 0:
                row.append('#')
            else:
                row.append('0')
        print(''.join(row))

if __name__ == "__main__":
    main()
```