output_description: Print `First` if Takahashi will win, and print `Second` if Aoki will win.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 b_1
      a_2 b_2
      :
      a_{N-1} b_{N-1}
attempt: class Tree:
      def __init__(self, n, decrement=1):
          self.n = n
          self.edges = [[] for _ in range(n)]
          self.root = None
          self.depth = [-1] * n
          self.size = [1] * n  # 部分木のノードの数
          self.decrement = decrement
  
      def add_edge(self, u, v):
          u, v = u - self.decrement, v - self.decrement
          self.edges[u].append(v)
          self.edges[v].append(u)
  
      def add_edges(self, edges):
          for u, v in edges:
              u, v = u - self.decrement, v - self.decrement
              self.edges[u].append(v)
              self.edges[v].append(u)
  
      def set_root(self, root):
          root -= self.decrement
          self.root = root
          self.par = [-1] * self.n
          self.depth[root] = 0
          self.order = [root]  # 帰りがけに使う
          next_set = [root]
          while next_set:
              p = next_set.pop()
              for q in self.edges[p]:
                  if self.depth[q] != -1:
                      continue
                  self.par[q] = p
                  self.depth[q] = self.depth[p] + 1
                  self.order.append(q)
                  next_set.append(q)
          for p in self.order[::-1]:
              for q in self.edges[p]:
                  if self.par[p] == q:
                      continue
                  self.size[p] += self.size[q]
  
      def diameter(self, path=False):
          # assert self.root is not None
          u = self.depth.index(max(self.depth))
          dist = [-1] * self.n
          dist[u] = 0
          prev = [-1] * self.n
          next_set = [u]
          while next_set:
              p = next_set.pop()
              for q in self.edges[p]:
                  if dist[q] != -1:
                      continue
                  dist[q] = dist[p] + 1
                  prev[q] = p
                  next_set.append(q)
          d = max(dist)
          if path:
              v = w = dist.index(d)
              path = [v + 1]
              while w != u:
                  w = prev[w]
                  path.append(w + self.decrement)
              return d, v + self.decrement, u + self.decrement, path
          else:
              return d
  
      def heavy_light_decomposition(self):
          """
          heavy edge を並べてリストにした物を返す (1-indexed if decrement=True)
          """
          # assert self.root is not None
          self.vid = [-1] * self.n
          self.hld = [-1] * self.n
          self.head = [-1] * self.n
          self.head[self.root] = self.root
          self.heavy_node = [-1] * self.n
          next_set = [self.root]
          for i in range(self.n):
              """for tree graph, dfs ends in N times"""
              p = next_set.pop()
              self.vid[p] = i
              self.hld[i] = p + self.decrement
              maxs = 0
              for q in self.edges[p]:
                  """encode direction of Heavy edge into heavy_node"""
                  if self.par[p] == q:
                      continue
                  if maxs < self.size[q]:
                      maxs = self.size[q]
                      self.heavy_node[p] = q
              for q in self.edges[p]:
                  """determine "head" of heavy edge"""
                  if self.par[p] == q or self.heavy_node[p] == q:
                      continue
                  self.head[q] = q
                  next_set.append(q)
              if self.heavy_node[p] != -1:
                  self.head[self.heavy_node[p]] = self.head[p]
                  next_set.append(self.heavy_node[p])
          return self.hld
  
      def lca(self, u, v):
          # assert self.head is not None
          u, v = u - self.decrement, v - self.decrement
          while True:
              if self.vid[u] > self.vid[v]:
                  u, v = v, u
              if self.head[u] != self.head[v]:
                  v = self.par[self.head[v]]
              else:
                  return u + self.decrement
  
      def path(self, u, v):
          """u-v 間の最短経路をリストで返す"""
          p = self.lca(u, v)
          u, v, p = u - self.decrement, v - self.decrement, p - self.decrement
          R = []
          while u != p:
              yield u + self.decrement
              u = self.par[u]
          yield p + self.decrement
          while v != p:
              R.append(v)
              v = self.par[v]
          for v in reversed(R):
              yield v + self.decrement
  
      def distance(self, u, v):
          # assert self.head is not None
          p = self.lca(u, v)
          u, v, p = u - self.decrement, v - self.decrement, p - self.decrement
          return self.depth[u] + self.depth[v] - 2 * self.depth[p]
  
      def find(self, u, v, x):
          return self.distance(u, x) + self.distance(x, v) == self.distance(u, v)
  
      def path_to_list(self, u, v, edge_query=False):
          """
          パス上の頂点の集合を self.hld 上の開区間の集合として表す
          ここで、self.hld は heavy edge を並べて数列にしたものである
          """
          # assert self.head is not None
          u, v = u - self.decrement, v - self.decrement
          while True:
              if self.vid[u] > self.vid[v]:
                  u, v = v, u
              if self.head[u] != self.head[v]:
                  yield self.vid[self.head[v]], self.vid[v] + 1
                  v = self.par[self.head[v]]
              else:
                  yield self.vid[u] + edge_query, self.vid[v] + 1
                  return
  
      def point(self, u):
          return self.vid[u - self.decrement]
  
      def subtree_query(self, u):
          u -= self.decrement
          return self.vid[u], self.vid[u] + self.size[u]
  
      def draw(self):
          import matplotlib.pyplot as plt
          import networkx as nx
  
          G = nx.Graph()
          for x in range(self.n):
              for y in self.edges[x]:
                  G.add_edge(x + self.decrement, y + self.decrement)
          pos = nx.spring_layout(G)
          nx.draw_networkx(G, pos)
          plt.axis("off")
          plt.show()
  
  
  ##################################################################################################
  import sys
  
  input = sys.stdin.readline
  
  N = int(input())
  T = Tree(N)
  for _ in range(N - 1):
      x, y = map(int, input().split())
      T.add_edge(x, y)
  T.set_root(1)
  
  
  print("Second" if (T.diameter() + 1) % 3 == 2 else "First")
  
problem_description: Statement
  
  Takahashi and Aoki will play a game on a tree. The tree has N vertices
  numbered 1 to N, and the i-th of the N-1 edges connects Vertex a_i and Vertex
  b_i.
  
  At the beginning of the game, each vertex contains a coin. Starting from
  Takahashi, he and Aoki will alternately perform the following operation:
  
    * Choose a vertex v that contains one or more coins, and remove all the coins from v.
    * Then, move each coin remaining on the tree to the vertex that is nearest to v among the adjacent vertices of the coin's current vertex.
  
  The player who becomes unable to play, loses the game. That is, the player who
  takes his turn when there is no coin remaining on the tree, loses the game.
  Determine the winner of the game when both players play optimally.
samples: [{"input": "3\n    1 2\n    2 3", "output": "First\n    \n\nHere is one possible progress of the game:\n\n  * Takahashi removes the coin from Vertex 1. Now, Vertex 1 and Vertex 2 contain one coin each.\n  * Aoki removes the coin from Vertex 2. Now, Vertex 2 contains one coin.\n  * Takahashi removes the coin from Vertex 2. Now, there is no coin remaining on the tree.\n  * Aoki takes his turn when there is no coin on the tree and loses.\n\n* * *"}, {"input": "6\n    1 2\n    2 3\n    2 4\n    4 6\n    5 6", "output": "Second\n    \n\n* * *"}, {"input": "7\n    1 7\n    7 4\n    3 4\n    7 5\n    6 3\n    2 1", "output": "First"}]