Language: C++


#pragma GCC optimize ("O3")
#include "bits/stdc++.h"

using namespace std;
using ll = long long int;

#define debugos cout
#define debug(v) {printf("L%d %s > ",__LINE__,#v);debugos<<(v)<<endl;}
#define debugv(v) {printf("L%d %s > ",__LINE__,#v);for(auto e:(v)){debugos<<e<<" ";}debugos<<endl;}
#define debuga(m,w) {printf("L%d %s > ",__LINE__,#m);for(int x=0;x<(w);x++){debugos<<(m)[x]<<" ";}debugos<<endl;}
#define debugaa(m,h,w) {printf("L%d %s >\n",__LINE__,#m);for(int y=0;y<(h);y++){for(int x=0;x<(w);x++){debugos<<(m)[y][x]<<" ";}debugos<<endl;}}
#define all(v) (v).begin(),(v).end()
#define repeat(cnt,l) for(auto cnt=decltype(l)();(cnt)<(l);++(cnt))
#define rrepeat(cnt,l) for(auto cnt=(l)-1;0<=(cnt);--(cnt))
#define iterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);++(cnt))
#define diterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);--(cnt))
const ll MD = 1000000007ll; const long double PI = 3.1415926535897932384626433832795L;
inline void assert_call(bool assertion, function<void()> f) { if (!assertion) { cerr << "assertion fault:" << endl; f(); abort(); } }
template<typename T1, typename T2> inline ostream& operator <<(ostream& o, const pair<T1, T2> p) { o << '(' << p.first << ':' << p.second << ')'; return o; }
template<typename Vec> inline ostream& _ostream_vecprint(ostream& os, const Vec& a) {
	os << '['; for (const auto& e : a) os << ' ' << e << ' '; os << ']'; return os;
}
template<typename T> inline ostream& operator<<(ostream & o, const vector<T> & v) { return _ostream_vecprint(o, v); }
template<typename T, size_t S> inline ostream& operator<<(ostream & o, const array<T, S> & v) { return _ostream_vecprint(o, v); }
template<typename T> inline T& chmax(T & to, const T & val) { return to = max(to, val); }
template<typename T> inline T& chmin(T & to, const T & val) { return to = min(to, val); }
void bye(string s, int code = 0) { cout << s << endl; exit(code); }
mt19937_64 randdev(8901016);
template<typename T, typename Random = decltype(randdev), typename enable_if<is_integral<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random & rand = randdev) { return uniform_int_distribution<T>(l, h)(rand); }
template<typename T, typename Random = decltype(randdev), typename enable_if<is_floating_point<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random & rand = randdev) { return uniform_real_distribution<T>(l, h)(rand); }

#if defined(_WIN32) || defined(_WIN64)
#define getc_x _getc_nolock
#define putc_x _putc_nolock
#elif defined(__GNUC__)
#define getc_x getc_unlocked
#define putc_x putc_unlocked
#else
#define getc_x getc
#define putc_x putc
#endif
#define isvisiblechar(c) (0x21<=(c)&&(c)<=0x7E)
class MaiScanner {
	FILE* fp_;
public:
	inline MaiScanner(FILE* fp) :fp_(fp) {}
	template<typename T> void input_integer(T& var) noexcept {
		var = 0; T sign = 1;
		int cc = getc_x(fp_);
		for (; cc < '0' || '9' < cc; cc = getc_x(fp_))
			if (cc == '-') sign = -1;
		for (; '0' <= cc && cc <= '9'; cc = getc_x(fp_))
			var = (var << 3) + (var << 1) + cc - '0';
		var = var * sign;
	}
	inline int c() noexcept { return getc_x(fp_); }
	inline MaiScanner& operator>>(int& var) noexcept { input_integer<int>(var); return *this; }
	inline MaiScanner& operator>>(long long& var) noexcept { input_integer<long long>(var); return *this; }
	inline MaiScanner& operator>>(string & var) {
		int cc = getc_x(fp_);
		for (; !isvisiblechar(cc); cc = getc_x(fp_));
		for (; isvisiblechar(cc); cc = getc_x(fp_))
			var.push_back(cc);
		return *this;
	}
	template<typename IT> inline void in(IT begin, IT end) { for (auto it = begin; it != end; ++it) * this >> *it; }
};
class MaiPrinter {
	FILE* fp_;
public:
	inline MaiPrinter(FILE* fp) :fp_(fp) {}
	template<typename T>
	void output_integer(T var) noexcept {
		if (var == 0) { putc_x('0', fp_); return; }
		if (var < 0)
			putc_x('-', fp_),
			var = -var;
		char stack[32]; int stack_p = 0;
		while (var)
			stack[stack_p++] = '0' + (var % 10),
			var /= 10;
		while (stack_p)
			putc_x(stack[--stack_p], fp_);
	}
	inline MaiPrinter& operator<<(char c) noexcept { putc_x(c, fp_); return *this; }
	inline MaiPrinter& operator<<(int var) noexcept { output_integer<int>(var); return *this; }
	inline MaiPrinter& operator<<(long long var) noexcept { output_integer<long long>(var); return *this; }
	inline MaiPrinter& operator<<(char* str_p) noexcept { while (*str_p) putc_x(*(str_p++), fp_); return *this; }
	inline MaiPrinter& operator<<(const string& str) {
		const char* p = str.c_str();
		const char* l = p + str.size();
		while (p < l) putc_x(*p++, fp_);
		return *this;
	}
	template<typename IT> void join(IT begin, IT end, char sep = ' ') { for (bool b = 0; begin != end; ++begin, b = 1) b ? *this << sep << *begin : *this << *begin; }
};
MaiScanner scanner(stdin);
MaiPrinter printer(stdout);


//

class Graph {
public:
	size_t n;
	vector<vector<int>> vertex_to;

	Graph(size_t n = 1) :n(n), vertex_to(n) {}

	inline size_t size() const { return n; }
	void resize(size_t _n) { vertex_to.resize(n = _n); }
	void connect(int from, int to) {
		vertex_to[(size_t)from].emplace_back(to);
		vertex_to[(size_t)to].emplace_back(from);
	}
};


template <typename T>
class SparseTable {
public:
	int size;
	const vector<int> log2;
	vector<T> data;
	vector<T> dp;

	SparseTable(int size) :size(size), log2(size + 1), data(size) {
		// for fast calculate log2
		for (int i = 2; i <= size; ++i) {
			log2[i] = log2[i >> 1] + 1;
		}

		dp.resize(size * (log2[size] + 1));
	}

	inline T& operator[](size_t i) { return data[i]; }
	inline T operator[](size_t i)const { return data[i]; }

	void build() {
		int l, i, f, b;
		for (i = 0; i < size; i++) {
			dp[i] = i;
		}
		for (l = 1; (1 << l) <= size; l++) {
			for (i = 0; i + (1 << l) <= size; i++) {
				f = dp[i + size * (l - 1)];
				b = dp[(i + (1 << (l - 1))) + size * (l - 1)];

				dp[i + size * l] = (data[f] <= data[b]) ? f : b; // minimum
			}
		}
	}

	// range [l,r)
	int getminrangeIdx(int l, int r) const {
		int lg = log2[r - l];
		int i1 = dp[l + size * lg];
		int i2 = dp[r - (1 << lg) + size * lg];
		return (data[i1] <= data[i2]) ? i1 : i2; // minimum
	}
};


class LCATable {
	vector<int> visited_;
	vector<int> visited_inv_;
	SparseTable<int> depth_;

public:
	LCATable(const Graph& g, int root = 0) :visited_(g.n * 2), visited_inv_(g.n), depth_(g.n * 2) { build(g, root); }

	int _tour_dfs(const Graph& g, int idx, int from = -1, int step = 0, int dep = 0) {
		depth_[step] = dep;
		visited_inv_[idx] = step;
		visited_[step] = idx;

		for (int to : g.vertex_to[idx]) {
			if (to == from) continue;
			step = _tour_dfs(g, to, idx, ++step, dep + 1);
			depth_[step] = dep;
			visited_[step] = idx;
		}
		return ++step;
	}

	inline void build(const Graph & g, int root = 0) {
		_tour_dfs(g, root);
		depth_.build();
	}

	inline int operator()(int u, int v) const {
		return visited_inv_[u] <= visited_inv_[v] ?
			visited_[depth_.getminrangeIdx(visited_inv_[u], visited_inv_[v])] : operator()(v, u);
	}
};


//


int N;
Graph graph;


//


int dist[200010];
int farv1, farv2;

int termdist[200010];

inline int distanc(int x, int y, const LCATable& lca) {
	return dist[x] + dist[y] - 2*dist[lca(x, y)];
}


//


void fardfs(int idx, int step = 0, int from = -1) {
	dist[idx] = step;
	for (auto to : graph.vertex_to[idx]) {
		if (to == from) continue;
		fardfs(to, step + 1, idx);
	}
}



void input() {
	scanner >> N;
	graph.resize(N);
	repeat(i, N - 1) {
		int u, v;
		scanner >> u >> v; --u; --v;
		graph.connect(u, v);
	}
}



int main() {

	input();

	if (N == 1) bye("First");

	// 直径
	fardfs(0);
	farv1 = distance(dist, max_element(dist, dist + N));
	fardfs(farv1);
	farv2 = distance(dist, max_element(dist, dist + N));
	
	// 端点からの距離+1
	queue<int> qu;
	repeat(i, N) {
		if (graph.vertex_to[i].size() != 1) continue;
		termdist[i] = 1;
		qu.push(i);
	}
	while (!qu.empty()) {
		int i = qu.front(); qu.pop();
		int t = termdist[i];

		for (int to : graph.vertex_to[i]) {
			if (termdist[to] > 0) continue;
			termdist[to] = t + 1;
			qu.push(to);
		}
	}

	// 頂点0からの距離
	fardfs(0);

	// LCA
	LCATable lca(graph);

	auto far = [&](int v) { return max(distanc(v, farv1, lca), distanc(v, farv2, lca)); };

	// solve

	int d = far(farv1);
	if (d % 3 == 2)
		cout << "Second" << endl;
	else
		cout << "First" << endl;

	return 0;
}

Compiler output:
a.cc: In constructor 'SparseTable<T>::SparseTable(int)':
a.cc:133:33: error: assignment of read-only location 'i->((SparseTable<T>*)this)->SparseTable<T>::log2.std::vector<int>::operator[]()'
  133 |                         log2[i] = log2[i >> 1] + 1;