#include <bits/stdc++.h>
using namespace std;

struct Dinic {
    struct Edge {
        int to, rev, cap;
    };

    int n;
    vector<vector<Edge>> g;
    vector<int> level, ptr;

    Dinic(int n) : n(n), g(n), level(n), ptr(n) {}

    void addEdge(int u, int v, int cap) {
        Edge a{v, (int)g[v].size(), cap};
        Edge b{u, (int)g[u].size(), 0};

        g[u].push_back(a);
        g[v].push_back(b);
    }

    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);

        queue<int> q;
        q.push(s);
        level[s] = 0;

        while (!q.empty()) {
            int v = q.front();
            q.pop();

            for (auto &e : g[v]) {
                if (e.cap > 0 && level[e.to] == -1) {
                    level[e.to] = level[v] + 1;
                    q.push(e.to);
                }
            }
        }

        return level[t] != -1;
    }

    int dfs(int v, int t, int pushed) {
        if (pushed == 0) return 0;
        if (v == t) return pushed;

        for (int &cid = ptr[v]; cid < (int)g[v].size(); cid++) {
            Edge &e = g[v][cid];

            if (e.cap <= 0 || level[e.to] != level[v] + 1)
                continue;

            int tr = dfs(e.to, t, min(pushed, e.cap));

            if (tr == 0) continue;

            e.cap -= tr;
            g[e.to][e.rev].cap += tr;

            return tr;
        }

        return 0;
    }

    int maxflow(int s, int t, int limit) {
        int flow = 0;

        while (flow < limit && bfs(s, t)) {
            fill(ptr.begin(), ptr.end(), 0);

            while (flow < limit) {
                int pushed = dfs(s, t, limit - flow);

                if (pushed == 0) break;

                flow += pushed;
            }
        }

        return flow;
    }
};

bool check(int i, int j,
           const vector<int> &r,
           const vector<int> &c,
           int n, int m) {

    int need = 0;

    for (int x = i; x < n; x++)
        need += r[x];

    int S = 0;

    int rowBase = 1;
    int colBase = rowBase + (n - i);
    int T = colBase + m;

    Dinic dinic(T + 1);

    for (int x = i; x < n; x++) {
        dinic.addEdge(S, rowBase + x - i, r[x]);
    }

    for (int y = 0; y < m; y++) {
        dinic.addEdge(colBase + y, T, c[y]);
    }

    for (int x = i; x < n; x++) {

        int firstCol = (x == i ? j + 1 : 0);

        for (int y = firstCol; y < m; y++) {

            if (r[x] == 0 || c[y] == 0)
                continue;

            dinic.addEdge(
                rowBase + x - i,
                colBase + y,
                1
            );
        }
    }

    return dinic.maxflow(S, T, need) == need;
}

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

    int n, m;
    cin >> n >> m;

    vector<int> r(n), c(m);

    int sumR = 0, sumC = 0;

    for (int &x : r) {
        cin >> x;
        sumR += x;
    }

    for (int &x : c) {
        cin >> x;
        sumC += x;
    }

    if (sumR != sumC) {
        cout << -1;
        return 0;
    }

    for (int x : r)
        if (x < 0 || x > m) {
            cout << -1;
            return 0;
        }

    for (int x : c)
        if (x < 0 || x > n) {
            cout << -1;
            return 0;
        }

    vector<string> ans(n, string(m, '0'));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {

            if (check(i, j, r, c, n, m)) {
                ans[i][j] = '0';
            }
            else {
                if (r[i] == 0 || c[j] == 0) {
                    cout << -1;
                    return 0;
                }

                ans[i][j] = '1';

                r[i]--;
                c[j]--;
            }
        }
    }

    for (int x : r) {
        if (x != 0) {
            cout << -1;
            return 0;
        }
    }

    for (int x : c) {
        if (x != 0) {
            cout << -1;
            return 0;
        }
    }

    for (auto &s : ans)
        cout << s << '\n';

    return 0;
}