#include <vector>
#include <iostream>
#include <limits>
#include <map>
#include <queue>

typedef std::vector<std::map<int, int> > graph;

bool bfs(const graph &g, int s, int t, std::vector<int> &parent)
{
    int n = g.size();
    std::vector<bool> visited(n);
    parent.resize(n);

    std::queue<int> q;
    q.push(s);
    visited[s] = true;
    parent[s] = -1;

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

        for (auto v : g[u]) {
            if (visited[v.first] == false && v.second > 0) {
                if (v.first == t) {
                    parent[v.first] = u;
                    return true;
                }
                q.push(v.first);
                parent[v.first] = u;
                visited[v.first] = true;
            }
        }
    }
    return false;
}


int fordFulkerson(graph &g, int s, int t)
{
    int n = g.size();
    std::vector<int> parent(n);
    int max_flow = 0;

    while (bfs(g, s, t, parent)) {
        int path_flow = std::numeric_limits<int>::max();
        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            path_flow = std::min(path_flow, g[u][v]);
        }

        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            g[u][v] -= path_flow;
            g[v][u] += path_flow;
        }

        max_flow += path_flow;
    }

    return max_flow;
}

bool ensurePath(graph &g, int v1, int v2)
{
    if(g[v2][v1] > 0)
        return true;
    int n = g.size();
    std::vector<int> parent(n);
    if(!bfs(g, v2, v1, parent))
        return false;
    int path_flow = g[v1][v2];
    for(int v = v1; v != v2; v = parent[v])
    {
        int u = parent[v];
        path_flow = std::min(path_flow, g[u][v]);
    }

    for (int v = v1; v != v2; v = parent[v]) {
        int u = parent[v];
        g[u][v] -= path_flow;
        g[v][u] += path_flow;
    }
    g[v2][v1] = path_flow;
    return path_flow > 0;
}

int main()
{
    int n, m;
    std::cin >> n >> m;
    std::vector<std::pair<int, int> > edges(m);
    graph g(2*n+2);
    for(int i=0; i<n; i++)
    {
      g[0][i+2] = 1;
      g[n+i+2][1] = 1;
    }
    for(int i=0; i<m; i++)
    {
        int v1, v2;
        std::cin >> v1 >> v2;
        g[v1+1][n+v2+1] = 1;
        g[v2+1][n+v1+1] = 1;
        edges[i] = {v1-1, v2-1};
    }
    if(fordFulkerson(g, 0, 1) != n)
    {
        std::cout << "-1" << std::endl;
        return 0;
    }
    
    int remainingPoints = 5000;
    graph ptsMatrix(n);
    for(int i=0; i<m; i++)
    {
        int v1 = edges[i].first;
        int v2 = edges[i].second;
        bool ok = ensurePath(g, v1+2, n+v2+2);
        if(ok)
        {
            for(int j=0; j<n; j++)
            {
                for(auto it : g[n+j+2])
                {
                    if(it.first != 1 && it.second > 0)
                    {
                        ptsMatrix[j][it.first-2] += 1;
                        ptsMatrix[it.first-2][j] += 1;
                    }
                }
            }
            remainingPoints--;
        }
    }
    for(int j=0; j<n; j++)
    {
        for(auto it : g[n+j+2])
        {
            if(it.first != 1 && it.second > 0)
            {
                ptsMatrix[j][it.first-2] += remainingPoints;
                ptsMatrix[it.first-2][j] += remainingPoints;
            }
        }
    }
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(j != 0) std::cout << " ";
            std::cout << ptsMatrix[i][j];            
        }
        std::cout << std::endl;
    }
}