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


using namespace std;
vector<vector<int> >lista_ad_2;
ifstream fin("darb.in");
ofstream gout("darb.out");

class Graf{
private:
    bool orientat;
    int noduri;
    vector< vector<int> > lista_ad;

public:
    Graf ();
    Graf (int noduri,bool o);
    void citire_graf(int m, bool o);
    void BFS(int start);
    void DFS(int start, vector<bool>& p, vector<int>& dist, int d);
    int Conexe(int n, int s);
    void DFSsort(int s, vector<int>& p, stack<int>& st);
    void SortTopologica(int n);
    void DFSt(int s, vector<int>& p,vector<vector<int> >&s2, int ctc);
    void CTC();
    pair<int,int> DistMax(vector<int> d);
    void diam();
};
Graf :: Graf ()
{
    orientat = 1;
    vector < vector<int> > aux;
    noduri = 0;
    lista_ad =  aux;

}

Graf :: Graf (int n, bool orr)
{   orientat = orr;
    noduri = n;
    lista_ad.resize(noduri + 1);
}
void Graf :: citire_graf (int muchii, bool orientat)
{
    int x,y;
    for ( int i = 1; i <= muchii; i++ )
    {
        fin >> x >> y;
        lista_ad[x].push_back(y);
        if (orientat == 0)
            lista_ad[y].push_back(x);
}
}

void Graf :: BFS(int start)
{
    vector <int> dist(noduri+1, -1);
    vector <bool> parcurs(noduri+1, 0);
    queue <int> q;


    dist[start] = 0;
    q.push(start);
    parcurs[start] = 1;

    while (!q.empty())
    {
        for (int j = 0; j < lista_ad[q.front()].size();j++)
        {
            int vecin = lista_ad[q.front()][j];
            if (parcurs[vecin] == 0)
            {
                q.push(vecin);
                parcurs [vecin] = 1;
                dist[vecin] = dist [q.front()] + 1;

            }
        }
        q.pop();}
        for (int i = 1; i <= dist.size()-1;i++)
        {
            gout<< dist[i]<<' ';
        }

    }

void Graf :: DFS(int start, vector<bool>& parcurs, vector<int>& dist, int d)
{
    dist[start] = d;
    parcurs [start] = 1;
    for (int i = 0; i < lista_ad[start].size(); i++)
    {
        if (parcurs[lista_ad[start][i]] == 0 )
            {
                DFS(lista_ad[start][i],parcurs,dist, d+ 1);
            }

    }
}

void Graf ::DFSsort(int start, vector<int>& parcurs, stack<int>& s)
{
    parcurs [start] = 1;
    for (int i = 0; i < lista_ad[start].size(); i++)
    {
        if (parcurs[lista_ad[start][i]] == 0 )
                Graf::DFSsort(lista_ad[start][i],parcurs,s);
    }
s.push(start);
}
/*
int Graf:: Conexe(int noduri, int start)
{
    vector <bool> parcurs1(noduri+1,0);
    int CompConexe = 0;

for(int i = 1; i<=noduri; i++)
{
    if(parcurs1[i] == 0)
        {   CompConexe++;
            Graf::DFS(i, parcurs1);
}}
return CompConexe;
}
*/

void Graf:: SortTopologica(int noduri)
{
    stack <int> s;
    vector<int> parcurs(noduri+1, 0);
    for(int i = 1; i<=noduri; i++)
{
    if(parcurs[i] == 0)
        Graf::DFSsort(i, parcurs, s);
}

while(s.empty()==0)
    {
    gout<<s.top()<<' ';
	s.pop();
	}
}

void Graf :: DFSt(int start, vector<int>& parcurs,vector<vector<int> >& s2, int ctc)
{
    parcurs[start] = 2;
    s2[ctc].push_back(start);
        for(int i = 0; i < lista_ad_2[start].size(); i++){
        if(parcurs[lista_ad_2[start][i]] == 1)
            Graf::DFSt(lista_ad_2[start][i], parcurs,s2, ctc);
    }
    }

void Graf::CTC()
{   int ctc = 0;
    stack <int> s;
    vector<int> parcurs(noduri+1, 0);
    vector<vector<int> > s2;
    s2.resize(noduri+1);
    for(int i = 1; i<= noduri; i++)
        if(parcurs[i] == 0)
            Graf::DFSsort(i, parcurs, s);

    while (s.empty() == 0)
    {
        int x = s.top();
        if(parcurs[x] == 1)
        {
            ctc++;
            Graf::DFSt(x,parcurs,s2,ctc);

        }
        s.pop();
    }


    gout<<ctc;
        for (int i = 0; i < s2.size(); i++)
    {gout<<'\n';
       if (s2[i].size() != 0)
        {
           for (int j = 0; j < s2[i].size(); j++)
              gout << s2[i][j] << ' ';
        }
    }
}



void SortareDescrescator(vector <int>& a)
{
    sort(a.begin(), a.end(), greater<int>());
}

int HavelRez(vector<int> sir_grade)
{
while(sir_grade[0] != 0 )
    {
    int fst = sir_grade[0];
    sir_grade.erase(sir_grade.begin());
    if (fst > sir_grade.size())
        return 0;
    for(int i = 0; i < fst; i++)
            {sir_grade[i]--;
            if(sir_grade[i] == -1)
                return 0;
            }
        SortareDescrescator(sir_grade);
    }

return 1;
}

void Havel()
{int n,x;
    cin>>n;
    vector <int> sir_grade;
    for(int i = 0; i < n; i++)
    {
        cin>>x;
        sir_grade.push_back(x);
    }
     SortareDescrescator(sir_grade);
    if (HavelRez(sir_grade) == 1)
        cout<<"Da, se poate forma un graf";
    else cout<<"Nu se poate forma un graf";
}

pair<int,int> Graf::DistMax(vector<int> dist) {

    int maxim = 0, nod = 0;
    for(int i=1;i<=noduri;++i) {
        if (dist[i] > maxim) {
    maxim = dist[i];
    nod = i;
}
}
return make_pair(maxim, nod);
}


void Graf:: diam()
{
    int x;
    vector <bool> parcurs(noduri+1,0);
    vector <int> dist(noduri+1, 0);

    Graf::DFS(1, parcurs, dist, 0);
    pair<int,int> nod1 = DistMax(dist);
    for(int i=1; i<=noduri; i++)
    {
        parcurs[i] = 0;
        dist[i] = 0;
    }
    Graf::DFS(nod1.second, parcurs, dist, x);
    pair<int,int> nod2 = DistMax(dist);
    gout << nod2.first + 1 << '\n';

}
int main()
{int n;
fin>>n;
    Graf g(n,0);
    g.citire_graf(n-1, 0);
    g.diam();

    /*
11
1 2
1 3
1 4
2 5
3 6
4 7
5 8
5 9
6 10
10 11
    */
    return 0;
}