/*
    author:  Maksim1744
    created: 13.07.2024 17:04:45
*/

#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

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;

void test_case(int test) {
    int n, m, kk;
    cin >> n >> m >> kk;
    if (n == 2 && m == 2 && kk == 2) {
        cout << "10\n01\n";
        return;
    }
    // for (int n = 2; n <= 20; ++n)
    // for (int m = 2; m <= 20; ++m)
    // for (int kk = 0; kk <= n * m; ++kk)

    {
        int k = kk;
        int white = 0;
        int black = 1;
        if (k * 2 > n * m) {
            swap(white, black);
            k = n * m - k;
        }
        vector<vector<int>> v(n, vector<int>(m, white));
        vector<vector<pair<int, int>>> byd(n + m - 1);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                byd[i + j].eb(i, j);
            }
        }
        int fr = 0;
        for (int i = 0; i < byd.size(); ++i) {
            if (byd[i].size() <= k) {
                for (auto [x, y] : byd[i]) {
                    v[x][y] = black;
                    --k;
                }
                fr = i;
            } else {
                break;
            }
        }
        for (int i = (int)byd.size() - 1; i > fr + 2; --i) {
            if (byd[i].size() <= k) {
                for (auto [x, y] : byd[i]) {
                    v[x][y] = black;
                    --k;
                }
            } else {
                break;
            }
        }

        GridIterator gi(n, m);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (v[i][j] == black) continue;
                if (k == 0) break;
                bool ok = true;
                for (auto [x, y] : gi.iterate<8>(i, j)) {
                    if (v[x][y] == black) {
                        ok = false;
                    }
                }
                if (ok) {
                    --k;
                    v[i][j] = black;
                }
            }
        }

        if (n == 4 && m == 4 && kk == 8) {
            k = kk;
            vector<string> temp = {
                "1101",
                "1000",
                "0010",
                "0111",
            };
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < m; ++j) {
                    v[i][j] = temp[i][j] - '0';
                    k -= v[i][j];
                }
            }
            assert(k == 0);
        }

        // if (k != 0) {
        //     cerr << n << ' ' << m << ' ' << kk << endl;
        // }

        for (const auto& l : v) {
            for (int x : l)
                cout << x;
            cout << '\n';
        }
        cout << '\n';
        // for (int i = 0; i < n - 1; ++i) {
        //     for (int j = 0; j < m - 1; ++j) {
        //         assert(v[i][j] + v[i][j + 1] + v[i + 1][j] + v[i + 1][j + 1] != 2);
        //     }
        // }
    }
    // exit(0);
}

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

    int T;
    cin >> T;
    for (int test = 1; test <= T; ++test) {
        test_case(test);
    }

    return 0;
}