//
//  main.cpp
//  Componente biconexe
//
//  Created by Mara Dascalu on 30/10/2021.
//

#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <set>

using namespace std;

ifstream input("biconex.in");
ofstream output("biconex.out");


 class Graph
{
    int nodes, edges;
    map<int, list<int>> adj;
    int cost[100010];
    queue<int> queue_bfs;
    list<int>:: iterator iter;
    int level[100010] = {0};
    int low_level[100010] = {0};
    stack<pair<int, int>> component_node;

public:

    bool visited[100010] = {0};
    vector<vector<int>> bcc; //vectorul care stocheaza componentele biconexe
    int current = 0;
    
    void set_no_nodes(int n) {nodes = n;}
    int get_no_nodes() {return nodes;}
    void set_no_edges(int n) {edges = n;}
    int get_no_edges() {return edges;}
    
    void addEdge_dg (int a, int b)
    {
        adj[a].push_back(b);
    }

    void addEdge_ug (int a, int b)
    {
        adj[a].push_back(b);
//        adj[a].sort();
        adj[b].push_back(a);
//        adj[b].sort();
    }

    void DFS(int node)
    {
        visited[node] = 1;
        //output<<node<<" ";

        for (iter = adj[node].begin(); iter != adj[node].end(); iter++)
            if( !visited[*iter])
                DFS(*iter);
    }
    
    void afis_adj(int node){
        list<int> :: iterator i;
        for(i = adj[node].begin(); i != adj[node].end(); i++)
            cout<<*i<<" ";
    }

    void BFS (int node)
    {
        memset(cost,  -1, sizeof(cost));
        visited[node] = 1; //marchez nodul curent ca vizitat
        queue_bfs.push(node);
        cost[node] = 0;

        while (!queue_bfs.empty()) {
            node = queue_bfs.front(); //iau nodul din varful cozii
            queue_bfs.pop();

            for (iter = adj[node].begin(); iter != adj[node].end(); iter++) //parcurg toti vecinii sai
                if ( !visited[*iter]) //daca sunt nevizitati
                {
                    visited[*iter] = 1;  //ii marchez ca vizitati
                    queue_bfs.push(*iter);   //ii adaug in coada
                    cost[*iter] = cost[node] + 1;   //calculez costul raportat la "parintele" sau
                }
        }
    }

    void out_cost (int no)
    {
        for (int i = 1; i <= no; i++)
        output<<cost[i]<<" ";
    }
    
    void DFS(int node, int parent)
    {
        visited[node] = 1;
     
     
        level[node] = level[parent] + 1;
        low_level[node] = level[node];
        int child;
     
        for ( iter = adj[node].begin(); iter != adj[node].end(); iter++)
        {
     
     
            child = *iter;
            if (child != parent)
            {
                if (visited[child] == true)  //daca fiul sau a fost deja parcurs si nu este tatal nodului curent, muchia (fiu,nod) este muchie de intoarcere
                {
                    //cout<<"true "<<node<<" "<<*iter<<" "<<level[*iter]<<"\n";
                    if(level[child] < low_level[node])low_level[node] = level[child];  //actualizam valoarea low_level[nod] daca fiul sau se afla mai sus decat el (p[t ca avem muchie de intoarcere
                }
                else //daca fiul sau nu a fost inca parcurs, continuam DFS din fiu
                {
                    component_node.push({node, child});
                    //cout<<"inainte de dfs"<<node<<" "<<*iter<<" "<<level[*iter]<<"\n";
                    DFS(child, node);
     
                    //cout<<"dupa dfs"<<*iter<<" "<<level[*iter]<<"\n";
                    if (low_level[child] < low_level[node])
                        low_level[node] = low_level[child]; //daca la intoarcerea din apel fiul are un nivel de intoarcere mai mic decat al nodului, actualizam low_level[node]
     
                    if (low_level[child] >= level[node])
                    {
                        while( component_node.top().first != node)
                        {
                            bcc[current].push_back(component_node.top().second);
                            component_node.pop();
                        }
                        bcc[current].push_back(component_node.top().second);
                        bcc[current].push_back(component_node.top().first);
                        component_node.pop();
                        //bcc[current].push_back(node);
                        current++;
                        cout << current;
                    }
     
     
     
     
                }
            }
        }
    }
    
}g;


int main(int argc, const char * argv[]) {
    int no_nodes, no_edges, n1, n2;
    input>>no_nodes>>no_edges;
    cout<<no_nodes<<" "<<no_edges<<"\n";
    for (int i = 0 ; i < no_edges; i++)
    {
        input>>n1>>n2;
        g.addEdge_ug(n1, n2);
    }
    
    
    g.DFS(1, 0);
    cout<< g.current;

    return 0;
}