#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cassert>
#include <numeric>

using namespace std;

typedef long long LL;
constexpr int mod = 998244353;
template <typename Tp1, typename Tp2> inline void cmax(Tp1 &A, const Tp2 &B)  { if (A < B) A = B; return; }
template <typename Tp1, typename Tp2> inline void cmin(Tp1 &A, const Tp2 &B)  { if (A > B) A = B; return; }
template <typename Tp1, typename Tp2, int mod = ::mod> inline void ad(Tp1 &A, const Tp2 &B) { A = (A + B) % mod; return; }
template <typename Tp1, typename Tp2, int mod = ::mod> inline void sb(Tp1 &A, const Tp2 &B) { A = (A + mod - B) % mod; return; }

constexpr int N = 100010;
int n, m;
vector<int> ans;

struct node
{
  int next, to;
} e[N << 1]; int head[N], es = 1, dfn[N], low[N], tot;
void bian(int u, int v)
{
  e[++es] = {head[u], v};
  head[u] = es; return;
}

void tarjan(int u, int fa)
{
  dfn[u] = low[u] = ++tot;
  
  for (int i = head[u]; i; i = e[i].next)
    if (const int v = e[i].to; !dfn[v])
    {
      tarjan(v, i);
      cmin(low[u], low[v]);
      if (low[v] > dfn[u])
        ans.emplace_back((i | 1) ^ 1);
    }
    else if (i != fa && i != (fa ^ 1))
      cmin(low[u], dfn[v]);
  
  return;
}

struct par
{
  par() = default;
  par(int _x, int _y) : x(_x), y(_y) { }
  bool operator<(const par Q) const { return x != Q.x ? x < Q.x : y < Q.y; }
  bool operator==(const par Q) const { return x == Q.x && y == Q.y; }
  bool operator>(const par Q) const { return x != Q.x ? x > Q.x : y > Q.y; }
  int x, y;
};
vector<par> edge;

int main()
{
  cin >> n >> m;
  edge.resize(m + 1);

  for (int i = 1; i <= m; i++)
  {
    cin >> edge[i].x >> edge[i].y;
    if (edge[i].x == edge[i].y) continue;
    bian(edge[i].x, edge[i].y);
    bian(edge[i].y, edge[i].x);
  }
  
  for (int i = 1; i <= n; i++)
    if (!dfn[i])
      tarjan(i, 0);
  
  sort(ans.begin(), ans.end());
  
  for (auto th : ans)
  {
    th >>= 1;
    cout << edge[th].x << ' ' << edge[th].y << '\n';
  }
  
  return 0;
}