#include <bits/stdc++.h>

using i64 = long long;

std::vector<std::vector<int>> transpose(const std::vector<std::vector<int>> &a) {
    if (a.empty()) {
        return {};
    }
    int n = a.size(), m = a[0].size();
    std::vector<std::vector<int>> b(m, std::vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            b[j][i] = a[i][j];
        }
    }
    return b;
}

std::vector<std::vector<int>> get(int n, int m) {
    if (n * m % 2 == 1) {
        return {};
    }
    std::vector a(n, std::vector<int>(m));
    int tot = 0;
    auto work = [&](int u, int d, int l, int r) {
        while (u < d && l < r) {
            for (int i = l; i < r; i += 2) {
                if (u >= 0) {
                    a[u][i] = a[u][i + 1] = ++tot;
                }
                if (d <= n) {
                    a[d - 1][i] = a[d - 1][i + 1] = ++tot;
                }
            }
            u++, d--;
            for (int i = u; i < d; i += 2) {
                a[i][l] = a[i + 1][l] = ++tot;
                a[i][r - 1] = a[i + 1][r - 1] = ++tot;
            }
            l++, r--;
        }
    };
    if (n <= m) {
        if (n % 2 == 0) {
            for (int k = 1; ; k++) {
                int L = (n - 2) * k + k - 1;
                if (L > m) {
                    break;
                }
                int R = L + 2 + 2 * k;
                if (m <= R) {
                    int lng = std::min(k, (m - L) / 2);
                    int sht = k - lng;
                    int bnd = m - L - 2 * lng;
                    int l = 0;
                    if (bnd) {
                        bnd--;
                        for (int i = 0; i < n; i += 2) {
                            a[i][l] = a[i + 1][l] = ++tot;
                        }
                        l++;
                    }
                    for (int j = 0; j < k; j++) {
                        if (j) {
                            for (int i = 0; i < n; i += 2) {
                                a[i][l] = a[i + 1][l] = ++tot;
                            }
                            l++;
                        }
                        if (lng) {
                            lng--;
                            work(0, n, l, l + n);
                            l += n;
                        } else {
                            sht--;
                            work(0, n, l, l + n - 2);
                            l += n - 2;
                        }
                    }
                    if (bnd) {
                        bnd--;
                        for (int i = 0; i < n; i += 2) {
                            a[i][l] = a[i + 1][l] = ++tot;
                        }
                        l++;
                    }
                    return a;
                }
            }
        } else {
            for (int k = 1; ; k++) {
                int L = (n - 1) * k;
                if (L > m) {
                    break;
                }
                int R = L + 2 * k;
                if (m <= R) {
                    int lng = (m - L) / 2;
                    int sht = k - lng;
                    int l = 0;
                    for (int j = 0; j < k; j++) {
                        if (lng) {
                            lng--;
                            if (j % 2) {
                                work(-1, n, l, l + n + 1);
                            } else {
                                work(0, n + 1, l, l + n + 1);
                            }
                            l += n + 1;
                        } else {
                            sht--;
                            if (j % 2) {
                                work(-1, n, l, l + n - 1);
                            } else {
                                work(0, n + 1, l, l + n - 1);
                            }
                            l += n - 1;
                        }
                    }
                    return a;
                }
            }
        }
    } else {
        return transpose(get(m, n));
    }
    return {};
}

void solve() {
    int n, m;
    std::cin >> n >> m;
    
    auto ans = get(n, m);
    if (ans.empty()) {
        std::cout << "Impossible!\n";
        return;
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            std::cout << ans[i][j] << " \n"[j == m - 1];
        }
    }
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < m - 1; j++) {
            assert(ans[i][j] == ans[i][j + 1] || ans[i][j + 1] == ans[i + 1][j + 1] || ans[i + 1][j + 1] == ans[i + 1][j] || ans[i + 1][j] == ans[i][j]);
        }
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t;
    std::cin >> t;
    
    while (t--) {
        solve();
    }
    
    return 0;
}