#ifdef aimbot
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#endif
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <queue>
#include <ostream>
#include <istream>
#include <typeinfo>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <limits>
#include <fstream>
#include <array>
#include <list>
#include <bitset>
#include <functional>
#include <random>
#include <cstring>
#include <chrono>
#define random escape__from__random__aetuhoetnuhshe
#define mt make_tuple
#define x first
#define y second
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define umap unordered_map
#define uset unordered_set
#define elif else if
#define len(v) ((int)v.size())
#define f(i, n) for (int i = 0; i < (n); i++)
#define rof(i, n) for (int i = ((n) - 1); i >= 0; i--)
#define apply(v, act) for (auto &x : v) { act; }
#define log(args...) {string s = #args;deque<string> deq;\
string buf = "";int bal = 0;for (char c : s) {\
if (c == '(' || c == '[' || c == '{') {bal++;\
} else if (c == ')' || c == ']' || c == '}') {\
bal--;} else {if (bal == 0) {if (c == ',') {\
deq.pb(buf);buf = "";} else {if (c != ' ') {\
buf += c;}}}}}if (!buf.empty()) {deq.pb(buf);}\
smart_io::precall_print();smart_io::_print(deq, args);}
inline int min(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^x; }
inline int max(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^y; }
inline long long min(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^x; }
inline long long max(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^y; }
#define print \
smart_io::precall_print(); \
cout,
#define scan cin,
#ifdef fast_allocator
const int MAXMEM = 200 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void* operator new(size_t _x) { _ptr += _x; assert(_ptr < MAXMEM); return _memory + _ptr - _x; }
void operator delete (void*) noexcept {}
#endif
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &x) { scanf("%d", &x); }
void fast_scan(long long &x) { scanf("%lld", &x); }
void fast_scan(unsigned long long &x) { scanf("%llu", &x); }
void fast_scan(double &x) { scanf("%lf", &x); }
void fast_scan(long double &x) { scanf("%Lf", &x); }
void fast_scan(char &x) {
scanf("%c", &x);
if (x == '\n') {
fast_scan(x);
}
}
void fast_scan(string &x) {
scanf("%s", string_in_buffer);
x = string(string_in_buffer);
}
template<class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &x : v) fast_scan(x);
}
void fast_print(const int &x) { printf("%d", x); }
void fast_print(const unsigned int &x) { printf("%u", x); }
void fast_print(const long long &x) { printf("%lld", x); }
void fast_print(const unsigned long long &x) { printf("%llu", x); }
void fast_print(const double &x) { printf("%.15lf", x); }
void fast_print(const long double &x) { printf("%.15Lf", x); }
void fast_print(const char &x) { printf("%c", x); };
void fast_print(const string &x) { printf("%s", x.c_str());}
void fast_print(const char v[]) { fast_print((string)v); }
template<class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &x : v) {
fast_print(x);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template<class T, class... Args>
void _print(deque<string> names, T elem, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(elem);
names.pop_front();
_print(names, args...);
}
} //namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace random {
using namespace std::chrono;
mt19937 rng(duration_cast< milliseconds >(
system_clock::now().time_since_epoch()
).count());
uniform_real_distribution<> prob_dist(0.0, 1.0);
};
namespace typedefs {
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef long double ld;
}
namespace numbers_operation {
template<class T>
T floor_mod(T a, T b) {
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
}
using namespace numbers_operation;
using namespace typedefs;
using namespace random;
const int N = 5e5;
int n;
vector<pii> g[N];
vector<int> tsize;
vector<bool> used;
void dfs_size(int v, int _p) {
tsize[v] = 1;
for (pii sub : g[v]) {
if (sub.x == _p) continue;
if (used[sub.x]) continue;
dfs_size(sub.x, v);
tsize[v] += tsize[sub.x];
}
}
pii find_centroid(int v, int _p, int up) {
int _max = up;
for (pii sub : g[v]) {
if (sub.x == _p) continue;
if (used[sub.x]) continue;
_max = max(_max, tsize[sub.x]);
}
pii best = mp(_max, v);
for (pii sub : g[v]) {
if (sub.x == _p) continue;
if (used[sub.x]) continue;
best = min(best, find_centroid(sub.x, v, up + tsize[v] - tsize[sub.x]));
}
return best;
}
vector<pair<int, ll>> con[N];
void go(int v, int _p, ll dist, int root) {
con[v].emplace_back(root, dist);
for (pii sub : g[v]) {
if (sub.x == _p) continue;
if (used[sub.x]) continue;
go(sub.x, v, dist + sub.y, root);
}
}
void compose(int v) {
dfs_size(v, -1);
v = find_centroid(v, -1, 0).y;
go(v, -1, 0, v);
used[v] = true;
for (pii sub : g[v]) {
if (used[sub.x]) continue;
compose(sub.x);
}
}
vector<ll> minA, minB;
void Init(int _n, int *a, int *b, int *d) {
n = _n;
tsize.resize(n);
used.resize(n, false);
minA.resize(n, 1e18);
minB.resize(n, 1e18);
f(i, n - 1) {
g[a[i]].emplace_back(b[i], d[i]);
g[b[i]].emplace_back(a[i], d[i]);
}
compose(0);
}
ll Query(int a, int *x, int b, int *y) {
f(i, a) {
for (auto p : con[x[i]]) {
minA[p.x] = min(minA[p.x], p.y);
}
}
ll result = 1e18;
f(i, b) {
for (auto p : con[y[i]]) {
result = min(result, minA[p.x] + p.y);
}
}
f(i, a) {
for (auto p : con[x[i]]) {
minA[p.x] = 1e18;
}
}
return result;
}
int A[] = {0, 1, 2, 2, 4, 1};
int B[] = {1, 2, 3, 4, 5, 6};
int D[] = {4, 4, 5, 6, 5, 3};
int Q1X[] = {0, 6};
int Q1Y[] = {3, 4};
int Q2X[] = {0, 1, 3};
int Q2Y[] = {4, 6};
// signed main(signed argc, char *argv[]) {
// int n = 7;
// int m = 3;
// Init(n, A, B, D);
// print Query(2, Q1X, 2, Q1Y);
// print Query(3, Q2X, 2, Q2Y);
// }
