template program

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define int int64_t
#define double long double
#define F first
#define S second
#define pb push_back
#define pf push_front
#define ppb pop_back();
#define ppf pop_front();
#define For(n) for(int (i) = 0; (i) < n; (i)++)
#define FOR(i, n) for(i; i < n; i++)
#define YES cout << "YES\n";
#define NO cout << "NO\n";

#pragma GCC optimize("O3")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")

using namespace std;
using namespace __gnu_pbds;

const int N = 1e5;
const int MAX = LLONG_MAX;
const int MIN = LLONG_MIN;
const int MOD = 1e9 + 7;

template<typename T>
using orset = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T, typename K>
using ormap = tree <T, K, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

typedef long long ll;
typedef pair <int, int> pii;
typedef vector <int> vi;
typedef deque <int> di;
typedef deque <pii> dii;
typedef map <int, di, greater <int> > mii;
typedef set <int> si;
typedef multiset <int> mi;
typedef string st;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> heap_Dijkstra;

int max_in_array(int n, di a)
{
    int mx = MIN;
    for (int i = 0; i < n; i++)
        mx = max(mx, a [i]);
    return mx;
}

int min_in_array(int n, di a)
{
    int mn = MAX;
    for (int i = 0; i < n; i++)
        mn = min(mn, a [i]);
    return mn;
}

int lcm(int x, int y)
{
    return(x * y / __gcd(x, y));
}

int sqr(int x)
{
    return x * x;
}

double log(double a, double b)
{
    return log(b) / log(a);
}

int binpow(int x, int y)
{
    if (y == 0)
        return 1;
    if (y & 1)
        return x * binpow(x, y - 1);
    else
    {
        int z = binpow(x, y / 2);
        return sqr(z);
    }
}

double binpow (double x, double y, bool d)
{
    return exp(y * log(x));
}

di in(int n, di v)
{
    v.resize(n);
    for (auto &i: v)
        cin >> i;
    return v;
}

void out(di v)
{
    for (auto i: v)
        cout << i << " ";
}

di pref_sum(di v)
{
    di rezult (v.size());
    if (v.empty())
        return rezult;
    rezult [0] = v [0];
    For(v.size())
    {
        if (!i)
            continue;
        rezult [i] = rezult [i - 1] + v [i];
    }
    return rezult;
}

di counting_sort(int n, int k, di v)
{
    int a [k + 1] = {};
    for (int i = 0; i < n; i++)
        a [v [i]]++;
    di rezult;
    for (int i = 0; i <= k; i++)
    {
        while (a [i]--)
            rezult.pb(i);
    }
    return rezult;
}

class graph
{
    public:
        int vertex, edge;
        di distance;
        graph();
        deque <di> gr;
    private:
        deque <bool> visited, used;
    public:
        void DFS(int u)
        {
            visited [u] = 1;
            for (int v = 0; v < gr [u].size(); v++)
            {
                if (!visited [v])
                    DFS(v);
            }
        }
        void BFS(int start)
        {
            queue<int> q;
            q.push(start);
            used [start] = 1;
            distance [start] = 0;
            while (!q.empty())
            {
                int cur = q.front();
                q.pop();
                //Здесь должна быть обработка текущей вершины.
                for (int v: gr[cur])
                {
                    if (!used[v]) {
                        q.push(v);
                        used[v] = 1;
                        distance [v] = distance [cur] + 1;
                    }
                }
            }
        }
};

graph::graph()
{
    cin >> vertex >> edge;
    gr.resize(vertex + 1);
    visited.resize(vertex + 1);
    used.resize(vertex + 1);
    distance.resize(vertex + 1);
    visited = {};
    distance = {};
    used = {};
    for (int i = 0; i < edge; i++)
    {
        int u, v;
        cin >> u >> v;
        gr [u].pb(v);
        gr [v].pb(u);
    }
}

class w_graph
{
    public:
        int vertex, edge;
        di distance;
        w_graph();
        vector <vector <pair <int, int> > > gr;
        void Dijkstra(int start)
        {
            for (int i = 1; i <= vertex; i++)
                distance [i] = MAX;
            distance [start] = 0;
            heap_Dijkstra q;
            q.push({0, start});
            while (!q.empty()) {
                pair<int, int> c = q.top();
                q.pop();
                int dst = c.first, v = c.second;
                if (distance [v] < dst)
                    continue;
                for (pair<int, int> e: gr[v]) {
                    int u = e.first, len_vu = e.second;

                    int n_dst = dst + len_vu;
                    if (n_dst < distance [u]) {
                        distance [u] = n_dst;
                        q.push({n_dst, u});
                    }
                }
            }
        }
};

w_graph::w_graph()
{
    cin >> vertex >> edge;
    gr.resize(vertex + 1);
    distance.resize(vertex + 1);
    distance = {};
    for (int i = 0; i < edge; i++)
    {
        int u, v, far;
        cin >> u >> v >> far;
        gr [u].pb({v, far});
        gr [v].pb({u, far});
    }
}

class SegmentTree
{
    public:
        int n;
        int32_t tree [4 * N + 1] = {};
        void tree_build(di a, int v, int l, int r)
        {
            if (l == r)
            {
                tree [v] = a [l];
                return;
            }
            int mid = (l + r) / 2;
            tree_build(a, v * 2, l, mid);
            tree_build(a, v * 2 + 1, mid + 1, r);
            tree [v] = tree [v * 2] + tree [v * 2 + 1];
        }
        void tree_build(int a [], int v, int l, int r)
        {
            if (l == r)
            {
                tree[v] = a[l];
                return;
            }
            int mid = (l + r) / 2;
            tree_build (a, v * 2, l, mid);
            tree_build (a, v * 2 + 1, mid + 1, r);
            tree [v] = tree [v * 2] + tree [v * 2 + 1];
        }
        void tree_update(int v, int l, int r, int where, int what)
        {
            if (l == r)
            {
                tree [v] = what;
                return;
            }
            int mid = (l + r) / 2;
            if (mid >= where)
                tree_update(v * 2, l, mid, where, what);
            else
                tree_update(v * 2 + 1, mid + 1, r, where, what);
            tree [v] = tree [v * 2] + tree [v * 2 + 1];
        }
        int tree_request(int v, int l, int r, int rl, int rr)
        {
            if (rl > rr)
                return 0;
            if (l == rl && r == rr)
                return tree [v];
            int mid = (l + r) / 2;
            return tree_request(v * 2, l, mid, rl, min(mid, rr)) + tree_request(v * 2 + 1, mid + 1, r, max(mid + 1, rl), rr);
        }
};

void solve()
{

}

int32_t main()
{
    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    #ifdef FILE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    int t;
    cin >> t;
    while (t--)
        solve();
}