Problem: Berland is very concerned with privacy, so almost all plans and blueprints are secret. However, a spy of the neighboring state managed to steal the Bertown subway scheme.

The Bertown Subway has n stations, numbered from 1 to n, and m bidirectional tunnels connecting them. All Bertown Subway consists of lines. To be more precise, there are two types of lines: circular and radial.

A radial line is a sequence of stations v1, ..., vk (k > 1), where stations vi and vi + 1 (i < k) are connected by a tunnel and no station occurs in the line more than once (vi ≠ vj for i ≠ j).

A loop line is a series of stations, v1, ..., vk (k > 2), where stations vi и vi + 1 are connected by a tunnel. In addition, stations v1 and vk are also connected by a tunnel. No station is occurs in the loop line more than once.

Note that a single station can be passed by any number of lines.

According to Berland standards, there can't be more than one tunnel between two stations and each tunnel belongs to exactly one line. Naturally, each line has at least one tunnel. Between any two stations there is the way along the subway tunnels. In addition, in terms of graph theory, a subway is a vertex cactus: if we consider the subway as a graph in which the stations are the vertexes and the edges are tunnels, then each vertex lies on no more than one simple cycle.

Unfortunately, scheme, stolen by the spy, had only the stations and the tunnels. It was impossible to determine to which line every tunnel corresponds. But to sabotage successfully, the spy needs to know what minimum and maximum number of lines may be in the Bertown subway.

Help him!

Input

The first line contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ 3·105) — the number of stations and the number of tunnels, correspondingly.

Each of the next m lines contain two integers — the numbers of stations connected by the corresponding tunnel. The stations are numbered with integers from 1 to n.

It is guaranteed that the graph that corresponds to the subway has no multiple edges or loops, it is connected and it is a vertex cactus.

Output

Print two numbers — the minimum and maximum number of lines correspondingly.

Examples

Input

3 3
1 2
2 3
3 1


Output

1 3


Input

8 8
1 2
2 3
3 4
4 5
6 4
4 7
7 2
2 8


Output

2 8


Input

6 6
1 2
2 3
2 5
5 6
3 4
3 5


Output

3 6

Note

The subway scheme with minimum possible number of lines for the second sample is: 

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 10;
int n, m, vnum, add, par[MAXN], d[MAXN], deg[MAXN], mrk[MAXN];
set<int> adj[MAXN];
bool in_C[MAXN];
vector<pair<int, int> > Bcorrect;
vector<int> lev[MAXN], child[MAXN], cycle[MAXN];
void read() {
  ios ::sync_with_stdio(false);
  cin >> n >> m;
  for (int i = 0; i < m; i++) {
    int v, u;
    cin >> v >> u;
    v--;
    u--;
    adj[v].insert(u);
    adj[u].insert(v);
    deg[u]++;
    deg[v]++;
  }
}
void dfs(int x, int p) {
  par[x] = p;
  mrk[x] = 1;
  set<int>::iterator it;
  for (it = adj[x].begin(); it != adj[x].end(); it++) {
    int cur = (*it);
    if (!mrk[cur])
      dfs(cur, x);
    else if (mrk[cur] == 1 && par[x] != cur)
      Bcorrect.push_back(make_pair(cur, x));
  }
  mrk[x] = 2;
}
void merge() {
  for (int i = 0; i < Bcorrect.size(); i++) {
    int cur = Bcorrect[i].second, root = Bcorrect[i].first;
    while (cur != root) {
      for (set<int>::iterator it = adj[cur].begin(); it != adj[cur].end();
           it++) {
        int nb = (*it);
        adj[nb].erase(cur);
        if (nb != root && nb != par[root]) {
          adj[nb].insert(root);
          adj[root].insert(nb);
        }
      }
      cycle[root].push_back(cur);
      cur = par[cur];
      in_C[root] = 1;
    }
    cycle[root].push_back(root);
  }
  for (int i = 0; i < n; i++) mrk[i] = 0;
}
void another_dfs(int x, int L) {
  lev[L].push_back(x);
  mrk[x] = 1;
  for (set<int>::iterator it = adj[x].begin(); it != adj[x].end(); it++)
    if (!mrk[(*it)]) {
      another_dfs((*it), L + 1);
      child[x].push_back((*it));
    }
}
void solve() {
  for (int L = n; L >= 0; L--)
    for (int mem = 0; mem < lev[L].size(); mem++) {
      int cnt = 0, cur = lev[L][mem];
      vnum++;
      for (int i = 0; i < child[cur].size(); i++) {
        int ch = child[cur][i];
        if (child[ch].size() % 2 == 1) cnt++;
        d[cur] += d[ch];
      }
      d[cur] -= cnt / 2;
      if (cnt % 2 == 1)
        d[cur] += (child[cur].size() - cnt) / 2;
      else if (cnt % 2 == 0)
        d[cur] += (child[cur].size() - cnt + 1) / 2;
    }
}
int calc_cycle() {
  int C = 0;
  for (int i = 0; i < n; i++) {
    int odd = 0, deg3 = 0;
    if (in_C[i]) {
      for (int j = 0; j < cycle[i].size(); j++) {
        if (deg[cycle[i][j]] % 2 == 1) odd++;
        if (deg[cycle[i][j]] > 2) deg3++;
      }
      if (odd >= 2)
        C += odd / 2;
      else if (deg3 <= 1)
        C++;
    }
  }
  return C;
}
int main() {
  read();
  dfs(0, -1);
  merge();
  another_dfs(0, 0);
  solve();
  if (vnum == 1) {
    if (in_C[0])
      cout << 1 << ' ' << m << endl;
    else
      cout << 0 << ' ' << m << endl;
    return 0;
  }
  cout << d[0] + calc_cycle() << ' ' << m << endl;
  return 0;
}