#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n==0) return Mint(1);
    Mint y = pow(n>>1); // pow(n/2)を計算する
    y *= y;
    if (n%2==1) y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return a.pow(mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};

struct edge {
  int src;
  int dst;
  int coin;
};
//bool bomb[300004][300004];
int main() {
  int N;
  std::cin >> N;
  std::vector<int > edges[200004];
  int a, b;
  for (int i=0; i<N-1; i++) {
    std::cin >> a >> b;
    a--;
    b--;
    edges[a].push_back(b);
    edges[b].push_back(a);
  }
  std::vector<int > dist(N, -1);
  std::queue<int > queue;
  queue.push(0);
  queue.push(-1);
  int d = 1;
  dist[0] = 0;
  while(queue.size()>1) {
    // printf("queue size=%d\n", queue.size());
    if (queue.front()==-1) {
      queue.pop();
      d++;
      queue.push(-1);
    }
    int v = queue.front();
    queue.pop();
    for (int vv :edges[v]) {
      if (dist[vv]==-1) {
        dist[vv] = d;
        queue.push(vv);
        // printf("push %d\n", vv);
      }
    }
  }
  int leaf1;
  int distmax = -1;
  for (int i=0; i<N; i++) {
    if (dist[i]>distmax) {
      distmax = dist[i];
      leaf1 = i;
    }
  }
  // printf("leaf1=%d\n", leaf1);
  dist = std::vector<int >(N, -1);
  while(queue.size()>0) queue.pop();
  queue.push(leaf1);
  queue.push(-1);
  dist[leaf1] = 0;
  d = 1;
  while(queue.size()>1) {
    // printf("queue size=%d\n", queue.size());
    if (queue.front()==-1) {
      queue.pop();
      d++;
      queue.push(-1);
    }
    int v = queue.front();
    queue.pop();
    for (int vv :edges[v]) {
      if (dist[vv]==-1) {
        dist[vv] = d;
        queue.push(vv);
        // printf("push %d\n", vv);
      }
    }
  }
  distmax = -1;
  for (int i=0; i<N; i++) {
    distmax = std::max(distmax, dist[i]);
  }
  // printf("distmax=%d\n", distmax);
  printf("%s\n", (distmax%3==1)?"Second":"First");
  return 0;
}

Measured memory_bytes: 16956