//
// Created by Andrei on 02/11/2020.
//
//pscnv
/*#include<iostream>
#define Mmax 500005
#define Nmax 250005
using namespace std;
typedef struct Muchie {int e1,e2,cost;};
Muchie G[Mmax];
int n,m,x,y,h[Nmax],tata[Nmax];

void read()
{
    freopen("pscnv.in","r",stdin);
    scanf("%d %d %d %d",&n,&m,&x,&y);
    for(int i=1;i<=m;++i) {
        scanf("%d %d %d", &G[i].e1, &G[i].e2, &G[i].cost);
    }
}

void CombHeap(int i,int k)
{
    int tata=i,fiu=i*2;
    Muchie v=G[i];
    while(fiu<=k)
    {
        if(fiu<k)
            if(G[fiu].cost<G[fiu+1].cost) fiu++;
        if(v.cost<G[fiu].cost)
        {
            G[tata]=G[fiu];
            tata=fiu;
            fiu=fiu*2;
        }
        else fiu=k+1;
    }
    G[tata]=v;
}

void create_heap()
{
    for(int i=m/2;i;i--)
        CombHeap(i,m);
}

void heapsort()
{
    Muchie aux;
    create_heap();
    for(int i=m;i>1;i--)
    {
        aux=G[1];
        G[1]=G[i];
        G[i]=aux;
        CombHeap(1,i-1);
    }
}

void Union_ponderare(int x,int y)
{
    if(h[x]>h[y]) tata[y]=x;
    else
    {
        tata[x]=y;
        if(h[x]==h[y]) h[y]++;
    }
}


int Find_compresie(int x)
{
    int r=x,y=x,help;
    while(tata[r]) r=tata[r];
    while(y!=r)
    {
        help=tata[y];
        tata[y]=r;
        y=help;
    }
    return r;
}


int main()
{
    read();
    heapsort();
    int i=1,ans=0,j=0;
    //while(Find_compresie(x)!=Find_compresie(y))
    while(j<n)
    {
        if(Find_compresie(G[i].e1)!=Find_compresie(G[i].e2))
        {
            ans=G[i].cost;
            ++j;
            Union_ponderare(Find_compresie(G[i].e1),Find_compresie(G[i].e2));
        }
        i++;
    }
    cout<<n;
}*/

//diametrul unui arbore
//resubmit
#include<iostream>
#include<fstream>
#include<vector>
using namespace std;
const int N=1e5+4;
ifstream fin("darb.in");
ofstream fout("darb.out");
vector<int> G[N];
bool viz[N];
int n,d[N],dmax;

inline void read()
{
    int x,y,i;
    fin>>n;
    for(i=1;i<=n;i++)
    {
        fin>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
}

void dfs(int x)
{
    viz[x]=1;
    for(std::vector<int>::iterator it=G[x].begin();it!=G[x].end();it++)
    {
        if(!viz[*it])
        {
            d[(*it)]=d[x]+1;
            dfs(*it);
        }
    }
}

void solve()
{
    int ret,i;
    d[3]=1;
    dfs(3);
    dmax=-1;
    for(i=1;i<=n;i++)
    {
        if(d[i]>dmax)
        {
            dmax=d[i];
            ret=i;
        }
        viz[i]=0;
        d[i]=0;
    }
    //cout<<ret;
    d[ret]=1;
    dfs(ret);
    dmax=-1;
    for(i=1;i<=n;i++)
        if(d[i]>dmax)
        {
            dmax=d[i];
        }

    fout<<dmax;
}

int main()
{
    read();
    solve();
}