package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
)

type Edge struct {
	to, rev int
	cap     int
	cost    int
}

type MCMF struct {
	n   int
	g   [][]Edge
	pot []int
}

func NewMCMF(n int) *MCMF {
	return &MCMF{
		n:   n,
		g:   make([][]Edge, n),
		pot: make([]int, n),
	}
}

func (m *MCMF) AddEdge(u, v, cap, cost int) {
	fwd := Edge{to: v, rev: len(m.g[v]), cap: cap, cost: cost}
	rev := Edge{to: u, rev: len(m.g[u]), cap: 0, cost: -cost}
	m.g[u] = append(m.g[u], fwd)
	m.g[v] = append(m.g[v], rev)
}

type Item struct {
	node int
	dist int
	idx  int
}

type MinHeap []Item

func (h MinHeap) Len() int            { return len(h) }
func (h MinHeap) Less(i, j int) bool  { return h[i].dist < h[j].dist }
func (h MinHeap) Swap(i, j int)       { h[i], h[j] = h[j], h[i]; h[i].idx = i; h[j].idx = j }
func (h *MinHeap) Push(x interface{}) { *h = append(*h, x.(Item)) }
func (h *MinHeap) Pop() interface{} {
	old := *h
	n := len(old)
	it := old[n-1]
	*h = old[:n-1]
	return it
}

func (m *MCMF) MinCostMaxFlow(s, t, maxflow int) (int, int) {
	const INF = int(1 << 30)
	n := m.n
	predNode := make([]int, n)
	predEdge := make([]int, n)
	flow := 0
	cost := 0
	for flow < maxflow {
		dist := make([]int, n)
		for i := 0; i < n; i++ {
			dist[i] = INF
		}
		dist[s] = 0
		h := &MinHeap{}
		heap.Init(h)
		heap.Push(h, Item{node: s, dist: 0})
		for h.Len() > 0 {
			it := heap.Pop(h).(Item)
			u := it.node
			if it.dist != dist[u] {
				continue
			}
			for i := range m.g[u] {
				e := m.g[u][i]
				if e.cap <= 0 {
					continue
				}
				nd := dist[u] + e.cost + m.pot[u] - m.pot[e.to]
				if nd < dist[e.to] {
					dist[e.to] = nd
					predNode[e.to] = u
					predEdge[e.to] = i
					heap.Push(h, Item{node: e.to, dist: nd})
				}
			}
		}
		if dist[t] == INF {
			break
		}
		for v := 0; v < n; v++ {
			if dist[v] < INF {
				m.pot[v] += dist[v]
			}
		}
		add := maxflow - flow
		v := t
		for v != s {
			u := predNode[v]
			ei := predEdge[v]
			if m.g[u][ei].cap < add {
				add = m.g[u][ei].cap
			}
			v = u
		}
		v = t
		for v != s {
			u := predNode[v]
			ei := predEdge[v]
			re := m.g[u][ei].rev
			m.g[u][ei].cap -= add
			m.g[v][re].cap += add
			v = u
		}
		flow += add
		cost += add * m.pot[t]
	}
	return flow, cost
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	a := make([][]int, n)
	for i := 0; i < n; i++ {
		a[i] = make([]int, n)
		for j := 0; j < n; j++ {
			if i == j {
				a[i][j] = 0
			} else {
				a[i][j] = -1
			}
		}
	}

	for k := 0; k < m; k++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		u--
		v--
		a[u][v] = 1
		a[v][u] = 0
	}

	type Pair struct{ u, v int }
	var edges []Pair
	for i := 0; i < n; i++ {
		for j := i + 1; j < n; j++ {
			if a[i][j] == -1 {
				edges = append(edges, Pair{i, j})
			}
		}
	}
	M := len(edges)

	d0 := make([]int, n)
	uCap := make([]int, n)
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if a[i][j] == 1 {
				d0[i]++
			} else if a[i][j] == -1 {
				uCap[i]++
			}
		}
	}

	s := 0
	offsetEdges := 1
	offsetVerts := 1 + M
	t := 1 + M + n
	N := t + 1
	mcmf := NewMCMF(N)

	eToIIdx := make([]int, M)
	eToJIdx := make([]int, M)

	for e := 0; e < M; e++ {
		eNode := offsetEdges + e
		mcmf.AddEdge(s, eNode, 1, 0)
		i := edges[e].u
		j := edges[e].v
		vi := offsetVerts + i
		vj := offsetVerts + j
		mcmf.AddEdge(eNode, vi, 1, 0)
		eToIIdx[e] = len(mcmf.g[eNode]) - 1
		mcmf.AddEdge(eNode, vj, 1, 0)
		eToJIdx[e] = len(mcmf.g[eNode]) - 1
	}

	for i := 0; i < n; i++ {
		vi := offsetVerts + i
		for k := 1; k <= uCap[i]; k++ {
			cost := d0[i] + k - 1
			mcmf.AddEdge(vi, t, 1, cost)
		}
	}

	if M > 0 {
		mcmf.MinCostMaxFlow(s, t, M)
	}

	for e := 0; e < M; e++ {
		eNode := offsetEdges + e
		i := edges[e].u
		j := edges[e].v
		edgeToI := mcmf.g[eNode][eToIIdx[e]]
		if edgeToI.cap == 0 {
			a[i][j] = 1
			a[j][i] = 0
		} else {
			a[i][j] = 0
			a[j][i] = 1
		}
	}

	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if i == j {
				fmt.Fprint(out, "0")
			} else {
				if a[i][j] == 1 {
					fmt.Fprint(out, "1")
				} else {
					fmt.Fprint(out, "0")
				}
			}
		}
		fmt.Fprintln(out)
	}
}