#include <iostream>
#include <tuple>
#include <cmath>
#include <string>
#include <cstring>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <random>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <vector>
#include <fstream>
#include <iomanip>
#include <ctime>
#include <cctype>
#include <climits>
#include <chrono>
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector< vector <int> > vvi;
typedef pair<int, int> pii;
typedef pair < pair < int, int >, int > piii;
typedef pair < pair <int, int > , pair <int, int> > piiii;
typedef pair<ll, ll> pll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
 
#define FOR(i,a,b) for(int i = a; i < b; i ++)
#define RFOR(i,a,b) for(int i = a-1; i >= b; i --)
#define all(a) a.begin(), a.end()
//#define endl '\n';
#define sz(x) (int)(x).size()
 
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
 
template <typename T>
void pr(vector<T> &v) {
    FOR(i, 0, sz(v)) cout << v[i] << " ";
    cout << endl;
}
template <typename T>
void pr(vector<vector<T> > &v) {
    FOR(i, 0, sz(v)) { pr(v[i]); }
}
template <typename T>
void re(T &x) {
    cin >> x;
}
template <typename T>
void re(vector<T> &a) {
    FOR(i, 0, sz(a)) re(a[i]);
}
template <class Arg, class... Args>
void re(Arg &first, Args &... rest) {
    re(first);
    re(rest...);
}
template <typename T>
void pr(T x) {
    cout << x << endl;
}
template <class Arg, class... Args>
void pr(const Arg &first, const Args &... rest) {
    cout << first << " ";
    pr(rest...);
    cout << endl;
}
void ps() { cout << endl; }
template<class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
    cout << t; if (sizeof...(ts)) cout << " "; ps(ts...);
}
 
const ll MOD  =  998244353;
#define inf 1e18;
#define INF INT_MAX

long double PI = 4*atan(1);
long double eps = 1e-16;

class UnionFind {
    private:
        vi p, siz;
        int numSets;
    public:
        UnionFind(int N) {
            p.assign(N, 0); FOR(i,0,N) p[i] = i;
            siz.assign(N,1);
            numSets = N;
        }

        int findSet(int i) {
            return (p[i] == i) ? i : (p[i] = findSet(p[i]));
        }
        bool isSameSet(int i, int j) {
            return findSet(i) == findSet(j);
        }
        int numDisjointSets() {
            return numSets;
        }
        int sizeOfSet(int i) {
            return siz[findSet(i)];
        }

        void unionset(int i, int j) {
            if(isSameSet(i,j)) return;

            int x = findSet(i), y = findSet(j);
            if(siz[x] <= siz[y]) {
                p[x] = p[y];
                siz[y] += siz[x];
            }
            else {
                p[y] = p[x];
                siz[x] += siz[y];
            }
            numSets--;
            return;
        }
};


bool check(vvi &g, int n, int m) {
    int num0 = 0;
    FOR(i,0,n) FOR(j,0,m) num0 += (g[i][j] == 0);
    UnionFind uf(n * m);
    int dr[4] = {1,-1,0,0};
    int dc[4] = {0,0,1,-1};

    FOR(i,0,n) {
        FOR(j,0,m) {
            if(g[i][j] == 1) {
                FOR(k,0,4) {
                    int ni = i + dr[k];
                    int nj = j + dc[k];
                    if(ni >= 0 && ni < n && nj >= 0 && nj < m && g[ni][nj] == 1) {
                        int c = m * i + j;
                        int nc = m * ni + nj;
                        uf.unionset(c, nc);
                    }
                }
            }
        }
    }
    // pr(g);
    // cout << uf.numDisjointSets() << " " << num0 + 1 << endl;
    return (uf.numDisjointSets() == num0 + 1);
}

void solve() {
    int n,m; cin >> n >> m;
    vvi g(n, vi(m, 1));
    int bestcnt = 0;
    if(max(n,m) < 4) {
        bestcnt = n * m;
        FOR(i,0,n) FOR(j,0,m) g[i][j] = 1;
    }
    else if(min(n,m) == 2) {
        bestcnt = n * m;
        if(n < m) {
            FOR(j,0,m) if(j % 4 == 3) {g[0][j] = 0; bestcnt--;}
            FOR(j,0,m) if(j % 4 == 1) {g[1][j] = 0; bestcnt--;}
        } else {
            FOR(i,0,n) if(i % 4 == 3) {g[i][0] = 0; bestcnt--;}
            FOR(i,0,n) if(i % 4 == 1) {g[i][1] = 0; bestcnt--;}
        }
    } else if(min(n,m) == 3) {
        bestcnt = n * m;
        if(n < m) {
            FOR(j,0,m) if(j % 4 == 3) {g[0][j] = 0; bestcnt--;}
            FOR(j,0,m) if(j % 4 == 1) {g[1][j] = 0; bestcnt--;}
            FOR(j,0,m) if(j % 4 == 3) {g[2][j] = 0; bestcnt--;}
        } else {
            FOR(i,0,n) if(i % 4 == 3) {g[i][0] = 0; bestcnt--;}
            FOR(i,0,n) if(i % 4 == 1) {g[i][1] = 0; bestcnt--;}
            FOR(i,0,n) if(i % 4 == 3) {g[i][2] = 0; bestcnt--;}
        }
    } else {
        
        vi perm = {0,1,2,3};
        do {
            vvi gt(n, vi(m, 1));
            int ans = n * m;
            FOR(i,0,n) {
                FOR(j,0,m) {
                    if((j % 4) == perm[i % 4])  {
                        gt[i][j] = 0; ans--;
                    }
                }
            }
            if(ans > bestcnt) {
                if(check(gt, n, m)) {
                    bestcnt = ans;
                    g = gt;
                }
            }
            
        } while (next_permutation(all(perm)));
    }
    
    cout << bestcnt << endl;
    FOR(i,0,n) {
        FOR(j,0,m) cout << g[i][j];
        cout << endl;
    }



}

int main() {
    auto start = chrono::high_resolution_clock::now();
    // ios_base::sync_with_stdio(0);cin.tie(0);
    //ofstream cout("output.txt");
    //ifstream cin("input.txt");
    #ifdef DEBUG
      freopen("input.txt", "r", stdin);
      freopen("output.txt", "w", stdout);
    #endif  
    
    int t; cin >> t;
    FOR(tcase,0,t) {
        solve();
    }

    // auto stop = chrono::high_resolution_clock::now();
    // auto duration = chrono::duration_cast<chrono::microseconds>(stop - start);
    // cout << duration.count() << endl;
    //cin.close();
    //cout.close();
}