#include <bits/stdc++.h>
using namespace std;
template <typename T, typename C>
struct MinCostMF {
  static constexpr T eps = (T)(1e-9);
  struct edge {
    int from;
    int to;
    T c;
    T f;
    C cost;
  };
  vector<vector<int> > G;
  vector<edge> edges;
  vector<C> d;
  queue<int> q;
  vector<bool> in_queue;
  vector<int> trace;
  int n;
  int s, t;
  T flow;
  C cost;
  MinCostMF(int n, int s, int t) : n(n), s(s), t(t) {
    assert(0 <= s && s < n && 0 <= t && t < n && t != s);
    G.resize(n);
    d.resize(n);
    in_queue.resize(n);
    trace.resize(n);
    flow = 0;
    cost = 0;
  }
  void clear_flow() {
    for (const edge& e : edges) {
      e.f = 0;
    }
    flow = 0;
  }
  void add(int from, int to, T fc, T bc, C cost) {
    assert(0 <= from && from < n && 0 <= to && to < n);
    G[from].push_back((int)edges.size());
    edges.push_back({from, to, fc, 0, cost});
    G[to].push_back((int)edges.size());
    edges.push_back({to, from, bc, 0, cost});
  }
  bool expath() {
    fill(d.begin(), d.end(), numeric_limits<C>::max());
    q = queue<int>();
    q.push(s);
    d[s] = 0;
    in_queue[s] = true;
    bool found = false;
    while (q.size()) {
      int u = q.front();
      q.pop();
      if (u == t) {
        found = true;
      }
      in_queue[u] = false;
      for (int id : G[u]) {
        const edge& e = edges[id];
        if (e.c - e.f > eps && d[u] + e.cost < d[e.to]) {
          d[e.to] = d[u] + e.cost;
          trace[e.to] = id;
          if (!in_queue[e.to]) {
            q.push(e.to);
            in_queue[e.to] = true;
          }
        }
      }
    }
    if (found) {
      T upflow = numeric_limits<T>::max();
      int v = t;
      while (v != s) {
        const edge& e = edges[trace[v]];
        upflow = min(upflow, e.c - e.f);
        v = e.from;
      }
      v = t;
      while (v != s) {
        edge& e = edges[trace[v]];
        e.f += upflow;
        edge& back = edges[trace[v] ^ 1];
        back.f -= upflow;
        v = e.from;
      }
      flow += upflow;
      cost += d[t] * upflow;
    }
    return found;
  }
  pair<T, C> mfmc() {
    while (expath()) {
    }
    return {flow, cost};
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<vector<char> > a(n, vector<char>(n, '0'));
  vector<int> deg(n, 0);
  for (int i = 0; i < m; ++i) {
    int u, v;
    cin >> u >> v;
    --u;
    --v;
    a[u][v] = '1';
    ++deg[u];
  }
  int rm = (n * (n - 1)) / 2 - m;
  MinCostMF<int, int> f(n + rm + 2, n + rm, n + rm + 1);
  for (int u = 0; u < n; ++u) {
    for (int i = deg[u] + 1; i < n; ++i) {
      f.add(f.s, u, 1, 0, i * (i - 1) - (i - 1) * (i - 2));
    }
  }
  vector<pair<int, int> > who;
  int id = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      if (a[i][j] == '0' && a[j][i] == '0') {
        f.add(i, n + id, 1, 0, 0);
        f.add(j, n + id, 1, 0, 0);
        f.add(n + id, f.t, 1, 0, 0);
        who.emplace_back(i, j);
        ++id;
      }
    }
  }
  f.mfmc();
  for (int i = 0; i < n; ++i) {
    for (int eid : f.G[i]) {
      if (f.edges[eid].f == 1) {
        int id = f.edges[eid].to - n;
        int j = who[id].first ^ who[id].second ^ i;
        a[i][j] = '1';
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      putchar(a[i][j]);
    }
    putchar('\n');
  }
}
