#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>

#define ll long long
#define Int int
#define loop(x, start, end) for(Int x = start; x < end; x++)
#define loopdown(x, start, end) for(Int x = start; x > end; x--)

using namespace std;

#define MAX_V 10000

vector<Int> graph[MAX_V];
bool used_v[MAX_V],used_e[MAX_V][MAX_V];
Int ord[MAX_V],lowlink[MAX_V];
Int k=0;
vector<pair<Int, Int> > bridges;

bool compare (pair<Int, Int> a, pair<Int, Int> b) {
  if (a.first != b.first)  return a.first < b.first;
  if (a.second != b.second) return a.second < b.second;
  return false;
}

void dfs(Int v, Int parent) {
  used_v[v] = true;
  ord[v]=lowlink[v]=k++;
  
  for (Int u: graph[v]) {
    if(!used_v[u]) {
      used_e[v][u] = true;
      dfs(u, v);
      lowlink[v] = min(lowlink[v], lowlink[u]);
      if (ord[v] < lowlink[u]) {
        if (v < u) bridges.push_back(make_pair(v, u));
        else bridges.push_back(make_pair(u, v));
      }
    }
    else if(!used_e[u][v]) {
      lowlink[v] = min(lowlink[v], ord[u]);
    }
  }
}

Int main(void) {
  Int n, e, u, v;
  cin >> n >> e;
  loop(i,0,e) {
    cin >> u >> v;
    graph[u].push_back(v);
    graph[v].push_back(u);
  }
  dfs(0, -1);
  sort(bridges.begin(), bridges.end(), compare);
  for (auto b: bridges) cout << b.first << ' ' << b.second << endl;
}


### Prompt

Construct a Cpp code solution to the problem outlined:

Find bridges of an undirected graph G(V, E).

A bridge (also known as a cut-edge) is an edge whose deletion increase the number of connected components.

Constraints

* 1 ≤ |V| ≤ 100,000
* 0 ≤ |E| ≤ 100,000
* The graph is connected
* There are no parallel edges
* There are no self-loops

Input


|V| |E|
s0 t0
s1 t1
:
s|E|-1 t|E|-1


, where |V| is the number of nodes and |E| is the number of edges in the graph. The graph nodes are named with the numbers 0, 1,..., |V|-1 respectively.

si and ti represent source and target nodes of i-th edge (undirected).

Output

A list of bridges of the graph ordered by name. For each bridge, names of its end-ponints, source and target (source < target), should be printed separated by a space. The sources should be printed ascending order, then the target should also be printed ascending order for the same source.

Examples

Input

4 4
0 1
0 2
1 2
2 3


Output

2 3


Input

5 4
0 1
1 2
2 3
3 4


Output

0 1
1 2
2 3
3 4

### Response

```cpp
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <queue>
#include <stack>
#include <math.h>

#define ll long long
#define Int int
#define loop(x, start, end) for(Int x = start; x < end; x++)
#define loopdown(x, start, end) for(Int x = start; x > end; x--)

using namespace std;

#define MAX_V 10000

vector<Int> graph[MAX_V];
bool used_v[MAX_V],used_e[MAX_V][MAX_V];
Int ord[MAX_V],lowlink[MAX_V];
Int k=0;
vector<pair<Int, Int> > bridges;

bool compare (pair<Int, Int> a, pair<Int, Int> b) {
  if (a.first != b.first)  return a.first < b.first;
  if (a.second != b.second) return a.second < b.second;
  return false;
}

void dfs(Int v, Int parent) {
  used_v[v] = true;
  ord[v]=lowlink[v]=k++;
  
  for (Int u: graph[v]) {
    if(!used_v[u]) {
      used_e[v][u] = true;
      dfs(u, v);
      lowlink[v] = min(lowlink[v], lowlink[u]);
      if (ord[v] < lowlink[u]) {
        if (v < u) bridges.push_back(make_pair(v, u));
        else bridges.push_back(make_pair(u, v));
      }
    }
    else if(!used_e[u][v]) {
      lowlink[v] = min(lowlink[v], ord[u]);
    }
  }
}

Int main(void) {
  Int n, e, u, v;
  cin >> n >> e;
  loop(i,0,e) {
    cin >> u >> v;
    graph[u].push_back(v);
    graph[v].push_back(u);
  }
  dfs(0, -1);
  sort(bridges.begin(), bridges.end(), compare);
  for (auto b: bridges) cout << b.first << ' ' << b.second << endl;
}


```