func_code_string: #include <bits/stdc++.h>   template <typename T>   void MACRO_VAR_Scan(T& t) {     std::cin >> t;   }   template <typename First, typename... Rest>   void MACRO_VAR_Scan(First& first, Rest&... rest) {     std::cin >> first;     MACRO_VAR_Scan(rest...);   }   template <typename T>   void MACRO_VEC_ROW_Init(int n, T& t) {     t.resize(n);   }   template <typename First, typename... Rest>   void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {     first.resize(n);     MACRO_VEC_ROW_Init(n, rest...);   }   template <typename T>   void MACRO_VEC_ROW_Scan(int p, T& t) {     std::cin >> t[p];   }   template <typename First, typename... Rest>   void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {     std::cin >> first[p];     MACRO_VEC_ROW_Scan(p, rest...);   }   template <class T>   inline T CHMAX(T& a, const T b) {     return a = (a < b) ? b : a;   }   template <class T>   inline T CHMIN(T& a, const T b) {     return a = (a > b) ? b : a;   }   template <class T>   std::vector<std::vector<T>> VV(int n, int m, T init = T()) {     return std::vector<std::vector<T>>(n, std::vector<T>(m, init));   }   template <typename S, typename T>   std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {     os <<  (  << p.first <<  ,   << p.second <<  ) ;     return os;   }   using ll = long long;   using ull = unsigned long long;   using ld = long double;   using PAIR = std::pair<ll, ll>;   using PAIRLL = std::pair<ll, ll>;   constexpr ll INFINT = 1 << 30;   constexpr ll INFINT_LIM = (1LL << 31) - 1;   constexpr ll INFLL = 1LL << 60;   constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);   constexpr double EPS = 1e-10;   constexpr ll MOD = 998244353;   constexpr double PI = 3.141592653589793238462643383279;   template <class T, size_t N>   void FILL(T (&a)[N], const T& val) {     for (auto& x : a) x = val;   }   template <class ARY, size_t N, size_t M, class T>   void FILL(ARY (&a)[N][M], const T& val) {     for (auto& b : a) FILL(b, val);   }   template <class T>   void FILL(std::vector<T>& a, const T& val) {     for (auto& x : a) x = val;   }   template <class ARY, class T>   void FILL(std::vector<std::vector<ARY>>& a, const T& val) {     for (auto& b : a) FILL(b, val);   }   std::vector<bool> banned;   std::vector<ll> pairSum;   std::vector<ll> getDiameterPath(const std::vector<std::vector<ll>>& g) {     size_t n = g.size();     std::vector<ll> depth(n), depth2(n);     ll maxDepth = 0, farthest = -1;     std::function<void(std::vector<ll>&, ll, ll)> getDepth =         [&](std::vector<ll>& d, ll v, ll par) {           if (par == -1) {             for (size_t i = 0; i < n; ++i) d[i] = n;             d[v] = 0;             maxDepth = 0, farthest = v;           }           for (auto&& to : g[v])             if (to != par && !banned[to]) {               d[to] = d[v] + 1;               if (PAIR(maxDepth, pairSum[farthest]) < PAIR(d[to], pairSum[to])) {                 maxDepth = d[farthest = to];               }               getDepth(d, to, v);             }         };     ll start = -1;     for (ll i = 0; i < ll(n); ++i)       if (!banned[i]) start = i;     getDepth(depth, start, -1);     getDepth(depth, farthest, -1);     getDepth(depth2, farthest, -1);     const ll R = (maxDepth + 1) / 2;     for (ll i = 0; i < ll(n); ++i) {       if (banned[i]) continue;       if (depth[i] <= R && depth2[i] <= R) {         getDepth(depth, i, -1);         getDepth(depth, farthest, -1);         break;       }     }     std::vector<ll> res(maxDepth + 1);     size_t now = farthest;     while (depth[now] != 0) {       res[depth[now]] = now;       for (auto&& to : g[now])         if (depth[to] + 1 == depth[now]) {           now = to;           break;         }     }     res[depth[now]] = now;     return res;   }   signed main() {     std::ios::sync_with_stdio(false);     std::cin.tie(0);     ;     ll n;     MACRO_VAR_Scan(n);     ;     std::vector<ll> a, b;     MACRO_VEC_ROW_Init(n - 1, a, b);     for (ll w = 0; w < n - 1; ++w) {       MACRO_VEC_ROW_Scan(w, a, b);     };     std::vector<std::vector<ll>> g(n);     for (ll i = 0; i < ll(n - 1); ++i) {       --a[i];       --b[i];       g[a[i]].emplace_back(b[i]);       g[b[i]].emplace_back(a[i]);     }     std::vector<bool> checked(n, false);     for (ll i = 0; i < ll(n); ++i) {       if (g[i].size() >= 3) checked[i] = true;     }     banned = checked;     {       std::vector<bool> deleted(n, false);       std::vector<ll> in(n, 0);       std::queue<ll> que;       for (ll i = 0; i < ll(n); ++i) {         in[i] = g[i].size();         if (g[i].size() == 1) que.push(i), deleted[i] = true;       }       while (!que.empty()) {         ll now = que.front();         que.pop();         for (auto& to : g[now])           if (!banned[to] && !deleted[to]) {             deleted[to] = true;             if (--in[to] <= 1) que.push(to);           }       }       for (ll i = 0; i < ll(n); ++i) banned[i] = !deleted[i];     }     std::vector<ll> depth(n, INFINT);     auto getP = [&](ll start) {       std::vector<PAIR> v;       for (auto& to : g[start])         if (!banned[to]) {           ll dist = 1;           ll pre = start;           ll now = to;           while (true) {             bool ch = false;             for (auto& ne : g[now])               if (ne != pre) {                 ++dist;                 ch = true;                 pre = now;                 now = ne;                 break;               }             if (!ch) break;           }           v.emplace_back(dist, now);         }       std::sort((v).begin(), (v).end());       std::reverse((v).begin(), (v).end());       return std::vector<PAIR>({v[0], v[1]});     };     pairSum.resize(n, 0);     for (ll i = 0; i < ll(n); ++i) {       if (!banned[i]) continue;       ll cnt = 0;       for (auto& to : g[i])         if (banned[to]) ++cnt;       if (cnt == 1) {         auto pp = getP(i);         pairSum[i] = pp[0].first + pp[1].first;       }     }     for (ll i = 0; i < ll(n); ++i) banned[i] = !banned[i];     auto path = getDiameterPath(g);     for (ll i = 0; i < ll(n); ++i) banned[i] = !banned[i];     auto pa(getP(path.front()));     auto pb(getP(path.back()));     std::cout << (pa[0].second + 1);     std::cout <<    ;     std::cout << (pb[0].second + 1);     std::cout <<   n ;     ;     std::cout << (pa[1].second + 1);     std::cout <<    ;     std::cout << (pb[1].second + 1);     std::cout <<   n ;     ;     return 0;   }   