#include <bits/stdc++.h>

#ifdef DEBUG
#define PRINT(x)\
    cout<<"func "<<__func__<<": line "<<__LINE__<<": "<<#x<<" = "<<(x)<<endl;
#define PRINTA(a,first,last)\
    cout<<"func "<<__func__<<": line "<<__LINE__<<": "<<#a<<"["<<(first)<<", "<<(last)<<")"<<endl;\
    for (int i=(first);i<(last);++i){cout<<#a<<"["<<i<<"] = "<<(a)[i]<<endl;}
#else
#define PRINT(x)
#define PRINTA(a,first,last)
#endif

#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);--i)
#define REP(i,n) for (int i=0;i<(n);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define MOD 1000000007

using namespace std;

using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;

template <class T, class U> void amax(T& x, U y) {if (x < y) x = y;}
template <class T, class U> void amin(T& x, U y) {if (x > y) x = y;}



template <class T>
struct edge
{
    int to;
    T cost;
    edge(int t, T c = 0) : to(t), cost(c) {}
};

template <class T>
class graph
{
    private:
        const int number_of_nodes;
        const bool is_directed;
    public:
        vector<edge<T> > *edges;
        graph(int number_of_nodes, bool is_directed = true) : number_of_nodes(number_of_nodes), is_directed(is_directed) {
            edges = new vector<edge<T> >[number_of_nodes];
        }
        ~graph() {
            delete [] edges;
        }
        int size() const {return number_of_nodes;}
        void make_edge(int u, int v, T cost) {
            edges[u].push_back(edge<T>(v, cost));
            if (!is_directed) {
                edges[v].push_back(edge<T>(u, cost));
            }
        }
};

template <class T>
T * dijkstra(const graph<T> &g, const int &start)
{
    T *dist = new T[g.size()];
    //vector<T> dist(g.size());
    bool *used = new bool[g.size()]();
    priority_queue<pair<T, int>, vector<pair<T, int> >, greater<pair<T, int> > > q;
    dist[start] = 0;
    q.push(pair<T, int>(0, start));
    used[start] = true;
    while(!q.empty()) {
        pair<T, int> p = q.top();
        q.pop();
        int from = p.second;
        if (dist[from] < p.first) {
            continue;
        }
        for (int i = 0; i < g.edges[from].size(); ++i) {
            int to = g.edges[from][i].to;
            T cost = g.edges[from][i].cost;
            if (!used[to]) {
                dist[to] = dist[from] + cost;
                q.push(pair<T, int>(dist[to], to));
                used[to] = true;
            }
            else if (dist[to] > dist[from] + cost) {
                dist[to] = dist[from] + cost;
                q.push(pair<T, int>(dist[to], to));
            }
        }
    }
    delete[] used;
    return dist;
}




int main(void) {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int N;
    cin >> N;

    //vector<vector<int>> g(N);
    graph<int> g(N, false);

    REP(i, N - 1) {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        g.make_edge(a, b, 1);
        /*
        g[a].pb(b);
        g[b].pb(a);
        */
    }

    int *d1;
    d1 = dijkstra(g, 0);
    /*
    REP(i, N) {
        printf("d1[%d] = %d\n", i, d1[i]);
    }
    */
    int d1_max = -1;
    int v1;
    REP(i, N) {
        if (d1_max < d1[i]) {
            d1_max = d1[i];
            v1 = i;
        }
    }

    int *d2;
    d2 = dijkstra(g, v1);
    int d2_max = -1;
    int v2;
    REP(i, N) {
        if (d2_max < d2[i]) {
            d2_max = d2[i];
            v2 = i;
        }
    }
    PRINT(v1);
    PRINT(v2);
    PRINT(d2_max);

    int diameter = d2_max;

    vector<bool> win(N);
    win[0] = true;
    win[1] = false;
    FOR(i, 2, N) {
        if (win[i - 1] == false || win[i - 2] == false) {
            win[i] = true;
        } else {
            win[i] = false;
        }
    }

    if (win[diameter]) {
        cout << "First" << endl;
    } else {
        cout << "Second" << endl;
    }

    /*
    vector<int> leaf_distance(N, N + 100);
    queue<pii> q;
    REP(i, N) {
        if (g[i].size() == 1) {
            leaf_distance[i] = 0;
            q.push(pii(0, i));
        }
    }

    while (!q.empty()) {
        int d, v;
        tie(d, v) = q.front();
        q.pop();

        if (leaf_distance[v] < d) {
            continue;
        }

        for (int w: g[v]) {
            if (leaf_distance[v] + 1 < leaf_distance[w]) {
                leaf_distance[w] = leaf_distance[v] + 1;
                q.push(pii(leaf_distance[w], w));
            }
        }
    }

    REP(i, N) {
        printf("leaf_distance[%d] = %d\n", i, leaf_distance[i]);
    }
    */
    return 0;
}



Measured memory_bytes: 18132