/*
    author:  Maksim1744
    created: 28.03.2024 13:03:11
*/

#include "bits/stdc++.h"

using namespace std;

using ll = long long;
using ld = long double;

#define mp   make_pair
#define pb   push_back
#define eb   emplace_back

#define sum(a)     ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)    (*min_element((a).begin(), (a).end()))
#define maxe(a)    (*max_element((a).begin(), (a).end()))
#define mini(a)    ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)    ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

template<typename T>             vector<T>& operator--            (vector<T> &v){for (auto& i : v) --i;            return  v;}
template<typename T>             vector<T>& operator++            (vector<T> &v){for (auto& i : v) ++i;            return  v;}
template<typename T>             istream& operator>>(istream& is,  vector<T> &v){for (auto& i : v) is >> i;        return is;}
template<typename T>             ostream& operator<<(ostream& os,  vector<T>  v){for (auto& i : v) os << i << ' '; return os;}
template<typename T, typename U> pair<T,U>& operator--           (pair<T, U> &p){--p.first; --p.second;            return  p;}
template<typename T, typename U> pair<T,U>& operator++           (pair<T, U> &p){++p.first; ++p.second;            return  p;}
template<typename T, typename U> istream& operator>>(istream& is, pair<T, U> &p){is >> p.first >> p.second;        return is;}
template<typename T, typename U> ostream& operator<<(ostream& os, pair<T, U>  p){os << p.first << ' ' << p.second; return os;}
template<typename T, typename U> pair<T,U> operator-(pair<T,U> a, pair<T,U> b){return mp(a.first-b.first, a.second-b.second);}
template<typename T, typename U> pair<T,U> operator+(pair<T,U> a, pair<T,U> b){return mp(a.first+b.first, a.second+b.second);}
template<typename T, typename U> void umin(T& a, U b){if (a > b) a = b;}
template<typename T, typename U> void umax(T& a, U b){if (a < b) a = b;}

#ifdef HOME
#define SHOW_COLORS
#include "/mnt/c/Libs/tools/print.cpp"
#else
#define show(...) void(0)
#define debugf(fun)   fun
#define debugv(var)   var
#define mclock    void(0)
#define shows     void(0)
#define debug  if (false)
#define OSTREAM(...)    ;
#define OSTREAM0(...)   ;
#endif

template<class Fun>
class y_combinator_result {
    Fun fun_;
public:
    template<class T>
    explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}

    template<class ...Args>
    decltype(auto) operator()(Args &&...args) {
        return fun_(std::ref(*this), std::forward<Args>(args)...);
    }
};
template<class Fun>
decltype(auto) y_combinator(Fun &&fun) {
    return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}
// auto gcd = std::y_combinator([](auto gcd, int a, int b) -> int {
//     return b == 0 ? a : gcd(b, a % b);
// });

namespace grid_iterator_ns {
const array<pair<int, int>, 8> dirs = {{{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}}};
struct GridIterator {
    int n, m;
    GridIterator(int n, int m) : n(n), m(m) {}

    template<size_t N>
    struct NeighbourIteratorContainer {
        int i, j, n, m;
        NeighbourIteratorContainer(int i, int j, int n, int m) : i(i), j(j), n(n), m(m) {}

        struct NeighbourIterator {
            int cur;
            int i, j, n, m;
            NeighbourIterator(int cur, int i, int j, int n, int m) : cur(cur), i(i), j(j), n(n), m(m) {
                skip_to_first_allowed();
            }

            void skip_to_first_allowed() {
                while (cur < N &&
                    (i + dirs[cur].first  < 0 || i + dirs[cur].first  >= n ||
                     j + dirs[cur].second < 0 || j + dirs[cur].second >= m)) {
                    ++cur;
                }
            }

            NeighbourIterator& operator ++ () {
                ++cur;
                skip_to_first_allowed();
                return *this;
            }

            pair<int, int> operator * () const { return {i + dirs[cur].first, j + dirs[cur].second}; }

            bool operator == (const NeighbourIterator& other) const { return cur == other.cur; }
        };

        auto begin() const { return NeighbourIterator(0, i, j, n, m); }
        auto end()   const { return NeighbourIterator(N, i, j, n, m); }

        auto collect() const {
            vector<pair<int, int>> result;
            for (auto it = begin(); it != end(); ++it) result.push_back(*it);
            return result;
        }
    };

    template<size_t N>
    auto iterate(int i, int j) const {
        static_assert(N == 4 || N == 8, "you can remove this, but make sure you understand what you are doing");
        return NeighbourIteratorContainer<N>(i, j, n, m);
    }
};
}
using grid_iterator_ns::GridIterator;

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

    auto build = [&](int n, int m) {
        bool sw = false;
        if (n > m) {
            swap(n, m);
            sw = true;
        }
        GridIterator gi(n, m);
        vector<vector<int>> a(n, vector<int>(m));

        if ((n <= 3 && m <= 3) || (n == 3 && m == 4)) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m && j < 3; ++j) {
                    a[i][j] = 1;
                }
            }
        } else if (n == 1) {
            for (int j = 0; j < m && j < 3; ++j) {
                a[0][j] = 1;
            }
        } else if (n == 2) {
            for (int j = 0; j < m; ++j) {
                a[0][j] = (j % 4 != 3);
                a[1][j] = (j % 4 != 1);
            }
        } else if (n == 3) {
            for (int j = 0; j < m; ++j) {
                a[0][j] = (j % 4 != 3);
                a[1][j] = (j % 4 != 1);
                a[2][j] = (j % 4 != 3);
            }
        } else {
            vector<int> bestp;
            int bestsh = -1;
            int bestans = -1;
            vector<int> p(4);
            iota(p.begin(), p.end(), 0);
            do {
                if (is_sorted(p.begin() + 1, p.end())) continue;
                if (is_sorted(p.rbegin(), p.rend() - 1)) continue;
                for (int sh0 = 0; sh0 < 4; ++sh0) {
                    auto shat = [&](int i) {
                        int sh = sh0 + p[(i % 4)];
                        sh %= 4;
                        return sh;
                    };
                    auto is0 = [&](int i, int j) {
                        return j % 4 == shat(i);
                    };
                    auto chck = [&](int i, int j) {
                        for (auto [x, y] : gi.iterate<4>(i, j)) {
                            if (!is0(x, y)) return true;
                        }
                        return false;
                    };
                    if (!chck(0, 0)) continue;
                    if (!chck(0, m - 1)) continue;
                    if (!chck(n - 1, 0)) continue;
                    if (!chck(n - 1, m - 1)) continue;
                    int cur = 0;
                    for (int i = 0; i < n; ++i) {
                        int sh = shat(i);
                        cur += m - (m - sh + 3) / 4;
                    }
                    if (cur > bestans) {
                        bestp = p;
                        bestans = cur;
                        bestsh = sh0;
                    }
                }
            } while (next_permutation(p.begin() + 1, p.end()));
            for (int i = 0; i < n; ++i) {
                int sh = bestsh + bestp[(i % 4)];
                sh %= 4;
                for (int j = 0; j < m; ++j) {
                    a[i][j] = (j % 4 != sh);
                }
            }
        }

        vector<vector<bool>> u(n, vector<bool>(m, false));

        auto conn = [&]() {
            int ones = 0;
            pair<int, int> one = {-1, -1};
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    if (a[i][j]) {
                        ++ones;
                        one = {i, j};
                    }
                    u[i][j] = false;
                }
            }

            if (one.first == -1) {
                return true;
            }
            u[one.first][one.second] = true;
            queue<pair<int, int>> q;
            q.push(one);
            --ones;
            while (!q.empty()) {
                auto [i, j] = q.front();
                q.pop();
                for (auto [x, y] : gi.iterate<4>(i, j)) {
                    if (a[x][y] && !u[x][y]) {
                        --ones;
                        u[x][y] = true;
                        q.emplace(x, y);
                    }
                }
            }
            assert(ones >= 0);
            return ones == 0;
        };
        if (!conn()) {
            show(a);
            assert(false);
        }

        if (sw) {
            vector<vector<int>> b(m, vector<int>(n));
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    b[j][i] = a[i][j];
                }
            }
            swap(a, b);
        }
        return a;
    };

    array<array<char, 20>, 20> mema;
    auto slow = [&](int n, int m) {
        if (n == 0 || m == 0) return 0;
        array<array<char, 20>, 20> a;
        array<array<char, 20>, 20> u;
        GridIterator gi(n, m);
        int ans = 0;
        auto conn = [&]() {
            int ones = 0;
            pair<int, int> one = {-1, -1};
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    if (a[i][j]) {
                        ++ones;
                        one = {i, j};
                    }
                    u[i][j] = false;
                }
            }

            if (one.first == -1) {
                return true;
            }
            u[one.first][one.second] = true;
            queue<pair<int, int>> q;
            q.push(one);
            --ones;
            while (!q.empty()) {
                auto [i, j] = q.front();
                q.pop();
                for (auto [x, y] : gi.iterate<4>(i, j)) {
                    if (a[x][y] && !u[x][y]) {
                        --ones;
                        u[x][y] = true;
                        q.emplace(x, y);
                    }
                }
            }
            assert(ones >= 0);
            return ones == 0;
        };
        y_combinator([&](auto calc, int i, int j, int cur) -> void {
            if (j == m) {
                j = 0;
                ++i;
            }
            if (i == n) {
                if (cur > ans && conn()) {
                    ans = cur;
                }
                return;
            }
            int upb = cur + (n - i - 1) * (m / 4 * 3 + m % 4) + ((m - j) / 4 * 3 + (m - j) % 4);
            if (upb <= ans) return;
            for (int b : {1, 0}) {
                if (b) {
                    if (i >= 3 && a[i - 1][j] && a[i - 2][j] && a[i - 3][j]) continue;
                    if (j >= 3 && a[i][j - 1] && a[i][j - 2] && a[i][j - 3]) continue;
                }
                a[i][j] = b;
                calc(i, j + 1, cur + b);
            }

        })(0, 0, 0);
        return ans;
    };

    auto shifts = [&](int n, int m) {
        if (min(n, m) == 0) return 0;
        if (min(n, m) == 1) return min(max(n, m), 3);
        array<array<char, 20>, 20> a;
        array<array<char, 20>, 20> u;
        GridIterator gi(n, m);
        int ans = 0;
        auto conn = [&]() {
            int ones = 0;
            pair<int, int> one = {-1, -1};
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    if (a[i][j]) {
                        ++ones;
                        one = {i, j};
                    }
                    u[i][j] = false;
                }
            }

            if (one.first == -1) {
                return true;
            }
            u[one.first][one.second] = true;
            queue<pair<int, int>> q;
            q.push(one);
            --ones;
            while (!q.empty()) {
                auto [i, j] = q.front();
                q.pop();
                for (auto [x, y] : gi.iterate<4>(i, j)) {
                    if (a[x][y] && !u[x][y]) {
                        --ones;
                        u[x][y] = true;
                        q.emplace(x, y);
                    }
                }
            }
            assert(ones >= 0);
            return ones == 0;
        };
        // if (n > m) swap(n, m);
        y_combinator([&](auto calc, int i, int cur) -> void {
            if (i == n) {
                if (cur > ans && conn()) {
                    ans = max(ans, cur);
                    mema = a;
                }
                return;
            }
            for (int shift = 0; shift < 4; ++shift) {
                bool ok = true;
                int here = 0;
                for (int j = 0; j < m; ++j) {
                    a[i][j] = (j % 4 != shift);
                    here += a[i][j];
                    if (a[i][j]) {
                        if (i >= 3 && a[i - 1][j] && a[i - 2][j] && a[i - 3][j]) ok = false;
                        if (j >= 3 && a[i][j - 1] && a[i][j - 2] && a[i][j - 3]) ok = false;
                        if (!ok) break;
                    }
                }
                if (!ok) continue;
                calc(i + 1, cur + here);
            }
        })(0, 0);
        return ans;
    };

    int t;
    cin >> t;
    while (t--) {
        int n, m;
        cin >> n >> m;
        auto v = build(n, m);
        int c = 0;
        for (auto& x : v)
            c += sum(x);
        cout << c << '\n';
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                cout << v[i][j];
            }
            cout << '\n';
        }
    }
    // for (int n = 1; n <= 30; ++n) {
    //     for (int m = 1; m <= 30; ++m) {
    //         build(n, m);
    //     }
    // }
    // const int N = 10;
    // vector<vector<int>> v1;
    // vector<vector<int>> v2;
    // {

    //     vector<vector<int>> v(N + 1, vector<int>(N + 1));
    //     for (int i = 0; i <= N; ++i) {
    //         for (int j = i; j <= N; ++j) {
    //             if (i * j < 50)
    //                 v[i][j] = v[j][i] = shifts(i, j);
    //         }
    //         cout << v[i] << endl;
    //     }
    //     cout << endl;
    //     v1 = v;
    // }
    // {
    //     vector<vector<int>> v(N + 1, vector<int>(N + 1));
    //     for (int i = 0; i <= N; ++i) {
    //         for (int j = i; j <= N; ++j) {
    //             if (i * j < 50)
    //                 v[i][j] = v[j][i] = slow(i, j);
    //         }
    //         cout << v[i] << endl;
    //         assert(v[i] == v1[i]);
    //     }
    //     v2 = v;

    //     for (int i = 0; i < N; ++i) {
    //         for (int j = 0; j < N; ++j) {
    //             if (i * j >= 50) continue;
    //             cerr << i << ' ' << j << endl;
    //             cerr << v[i][j] << endl;
    //             auto b = build(i, j);
    //             int h = 0;
    //             for (auto& v : b) {
    //                 for (auto x : v) {
    //                     cerr << x;
    //                     h += x;
    //                 }
    //                 cerr << endl;
    //             }
    //             cerr << endl;
    //             if (h != v[i][j]) {
    //                 cerr << h << ' ' << v[i][j] << endl;
    //                 shifts(i, j);
    //                 for (int x = 0; x < i; ++x) {
    //                     for (int y = 0; y < j; ++y) {
    //                         cerr << (int)mema[x][y];
    //                     }
    //                     cerr << endl;
    //                 }
    //             }
    //             assert(h == v[i][j]);
    //         }
    //     }
    // }

    // assert(v1 == v2);
    // for (auto& x : v)
    //     cout << x << endl;

    return 0;
}