#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
#include<map>

using namespace std;
#define int long long
#define lint long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
typedef pair<int,int> P;
const lint inf=1e18+7;
const int MOD=1000000007;
struct Node{
  int no;//number of node
  int col;//color of binary_graph
  long long dist;//distance of arbitrary node
  int group;//group number of disconnected graph
  int indegree;//indegree of this node
  vector<pair<Node*,long long>> child;//chidren of this node
  vector<pair<Node*,int>> par;//parretns of this node
  void build(int i){
    no=i;col=0;dist=inf;
    group=0;indegree=0;
  }
};
bool operator >(const Node &a,const Node &r){
        return a.dist > r.dist;
    }
struct Graph{
    int n;
    bool direct;
    vector<Node> node;
    Graph(int N){
        n=N;
        node.resize(n+1);
        for(int i=1;i<=n;++i){
            node[i].build(i);
        }
    }
    void input(int m,bool flag){
        //choose direct or undirect
        direct=flag;
        for(int i=0;i<m;++i){
            int l=1;
            int a,b;cin>>a>>b;
            node[a].child.push_back({&node[b],l});
            if(!direct){
                node[b].child.push_back({&node[a],l});
            }
            else{
                node[b].par.push_back({&node[a],l});
                node[b].indegree++;
            }
        }
    }
    vector<Node> topological_sort(){
        //return the least lexical order in the topological sorted array
        priority_queue<int,vector<int>,greater<int>> que;
        vector<Node> res;
        for(int i=1;i<=n;++i){
            if(node[i].indegree==0){
                que.push(i);
            }
        }
        while(!que.empty()){
            int buf=que.top();que.pop();
            int num=node[buf].child.size();
            res.push_back(node[buf]);
            for(int i=0;i<num;++i){
                node[buf].child[i].first->indegree--;
                if(node[buf].child[i].first->indegree==0){
                    que.push(node[buf].child[i].first->no);
                }
            }
        }
        return res;
    }
    void dijkstra(int s){
        for(int i=1;i<=n;++i){
            node[i].dist=inf;
        }
        node[s].dist=0;
        priority_queue<Node,vector<Node>,greater<Node>> que;
        que.push(node[s]);
        while(!que.empty()){
            Node buf=que.top();que.pop();
            int num=buf.child.size();
            for(int i=0;i<num;++i){
                if(buf.child[i].first->dist>buf.child[i].second+buf.dist){
                    buf.child[i].first->dist=buf.child[i].second+buf.dist;
                    que.push(*buf.child[i].first);
                }
            }
        }
    }
    bool binary_graph(){
        node[1].col=1;
        queue<Node> que;
        que.push(node[1]);
        bool res=true;
        while(!que.empty()){
            Node buf=que.front();que.pop();
            int num=buf.child.size();
            for(int i=0;i<num;++i){
                if(buf.child[i].first->col==0){
                    buf.child[i].first->col=buf.col*2%3;
                    que.push(*buf.child[i].first);
                }
                else{
                    if(buf.child[i].first->col==buf.col){
                        res=false;
                    }
                }
            }
        }
        return res;
    }
    vector<vector<long long>> warshall_froyd(){
        vector<vector<long long>> dp(n+1,vector<long long>(n+1,inf));
        for(int i=1;i<=n;++i){
            int num=node[i].child.size();
            for(int j=0;j<num;++j){
                dp[i][node[i].child[j].first->no]=node[i].child[j].second;
            }
            dp[i][i]=0;
        }
        for(int k=1;k<=n;++k){
            for(int i=1;i<=n;++i){
                for(int j=1;j<=n;++j){
                    dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
                }
            }
        }
        return dp;
    }
    int dist(){
        int mx=0;int mxind=0;
        dijkstra(1);
        rep1(i,n){
            if(node[i].dist>mx){
                mx=node[i].dist;
                mxind=i;
                //printf("mx=%lld ind=%lld\n",mx,mxind);
            }
        }
        //cout<<mx<<endl;
        dijkstra(mxind);
        int res=0;
        rep1(i,n)res=max(res,node[i].dist);
        return res;
    }
};

signed main(){
  int n;cin>>n;
  Graph g(n);
  g.input(n-1,false);
  g.dijkstra(1);
  int l=g.dist()+1;
  if(n==1){
      cout<<"First"<<endl;
      return 0;
  }
  //cout<<l<<endl;
	if((l-2)%3==0){
        cout<<"Second"<<endl;
    }
    else{
        cout<<"First"<<endl;
    }
  return 0;
}

Measured memory_bytes: 73248