#include <iostream>
#include <vector>
#include <queue>
#define INF (1 << 29) ///Significa 1x(2^29)

using namespace std;

struct Grafo
{
    vector <vector <int> > adj;
    vector <int> dist; ///Vector de distancias
    int nodos, aristas;
    void leer()
    {
        cin >> nodos >> aristas;
        adj.resize(nodos+1);
        dist = vector <int> (nodos+1, INF);
        int desde, hacia;
        for(int i=0; i<aristas; i++)
        {
            cin >> desde >> hacia;
            adj[desde].push_back(hacia);
            adj[hacia].push_back(desde);
        }
    }

    void BFS(int n)
    {
        dist[n] = 0;
        queue <int> cola;
        cola.push(n);

        while(cola.size())
        {
            n = cola.front();
            cola.pop();

            for(int i=0; i<adj[n].size(); i++)
            {
                int vecino = adj[n][i];

                if(dist[n]+1 < dist[vecino])
                {
                    dist[vecino] = dist[n]+1;
                    cola.push(vecino);
                }
            }
        }
    }

    int resolver()
    {
        BFS(1);
        int cant = 0;
        for(int i=1; i<dist.size(); i++)
            if(dist[i] < INF)
                cant++;

        return cant;
    }
};

int main()
{
    /**
    Problema:
    Dado un grafo, decir cuales son los nodos que son alcanzables desde el nodo 1.
    **/

    Grafo g;
    g.leer();

    cout << g.resolver() << endl;

    return 0;
}