#include <stdio.h>

#pragma GCC optimize("Ofast")
#pragma GCC optimize ("unroll-loops")

static inline int min( int a, int b ) {
    return ( a <= b ? a : b );
}

static inline int max( int a, int b ) {
    return ( a >= b ? a : b );
}

FILE *fin;

int poz, valBuff;
char buff[ ( 1 << 7 ) ];
char nextChar() {
    if( poz == valBuff ) {
        fread( buff, 1, valBuff, fin );
        poz = 0;
    }

    return buff[ poz++ ];
}

bool f[ 100 ];
static inline int readInt() {
    int rez = 0;
    int ch;

    while( !f[ ch = nextChar() ] );
    do
        rez = rez * 10 + ch - '0';
    while( f[ ch = nextChar() ] );

    return rez;
}

//////////////////////////////////////////////////////////////////////////////////////////////

#include <string.h>
#include <vector>
#include <queue>

#define MAX 100000

int dp[ MAX ], n;
bool ok[ MAX ];

std::vector<int> nod[ MAX ];
std::queue<int> q;

int dr, d;
void bfs( int st ) {
    memset( dp, 0, MAX );
    memset( ok, 0, MAX );

    q.push( st );

    dp[ st ] = 1;
    ok[ st ] = true;
    while( !q.empty() ) {
        int el = q.front();
        q.pop();

        for( int i = 0; i < nod[ el ].size(); i++ )
            if( !ok[ nod[ el ][ i ] ] ) {
                q.push( nod[ el ][ i ] );
                ok[ nod[ el ][ i ] ] = true;
                dp[ nod[ el ][ i ] ] = dp[ el ] + 1;

                d = dp[ nod[ el ][ i ] ];
                dr = nod[ el ][ i ];
            }
    }
}

int main()
{
    f[ '0' ] = f[ '1' ] = f[ '2' ] = f[ '3' ] = f[ '4' ] = 1;
    f[ '6' ] = f[ '7' ] = f[ '8' ] = f[ '9' ] = f[ '5' ] = 1;
    valBuff = sizeof( buff );

    fin = fopen( "darb.in", "r" );
    fread( buff, 1, valBuff, fin );
    n = readInt();

    int x, y;
    for( int i = 1; i < n; i++ ) {
        x = readInt();
        y = readInt();
        nod[ x ].push_back( y );
        nod[ y ].push_back( x );
    }
    fclose( fin );

    bfs( 1 );
    bfs( dr );

    FILE *fout = fopen( "darb.out", "w" );
    fprintf( fout, "%d\n", d );
    fclose( fout );
    return 0;
}