#include <iostream>

 #include <stdio.h>

 #include <vector>

 #include <string.h>

 using namespace std;

 const int MAXN=1e5+;

 vector<int> mp[MAXN];

 bool is_cut[MAXN];

 int n, m, count=;

 int low[MAXN], dfn[MAXN], pre[MAXN];//pre[u]记录u的父亲节点编号

 //dfn[u]记录节点u在DFS过程中被遍历到的次序号，low[u]记录节点u或u的子树通过非父子边追溯到最早的祖先节点（即DFS次序号最小

 void tarjan(int u, int fu){

     pre[u]=fu;//记录当前u的父亲节点

     dfn[u]=low[u]=count++;

     for(int i=; i<mp[u].size(); i++){

         int v=mp[u][i];

         if(dfn[v]==-){

             tarjan(v, u);

             low[u]=min(low[u], low[v]);

         }else if(fu!=v){//如果v是u的父亲的话，即有重边，那么不可能是桥

             low[u]=min(low[u], dfn[v]);

         }

     }

 }

 void solve(void){

     int rootson=;

     tarjan(, );

     for(int i=; i<=n; i++){

         int v=pre[i];

         if(v==){

             rootson++;//统计根节点的子树个数，若其不小于2,即为割点

         }else if(low[i]>=dfn[v]){

             is_cut[v]=true;

         }

     }

     if(rootson>) is_cut[]=true;

     puts("割点为：");

     for(int i=; i<=n; i++){//输出割点

         if(is_cut[i]){

             printf("%d ", i);

         }

     }

     puts("\n桥为：");

     for(int i=; i<=n; i++){

         int v=pre[i];

         if(v>&&low[i]>dfn[v]){

             printf("%d %d\n", v, i);

         }

     }

     puts("");

 }

 int main(void){

     scanf("%d%d", &n, &m);

     for(int i=; i<m; i++){

         int x, y;

         scanf("%d%d", &x, &y);

         mp[x].push_back(y);

         mp[y].push_back(x);

     }

     memset(dfn, -, sizeof(dfn));

     memset(low, -, sizeof(low));

     solve();

     return ;

 }

 #include <iostream>

 #include <stdio.h>

 #include <string.h>

 using namespace std;

 const int MAXN = 1e5 + ;

 struct node{

     int v, next, use;

 }edge[MAXN << ];

 bool bridge[MAXN];

 int low[MAXN], dfn[MAXN], vis[MAXN];

 int head[MAXN], pre[MAXN], ip, sol, count;

 void init(void){

     memset(head, -, sizeof(head));

     memset(vis, false, sizeof(vis));

     memset(bridge, false, sizeof(bridge));

     count = sol = ip = ;

 }

 void addedge(int u, int v){

     edge[ip].v = v;

     edge[ip].use = ;

     edge[ip].next = head[u];

     head[u] = ip++;

 }

 void tarjan(int u){

     vis[u] = ;

     dfn[u] = low[u] = count++;

     for(int i = head[u]; i != -; i = edge[i].next){

         if(!edge[i].use){

             edge[i].use = edge[i ^ ].use = ;

             int v = edge[i].v;

             if(!vis[v]){

                 pre[v] = u;

                 tarjan(v);

                 low[u] = min(low[u], low[v]);

                 if(dfn[u] < low[v]){

                     sol++;

                     bridge[v] = true;

                 }

             }else if(vis[v] == ){

                 low[u] = min(low[u], dfn[v]);

             }

         }

     }

     vis[u] = ;

 }

 int main(void){

     int n, m, q, x, y, cas = ;

     while(~scanf("%d%d", &n, &m)){

         if(!n && !m) break;

         init();

         for(int i = ; i < m; i++){

             scanf("%d%d", &x, &y);

             addedge(x, y);

             addedge(y, x);

         }

         pre[] = ;

         tarjan();

         for(int i = ; i <= n; i++){

             if(bridge[i]) cout << i << " " << pre[i] << endl;

         }

     }

     return ;

 }