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

const int MAXN = 105;  // 최대 노드 수 (N+M+2 정도)
int N, M;
int capacity[MAXN][MAXN];  // 용량
int flow[MAXN][MAXN];      // 흐른 유량 (양수: 정방향, 음수: 역방향)

// BFS로 최대 유량 증가 경로 찾기 (에드몬즈-카프 사용)
bool findAugmentingPath(int source, int sink, vector<int>& parent) {
    fill(parent.begin(), parent.end(), -1);
    parent[source] = source;
    queue<int> q;
    q.push(source);
    while (!q.empty() && parent[sink] == -1) {
        int u = q.front();
        q.pop();
        for (int v = 0; v <= N + M + 1; ++v) {
            // 남은 용량이 있고 방문하지 않은 노드
            if (parent[v] == -1 && capacity[u][v] - flow[u][v] > 0) {
                parent[v] = u;
                q.push(v);
                if (v == sink) break;
            }
        }
    }
    return parent[sink] != -1;
}

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

    if (!(cin >> N >> M)) {
        return 0;
    }
    vector<int> rowMatches(N+1), colMatches(M+1);
    for (int i = 1; i <= N; ++i) {
        cin >> rowMatches[i];
    }
    for (int j = 1; j <= M; ++j) {
        cin >> colMatches[j];
    }

    // 소스, 싱크 노드 번호 설정
    int source = 0;
    int sink = N + M + 1;

    // 용량 초기화
    memset(capacity, 0, sizeof(capacity));
    memset(flow, 0, sizeof(flow));

    // 소스->지민팀 노드 용량 설정
    long long totalRow = 0, totalCol = 0;
    for (int i = 1; i <= N; ++i) {
        capacity[source][i] = rowMatches[i];
        totalRow += rowMatches[i];
    }
    // 한수팀 노드->싱크 용량 설정
    for (int j = 1; j <= M; ++j) {
        capacity[N + j][sink] = colMatches[j];
        totalCol += colMatches[j];
    }
    // 만약 요구 경기 수 총합이 다르면 불가능
    if (totalRow != totalCol) {
        cout << "-1";
        return 0;
    }
    // 지민팀->한수팀 노드 용량 1 (모든 가능한 대결 간선 추가)
    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= M; ++j) {
            capacity[i][N + j] = 1;
        }
    }

    // 최대 유량 계산 (Edmonds-Karp)
    int maxFlow = 0;
    vector<int> parent(N + M + 2);
    while (findAugmentingPath(source, sink, parent)) {
        // 증강 경로가 발견되면 가능한 유량만큼(여기서는 1 단위씩) 보냄
        int increment = INT_MAX;
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            increment = min(increment, capacity[u][v] - flow[u][v]);
        }
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            flow[u][v] += increment;
            flow[v][u] -= increment;
        }
        maxFlow += increment;
    }

    // 최대 유량이 총 필요한 경기 수와 다르면 -1 출력 후 종료
    if (maxFlow != totalRow) {
        cout << "-1";
        return 0;
    }

    // 사전순으로 대진표 조정: 각 지민팀 i, 한수팀 j 순회
    for (int i = 1; i <= N; ++i) {
        for (int j = 1; j <= M; ++j) {
            int colNode = N + j;
            if (flow[i][colNode] == 1) {  // 현재 i번째 선수와 j번째 선수 간 경기 있음
                // 해당 경기(flow)를 제거해보고 대체 가능 여부 확인
                flow[source][i] -= 1;
                flow[i][source] += 1;
                flow[i][colNode] -= 1;
                flow[colNode][i] += 1;
                flow[colNode][sink] -= 1;
                flow[sink][colNode] += 1;
                // BFS로 i에서 sink까지 새로운 경로 찾기 (제한 조건 적용)
                vector<int> prev(N + M + 2, -1);
                queue<int>q;
                q.push(i);
                prev[i] = source;
                bool canReplace = false;
                while (!q.empty() && !canReplace) {
                    int u = q.front();
                    q.pop();
                    // 인접 노드 순회 (0~N+M+1 전체를 확인)
                    for (int v = 0; v <= N + M + 1; ++v) {
                        if (prev[v] != -1) continue;
                        // **제한 조건 적용** 
                        // 1) 시작 행 i로부터 이동할 때, j보다 작은(혹은 같은) 열은 제외
                        if (u == i && v <= N + j) continue;
                        // 2) 어떤 정점으로든 i보다 작은 번호의 지민팀 선수 노드는 방문 불가
                        if (v <= i && v != source) continue;
                        // 유량을 더 보낼 수 있는 간선인지 확인
                        if (capacity[u][v] - flow[u][v] > 0) {
                            prev[v] = u;
                            q.push(v);
                            if (v == sink) {  // sink에 도달하면 경로 찾음
                                canReplace = true;
                                break;
                            }
                        }
                    }
                }
                if (!canReplace) {
                    // 대체 경로 못 찾았으면 제거 실패 -> 원래 흐름 복구
                    flow[source][i] += 1;
                    flow[i][source] -= 1;
                    flow[i][colNode] += 1;
                    flow[colNode][i] -= 1;
                    flow[colNode][sink] += 1;
                    flow[sink][colNode] -= 1;
                } else {
                    // 대체 경로 찾았으면 경로 따라 유량 1 보충
                    int v = sink;
                    while (v != i) {
                        int u = prev[v];
                        flow[u][v] += 1;
                        flow[v][u] -= 1;
                        v = u;
                    }
                    // (i->colNode 경기는 0으로 유지되고, 유량은 다른 경로로 채워짐)
                }
            }
        }
    }

    // 최종 대진표 출력
    for (int i = 1; i <= N; ++i) {
        string line = "";
        for (int j = 1; j <= M; ++j) {
            int colNode = N + j;
            line.push_back(flow[i][colNode] > 0 ? '1' : '0');
        }
        cout << line << "\n";
    }

    return 0;
}