#include <iostream>
#include <fstream>
#include <bits/stdc++.h>

using namespace std;

class graf {

protected:
    int noduri, muchii;
    vector < vector < int >> adiacenta;

public:
    // Constructor cu matrice de adiacenta data
    graf(vector < vector < int >> listaAdiacenta, int noduri, int muchii): adiacenta(listaAdiacenta), noduri(noduri), muchii(muchii) {};

    // Constructor fara matrice de adiacenta, se cu initalizeaza una goala
    graf(int noduri, int muchii): adiacenta(noduri + 1), noduri(noduri), muchii(muchii) {};

    vector < int > bfs(int);
    int dfs();

};

class graf_neorientat : public graf{
private:
    void dfsbiconex(int, vector < int >&, vector < int >&, stack < pair < int, int >>&, int&, vector < string >&);
    void dfsCriticalConnections(int tata, vector < int >&, vector < int >&, int&, vector < vector < int >>&, vector < int >&);

public:
    graf_neorientat(vector < vector < int >> listaAdiacenta, int noduri, int muchii): graf(listaAdiacenta, noduri, muchii) {};
    graf_neorientat(int noduri, int muchii): graf(noduri, muchii) {};

    friend istream& operator>>(istream&, graf_neorientat&);

    vector < string > biconex();

    vector < vector < int >> criticalConnections();

    int darb ();
};

istream& operator>>(istream& in, graf_neorientat& g) {
    for (int i = 0; i < g.muchii; i++) {
        int aux1, aux2;
        in >> aux1 >> aux2;
        g.adiacenta[aux1].push_back(aux2);
        g.adiacenta[aux2].push_back(aux1);
    }
    return in;
}

vector < int > graf :: bfs(int start) {
    vector < int > rasp(noduri + 1, -1);
    vector < int > vis(noduri + 1);
    queue < int > q;
    vis[start] = 1;
    q.push(start);
    rasp[start] = 0;

    // Se baga pe rand in queue toate nodurile nevizitate ale nodului din capul queue-ului, si se noteaza timpul la care se ajunge la ele
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        for (int i: adiacenta[curr]){
            if (vis[i] == 0) {
                vis[i] = 1;
                q.push(i);
                rasp[i] = rasp[curr] + 1;
            }
        }
    }
    return rasp;
}

int graf_neorientat :: darb(){
    vector<int> v(bfs(1));
    int m = 0, nod = 0;
    for(int i = 1; i <= noduri; i++){
        if(v[i] > m){
            m = v[i];
            nod = i;
        }
    }
    v = bfs(nod);
    m = 0;
    for(auto i : v){
        m = max(i, m);
    }
    return m+1;
}

void darbDriver() {
    // https://infoarena.ro/problema/darb
    // Citire
    ifstream in ("darb.in");
    ofstream out("darb.out");

    int n, m, a, b;
    in >> n;
    vector < vector < int >> listaAdiacenta(n + 1);

    while(in >> a >> b){
        listaAdiacenta[a].push_back(b);
        listaAdiacenta[b].push_back(a);
    }

    graf_neorientat x(listaAdiacenta, n, m);

    out << x.darb();
}

int main() {
    // Se apeleaza functia corespunzatoare problemei
    darbDriver();
    return 0;
}