#include <iostream>
#include <vector>
#include <fstream>
#include <stack>
using namespace std;

ifstream fin("dfs.in");
ofstream fout("dfs.out");

class Graph{

private:

    int n_nodes;
    vector<bool> visited;
    vector<vector<int>> adj;
    vector< pair<int, pair<int,int>> > adj_weights;
    int no_comp_conexe = 0;
    //pentru muchii critice
    vector<int> nivel;
    vector<int> niv_min;
public:
    Graph(){
        n_nodes = 0;
        adj = {};
    }

    Graph(int n, vector<vector<int>> &graph)
    {
        n_nodes = n;
        adj = graph;

        visited.resize(n+1, false);
    }

    void dfs(int root);

    void dfs_comp_conexe(int root);

    int comp_conexe();

    bool havelhakimi(vector<int> v);

    void df_m_critice(int i);

    void solve_m_critice();

    vector < vector < int > > comp_biconexe();

    void dfs_biconexe (int nod , int dad, vector < int > &lv, vector < int > &MIN, stack < int > &s, vector < vector < int > > &ans){
        lv[nod] = lv[dad]+1;
        MIN[nod] = lv[nod];
        s.push(nod);
        for (auto &x : adj[nod]){
            if (lv[x]){
                if (x != dad){
                    MIN[nod] = min(MIN[nod] , lv[x]);
                }
            }
            else{
                dfs_biconexe(x , nod, lv, MIN, s, ans);
                MIN[nod] = min(MIN[nod] , MIN[x]);
                if (MIN[x] >= lv[nod]){
                    vector < int > aux;
                    while (s.top() != x){
                        aux.push_back(s.top());
                        s.pop();
                    }
                    aux.push_back(x);
                    s.pop();
                    aux.push_back(nod);
                    ans.push_back(aux);
                }
            }
        }
    }


};

void Graph::dfs(int root)
{
    visited[root] = true;
    for(int i = 0; i < adj[root].size(); ++i)
    {
        if(!visited[adj[root][i]]){
            dfs(adj[root][i]);
            cout<<adj[root][i]<<' ';
        }
    }

}

void Graph::dfs_comp_conexe(int root)
{
    visited[root] = true;
    for(int i = 0; i < adj[root].size(); ++i)
    {
        if(!visited[adj[root][i]]){
            dfs(adj[root][i]);
        }
    }
    no_comp_conexe++;
}

int Graph::comp_conexe()
{
    for(int i = 1; i <= n_nodes; ++i){
        if(!visited[i]) dfs_comp_conexe(i);
    }
    return no_comp_conexe;
}

bool Graph::havelhakimi(vector<int> v)
{
    //given a sequence of degrees -> is it graphical?
    //algorithm: check necessary (yet not sufficient) proprieties: even sum of degrees, degree <= n-1
    int s = v.size();

    for(int i = 0; i < s; ++i){
        sort(v.begin(), v.end(), greater<int>());

        if(v[0] >= s) return false; //degree >= n

        for(int j = 1; j < s; ++j){
            v[j]--;
            if(v[j] < 0) return false;
        }
        v[0] = 0;
    }

    return true;

}

void Graph::solve_m_critice()
{
    visited.resize(n_nodes, false);
}

void Graph::df_m_critice(int i){
    visited[i] = true;
    niv_min[i] = nivel[i];
    for(auto j: adj[i]){
        if(!visited[j]){ //ij muchie de avansare
            nivel[j] = nivel[i] + 1;
            df_m_critice(j);
            //actualizez niv_min[i]: formula B
            niv_min[i] = min(niv_min[i], niv_min[j]);
            //testam daca e muchie critica
            if(niv_min[j] > nivel[i])
                cout<<i<<' '<<j<<'\n';
        }
        else
        {
            if(nivel[j] < nivel[i] - 1) //ij muchie de intoarcere
                //actualizez niv_min: formula A
                niv_min[i] =  min(niv_min[i], nivel[j]);
        }
    }

}
vector < vector < int > >  Graph::comp_biconexe()
{
    vector < vector < int > > ans;
    vector < int > lv (n_nodes + 1, 0);
    vector < int > MIN (n_nodes + 1, 0);
    stack < int > s;

    for (int i=1; i<=n_nodes; i++){
        if (!lv[i]){ //nu am vizitat nodul
            dfs_biconexe(i , 0, lv, MIN, s, ans);
        }
    }

    return ans;

}

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

    int n, m, x, y;
    vector<vector<int>> a;
    fin>>n>>m;
    a.resize(n+1);

    for(int i = 0; i < m; ++i)
    {
        fin>>x>>y;
        a[x].push_back(y);
        a[y].push_back(x);
    }

    Graph g(n, a);

    //fout<<g.comp_conexe();
    return 0;
}