#include <bits/stdc++.h>
using namespace std;
// CJX__//
typedef long long ll; // 不开long long 见祖宗
typedef unsigned long long ull;
typedef __int128 i128;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<PII> vPII;
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
#define debug(...) cout << "[debug] " #__VA_ARGS__ " = " << (__VA_ARGS__) << endl;
#define out(x) cout << ((x) ? "YES" : "NO") << endl
#define mod(x, P) (((x) % (P) + (P)) % (P))
#define endl '\n'
#define gcd __gcd
#define lc p << 1
#define rc p << 1 | 1
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define lowbit(x) ((x) & (-x))
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define dep(i, x, n) for (ll i = x; i >= n; i--)
#define mem(a, x) memset(a, x, sizeof a)
const double eps = 1e-5;
const int N = 1e5 + 10, M = 2 * N, K = 26;
const ll MOD = 1e9 + 7, Md3 = 998244353, Md7 = 1e9 + 7, Md9 = 1e9 + 9;
const ll base1 = 131, base2 = 13331;
const int dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1}, dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
const int ddx[8] = {1, 1, 2, 2, -1, -1, -2, -2}, ddy[8] = {2, -2, 1, -1, 2, -2, 1, -1};
template <typename T>
bool cmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <typename T>
bool cmax(T &a, const T &b) { return b > a ? a = b, 1 : 0; }
template <typename T>
void sort_range(vector<T> &v, int l, int r) { sort(v.begin() + l, v.begin() + r + 1); }
/*

*/
ll n;
void solve()
{
    cin >> n;
    rep(i, 1, n) cout << i << " ";
    cout << endl;
}

int main()
{
    IOS;

    int _ = 1;
    cin >> _; // 如果是多组数据
    while (_--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
// CJX__//
typedef long long ll; // 不开long long 见祖宗
typedef unsigned long long ull;
typedef __int128 i128;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<PII> vPII;
#define IOS                  \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
#define debug(...) cout << "[debug] " #__VA_ARGS__ " = " << (__VA_ARGS__) << endl;
#define out(x) cout << ((x) ? "YES" : "NO") << endl
#define mod(x, P) (((x) % (P) + (P)) % (P))
#define endl '\n'
#define gcd __gcd
#define lc p << 1
#define rc p << 1 | 1
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define lowbit(x) ((x) & (-x))
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define dep(i, x, n) for (ll i = x; i >= n; i--)
#define mem(a, x) memset(a, x, sizeof a)
const double eps = 1e-5;
const int N = 1e5 + 10, M = 2 * N, K = 26;
const ll MOD = 1e9 + 7, Md3 = 998244353, Md7 = 1e9 + 7, Md9 = 1e9 + 9;
const ll base1 = 131, base2 = 13331;
const int dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1}, dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
const int ddx[8] = {1, 1, 2, 2, -1, -1, -2, -2}, ddy[8] = {2, -2, 1, -1, 2, -2, 1, -1};
template <typename T>
bool cmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <typename T>
bool cmax(T &a, const T &b) { return b > a ? a = b, 1 : 0; }
template <typename T>
void sort_range(vector<T> &v, int l, int r) { sort(v.begin() + l, v.begin() + r + 1); }

/*

*/

void solve()
{
    ll n, m, h;
    cin >> n >> m >> h;
    vll a(n + 1, 0);
    rep(i, 1, n) cin >> a[i];
    vector<PLL>q;

    rep(i, 1, m)
    {
        ll k, c;
        cin >> k >> c;
        if (a[k] + c > h)
        {
            while(q.size())
            {
                auto [fi,se]=q.back();
                q.pop_back();
                a[fi]-=se;
            }
        }
        else
        {
            a[k] += c;
            q.push_back({k,c});
        }
    }
    rep(i, 1, n) cout << a[i] << " ";
    cout << endl;
}

int main()
{
    IOS;

    int _ = 1;
     cin>>_;//如果是多组数据
    while (_--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
// CJX__//
typedef long long ll; // 不开long long 见祖宗
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> vi;
typedef vector<ll> vll;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define all(x) x.begin(), x.end()
#define INF 0x3f3f3f3f3f3f3f3f
template <typename T>
void sort_range(vector<T> &v, int l, int r) { sort(v.begin() + l, v.begin() + r + 1); }

/*

*/
void solve()
{
    ll n, m, k;
    cin >> n >> m >> k;
    vll a(n + 1, 0), b(m + 2, 0);
    
    // 读入机器人位置
    rep(i, 1, n) {
        cin >> a[i];
    }
    // 读入尖刺位置
    rep(i, 1, m) {
        cin >> b[i];
    }
    
    // 设置哨兵，防止越界，简化二分边界判断
    b[0] = -INF, b[m + 1] = INF;
    
    // 排序，为了后续二分查找
    sort_range(a, 1, n);
    sort_range(b, 1, m);

    // Lambda: 二分查找 <= x 的最大尖刺 (左边最近)
    auto ckl = [&](ll x) {
        ll l = 0, r = m + 1;
        while (l + 1 < r) {
            ll mid = (l + r) >> 1;
            if (b[mid] <= x) l = mid;
            else r = mid;
        }
        return b[l];
    };

    // Lambda: 二分查找 > x 的最小尖刺 (右边最近)
    // 注意：题意是不重合，所以找 >= 或 > 都可以，这里逻辑是找右侧威胁
    auto ckr = [&](ll x) {
        ll l = 0, r = m + 1;
        while (l + 1 < r) {
            ll mid = (l + r) >> 1;
            if (b[mid] < x) l = mid;
            else r = mid;
        }
        return b[r];
    };

    // dl[d]: 向左走 d 步会死的机器人列表
    // dr[d]: 向右走 d 步会死的机器人列表
    vector<vector<ll>> dl(k + 5), dr(k + 5);
    
    rep(i, 1, n)
    {
        // 计算致死距离
        ll l = a[i] - ckl(a[i]); // 左距离
        ll r = ckr(a[i]) - a[i]; // 右距离
        
        // 只有在 k 步内能撞上的才存入桶中
        if (l <= k) dl[l].push_back(i);
        if (r <= k) dr[r].push_back(i);
    }

    // offset 用于处理负数下标，st 数组记录相对位移是否访问过
    const int offset = 2e5 + 5;
    vector<bool> st(4e5 + 10, false);
    vector<bool> dead(n + 1, false);
    
    st[0 + offset] = true;
    ll far = 0; // 当前相对位移
    ll now = n; // 当前存活数
    
    string op;
    cin >> op;
    
    rep(i, 0, k - 1)
    {
        char s = op[i];
        if (s == 'L')
        {
            far -= 1;
            // 如果这个位置之前没到过（探索新区域）
            if (!st[far + offset])
            {
                st[far + offset] = true;
                ll d = abs(far);
                // 且距离在射程范围内
                if (d <= k)
                {
                    // 结算所有“向左走 d 步死”的机器人
                    for (auto id : dl[d])
                    {
                        if (!dead[id]) // 防止重复死亡
                        {
                            dead[id] = true;
                            now--;
                        }
                    }
                }
            }
        }
        else // s == 'R'
        {
            far += 1;
            if (!st[far + offset])
            {
                st[far + offset] = true;
                ll d = abs(far);
                if (d <= k)
                {
                    // 结算所有“向右走 d 步死”的机器人
                    for (auto id : dr[d])
                    {
                        if (!dead[id])
                        {
                            dead[id] = true;
                            now--;
                        }
                    }
                }
            }
        }
        cout << now << " ";
    }
    cout << endl;
}

int main()
{
    IOS;
    int _ = 1;
    cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// 通用模板部分
typedef long long ll;
typedef vector<ll> vll;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define endl '\n'

void solve()
{
    ll n, q; 
    cin >> n >> q;
    ll len = 1 << n; // 总奶牛数 2^n
    
    // a: 原数组, pre: 前缀异或和数组
    vll a(len + 1, 0), pre(len + 2, 0);
    
    rep(i, 1, len)
    {
        cin >> a[i];
        pre[i] = pre[i - 1] ^ a[i];
    }
    
    while(q--)
    {
        ll b, c; 
        cin >> b >> c;
        
        // 定义分治递归函数
        // l, r: 当前处理的区间范围
        auto fz = [&](auto&& self, int l, int r) -> ll
        {
            if(l == r) return 0; // 叶子节点，没有对手，头顶数量为0
            
            int mid = (l + r) >> 1;
            ll sz = (r - l + 1) / 2; // 半区大小（对手栈的大小）
            
            // 计算左右半区原本的异或和
            ll L = pre[mid] ^ pre[l - 1];
            ll R = pre[r] ^ pre[mid];
            
            ll res = 0;
            
            if(b <= mid) // 目标奶牛在左半区
            {
                // 先递归下一层，获取底层的累积结果
                res = self(self, l, mid);
                
                // 修正左半区的异或和：去掉原来的 a[b]，加上新的 c
                L = L ^ a[b] ^ c;
                
                // 判断胜负：左区 vs 右区
                // 题目规则：值大的赢，相等左边赢。
                // 如果 L < R，说明左边输了。
                // 左边输了，右边整个栈(大小sz)会压在左边头上。
                if(L < R) res += sz;
            }
            else // 目标奶牛在右半区
            {
                res = self(self, mid + 1, r);
                
                // 修正右半区的异或和
                R = R ^ a[b] ^ c;
                
                // 如果 R <= L，说明右边输了（注意平局也是左边赢，所以右边输是 <=）
                // 右边输了，左边整个栈(大小sz)会压在右边头上。
                if(R <= L) res += sz;
            }
            
            return res;
        };
        
        // 从整个区间开始递归
        cout << fz(fz, 1, len) << endl;
    }
}

int main()
{
    IOS;
    int _ = 1;
    cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll; 
typedef vector<ll> vll;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define all(x) x.begin(), x.end()
#define endl '\n'

const int N = 1000010; 
int cnt[N]; // 用于统计全局每个数字出现的次数

void solve()
{
    int n;
    cin >> n;
    
    vector<vector<int>> a(n);
    vector<int> pmex(n);
    
    ll sum = 0; // 初始所有数组 MEX 之和
    ll len = 0; // 所有元素的总个数
    
    // 1. 读入数据并预处理
    rep(i, 0, n - 1)
    {
        int l;
        cin >> l;
        a[i].resize(l);
        len += l; 
        
        rep(j, 0, l - 1)
        {
            cin >> a[i][j];
            cnt[a[i][j]]++; // 全局计数
        }
        sort(all(a[i])); // 排序方便求 MEX
    }

    // 2. 计算初始 MEX
    rep(i, 0, n - 1)
    {
        int m = 0;
        for (int x : a[i])
        {
            if (x == m) m++;
            else if (x > m) break;
        }
        pmex[i] = m;
        sum += m;
    }

    // 3. 初始基准答案：假设 MEX 都不变
    // 总操作次数 = 总元素数 * (n-1) 个目标数组
    ll ans = sum * len * (n - 1);

    // 4. 处理移除元素导致的 MEX 减小
    rep(i, 0, n - 1)
    {
        int sz = a[i].size();
        rep(j, 0, sz - 1)
        {
            int x = a[i][j];
            
            // 检查 x 是否只出现了一次
            bool check = true;
            if (j > 0 && a[i][j - 1] == x) check = false;
            if (j < sz - 1 && a[i][j + 1] == x) check = false;

            // 如果 x 是唯一的，且 x < MEX，移除它会导致 MEX 降低为 x
            if (check && x < pmex[i])
            {
                // 每次操作都会少算 (pmex[i] - x)
                // 共有 n-1 个接收数组，所以减去 (n-1) 倍
                ans -= (ll)(pmex[i] - x) * (n - 1);
            }
        }
    }

    // 5. 处理添加元素导致的 MEX 增加
    rep(i, 0, n - 1)
    {
        int tag = pmex[i]; // 当前数组缺少的数
        ll num = cnt[tag]; // 全局有多少个这个数可以被移过来
        
        if (num > 0)
        {
            // 如果把 tag 移进来，MEX 会变成多少？
            int nmex = tag + 1;
            
            // 在有序数组中找下一个缺失的数
            auto it = upper_bound(all(a[i]), tag);
            int idx = it - a[i].begin();
            
            while (idx < a[i].size())
            {
                if (a[i][idx] == nmex)
                {
                    nmex++;
                    // 跳过重复的数字
                    while (idx < a[i].size() && a[i][idx] < nmex) idx++;
                }
                else
                {
                    break; 
                }
            }

            // 增加的贡献 = (新MEX - 旧MEX) * 来源数的个数
            ans += (ll)(nmex - pmex[i]) * num;
        }
    }

    cout << ans << endl;

    // 清空计数数组，为下一组数据做准备
    rep(i, 0, n - 1)
    {
        for (int x : a[i]) cnt[x]--;
    }
}

int main()
{
    IOS;
    int _ = 1;
    cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// 通用模板部分
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> PLL;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define rep(i, x, n) for (ll i = x; i <= n; i++)
#define all(x) x.begin(), x.end()
#define endl '\n'

// 更新最大值函数
template <typename T>
bool cmax(T &a, const T &b) { return b > a ? a = b, 1 : 0; }

void solve()
{
    ll n, k;
    cin >> n >> k;
    
    // a: 技能值, pre: 前缀和
    vll a(n + 1, 0), pre(n + 1, 0);
    vector<PLL> q; // 存储“强者”：{下标, 需要的技能阈值}
    
    rep(i, 1, n)
    {
        cin >> a[i];
        pre[i] = pre[i - 1] + a[i];
        
        // 如果当前牛比前面所有牛的总和还大，它是一个潜在的威胁（强者）
        // 记录它，因为它可能会迫使别人消耗作弊次数
        if (a[i] > pre[i - 1])
        {
            q.push_back({i, a[i] - pre[i - 1]});
        }
    }
    
    // 逆序处理，方便后续遍历
    reverse(all(q));
    
    // 核心判定函数：在区间 [l, r] 内，奶牛 pos 是否有足够的作弊次数 cnt
    auto calc = [&](ll l, ll r, ll pos, ll cnt) -> ll
    {
        if (cnt < 0) return 0;
        
        // 遍历所有“强者”，检查是否会消耗作弊次数
        for (auto p : q)
        {
            auto [x, y] = p; // x: 强者下标, y: 阈值
            if (x != pos)
            {
                // 如果强者 x 在 pos 后面，或者 pos 打不过强者 x 的阈值 y
                // 这里的逻辑是：如果 x 是一个威胁，我们需要消耗一次作弊机会
                // (x > pos) 表示 x 在 pos 后面，如果不作弊可能会输
                // (a[pos] < y) 表示 pos 即使在前面，初始值太小也打不过 x
                if (x > pos || a[pos] < y)
                    cnt--;
                
                // 如果作弊次数不够了，说明当前的 l 位置不可行
                // 我们需要把 l 往后推，尝试缩短区间
                if (cnt < 0)
                    cmax(l, x + (x < pos));
            }
        }
        // 返回有效区间的长度
        return max((ll)0, r - l + 1);
    };

    // 二分查找函数：找到第一个前缀和 >= x 的位置
    // 用于确定奶牛 i 能凭实力（或一次作弊）吞噬到的最远边界
    auto f = [&](ll x) -> ll
    {
        ll l = 0, r = n + 1;
        while (l + 1 < r)
        {
            ll mid = l + (r - l) / 2;
            if (pre[mid] >= x)
                r = mid;
            else
                l = mid;
        }
        return r;
    };

    rep(i, 1, n)
    {
        ll pos = 0;
        // 分情况确定临界点 pos
        if (pre[i - 1] >= a[i])
        {
            // 情况1：a[i] 较小，打不过前面的前缀和
            // 它需要消耗作弊次数才能赢下第一场
            // pos 是它能成长到的位置
            pos = f(a[i]);
        }
        else
        {
            // 情况2：a[i] 很大，能直接吃掉前面的前缀
            // 它的技能会翻倍增长，pos 会更远
            pos = f(2 * a[i]) - 1;
        }
        
        if (pos > n) pos = n;
        
        // 计算两段区间的贡献：
        // 1. [1, pos]: 在这个范围内，它可能只需要 k 次作弊
        // 2. [pos+1, n]: 在这个范围内，它可能需要额外的一次作弊（因为初始就落后了），所以是 k-1
        ll ans = calc(1, pos, i, k) + calc(pos + 1, n, i, k - 1);
        cout << ans << " ";
    }
    cout << endl;
}

int main()
{
    IOS;
    int _ = 1;
    cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}