import java.io.*;
import java.util.*;

public class MaxComponent implements Comparable<MaxComponent> {
    private int vertexes;
    private int edges;
    private int mi_vertex;

    private MaxComponent(int vertexes, int edges, int mi_vertex) {
        this.vertexes = vertexes;
        this.edges = edges;
        this.mi_vertex = mi_vertex;
    }

    private void dfs(int v, List<Integer>[] graph, boolean[] used) {
        used[v] = true;
        vertexes++;
        mi_vertex = v;
        for (int i = 0; i < graph[v].size(); i++) {
            edges++;

            if (graph[v].get(i) < mi_vertex)
                mi_vertex = graph[v].get(i);
            if (!used[graph[v].get(i)]) {
                dfs(graph[v].get(i), graph, used);
            }
        }
    }

    private void bfs(boolean[] f_used, boolean[] s_used, List<Integer>[] graph, boolean flag, PrintWriter out) {
        Deque<Integer> deque = new ArrayDeque<>();
        deque.add(mi_vertex);

        while (!deque.isEmpty()) {
            int v = deque.poll();

            if (!s_used[v]) {
                if (!flag) {
                    out.println(v);
                } else {
                    out.println(v + " [color = red]");
                }
            }

            s_used[v] = true;

            for (int to : graph[v]) {
                if (!f_used[to] && !f_used[v]) {
                    deque.add(to);

                    if (!flag) {
                        out.println(v + " -- " + to);
                    } else {
                        out.println(v + " -- " + to + " [color = red]");
                    }
                }
            }

            f_used[v] = true;
        }
    }

    @Override
    public int compareTo(MaxComponent o) {
        if (vertexes < o.vertexes)
            return 1;
        else if (vertexes > o.vertexes)
            return -1;
        else if (edges < o.edges)
            return 1;
        else if (edges > o.edges)
            return -1;
        else if (mi_vertex > o.mi_vertex)
            return 1;
        return -1;
    }

    public static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /** call this method to initialize reader for InputStream */
        static void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input) );
            tokenizer = new StringTokenizer("");
        }

        /** get next word */
        static String next() throws IOException {
            while ( ! tokenizer.hasMoreTokens() ) {
                //TODO add check for eof if necessary
                tokenizer = new StringTokenizer(
                        reader.readLine() );
            }
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt( next() );
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble( next() );
        }
    }

    public static void main(String[] args) throws Exception {
        Reader.init(System.in);

        int n = Reader.nextInt();
        int m = Reader.nextInt();

        List<Integer>[] graph = new List[n];

        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }

        for(int i = 0; i < m; i++) {
            int from = Reader.nextInt();
            int to = Reader.nextInt();

            if (from == to) {
                graph[from].add(to);
            } else {
                graph[from].add(to);
                graph[to].add(from);
            }
        }

        List<MaxComponent> components = new ArrayList<>();
        boolean[] used = new boolean[n];

        for (int i = 0; i < n; i++) {
            if (!used[i]) {
                MaxComponent temp = new MaxComponent(0, 0, i);
                temp.dfs(i, graph, used);
                components.add(temp);
            }
        }

        components.sort(MaxComponent::compareTo);

        PrintWriter pw = new PrintWriter(System.out);

        pw.println("graph {");

        Arrays.fill(used, false);
        boolean[] s_used = new boolean[n];

        components.get(0).bfs(used, s_used, graph, true, pw);

        for (int i = 1; i < components.size(); i++) {
            components.get(i).bfs(used, s_used, graph, false, pw);
        }

        pw.println("}");
        pw.flush();
        pw.close();
    }
}