#include <bits/stdc++.h>

#define                     endl                '\n'

#define                 debug(x)                std::cerr << __FUNCTION__ << ':'<< __LINE__ << ' ' << #x << " = " << x << endl

#define                 bit(x,i)                ((x) & (1<<i)) 
#define                  LBIT(x)                ((x) & ((x) ^ ((x) - 1)))
#define              HBIT(msb,n)                asm("bsrl %1,%0" : "=r"(msb) : "r"(n))

#define            getI(type, a)                type a;       std::cin >> a
#define        getII(type, a, b)                type a, b;    std::cin >> a >> b
#define    getIII(type, a, b, c)                type a, b, c; std::cin >> a >> b >> c

#define               getL(a, s)                string a; std::getline(std::cin, a, s)
#define         getV(type, T, a)                std::vector<type> a; WT(i, T) {getI(ull, value); a.pb(value);}
#define     getVS(type, T, a, s)                std::vector<type> a; type s = 0; WT(i, T) {getI(ull, value); a.pb(value); s+=value;}

#define                    cendl                std::cout << endl;

#define                  outI(a)                std::cout << a << ' '
#define              outII(a, b)                std::cout << a << ' ' << b << endl
#define          outIII(a, b, c)                std::cout << a << ' ' << b << ' ' << c << endl

#define                 coutI(a)                std::cout << a << endl
#define             coutII(a, b)                std::cout << a << endl << b << endl
#define         coutIII(a, b, c)                std::cout << a << endl << b << endl << c << endl

#define                 TOINT(c)                (c-'0')

#define                    SZ(x)                ((int)((x).size()))
#define                   ALL(v)                v.begin(), v.end()
#define                  RALL(v)                v.rbegin(),v.rend()
#define                 clr(a,x)                std::memset(a, x, sizeof(a)/sizeof(a[0]))
#define                fill(a,x)                std::fill(all(a), x)
#define                find(c,x)                c.find(x) != c.end()
#define               REMAX(a,b)                (a) = max((a), (b))
#define               REMIN(a,b)                (a) = min((a), (b));
#define                last(vec)                vec[SZ(vec) - 1]

#define                       pb                push_back
#define                       mp                std::make_pair
#define                      ins                insert

#define                     W(a)                while (a)
#define                 WT(i, T)                decltype(T) i = 0; while (++i <= T) 
#define                 WG(i, T)                getI(ull, T); WT(i, T)

#define                 FR(i, a)                for (auto &&i : a)
#define               F(i, L, R)                for (decltype(R) i = L; i < R; i++)
#define              FE(i, L, R)                for (decltype(R) i = L; i <= R; i++)
#define              FF(i, L, R)                for (decltype(R) i = L; i > R; i--)
#define             FFE(i, L, R)                for (decltype(R) i = L; i >= R; i--)

#define              IN(i, L, R)                (L < i && i < R) 
#define             INR(i, L, R)                (L < i && i <= R)
#define             LIN(i, L, R)                (L <= i && i < R)
#define            LINR(i, L, R)                (L <= i && i <= R)

#define                      IOS                std::ios_base::sync_with_stdio(0); std::cin.tie(0); std::cout.tie(0); std::cerr.tie(0);

using                         ll        =       long long;
using                         ld        =       long double;
using                        ull        =       unsigned long long;

using                        vll        =       std::vector<ll>;
using                        vld        =       std::vector<ld>;
using                        sll        =       std::set<ll>;
using                        sld        =       std::set<ld>;
using                       usll        =       std::unordered_set<ll>;
using                       usld        =       std::unordered_set<ld>;
using                       vull        =       std::vector<ull>;
using                       sull        =       std::set<ull>;
using                      usull        =       std::unordered_set<ull>;

using                        pll        =       std::pair<ll, ll>;
using                        pld        =       std::pair<ld, ld>;
using                       pull        =       std::pair<ull, ull>;

using                       vpll        =       std::vector<pll>;
using                       vpld        =       std::vector<pld>;
using                      vpull        =       std::vector<pull>;
using                      uspll        =       std::unordered_set<pll>;
using                     uspull        =       std::unordered_set<pull>;
using                      uspld        =       std::unordered_set<pld>;

using                       vvll        =       std::vector<vll>;
using                       vvld        =       std::vector<vld>;
using                      vvull        =       std::vector<vull>;
using                     vvchar        =       std::vector<std::string>;
using                       ssll        =       std::set<sll>;
using                      ssull        =       std::set<sull>;
using                     ussull        =       std::unordered_set<usull>;

template<typename T,typename TT> 
std::ostream& operator<<(std::ostream &s,std::pair<T,TT> t) {
    return s << "("<<t.first<<","<<t.second<<")";
} 
template<typename T> 
std::ostream& operator<<(std::ostream &s, std::vector<T> t){
    ull size = SZ(t);
    F(i, 0, size) {
        s << t[i] << ' ';
    }
    return s; 
}
template<typename T> 
std::ostream& operator<<(std::ostream &s, std::vector<std::vector<T>> t){
    ull size = SZ(t), size0 = SZ(t[0]);
    F(j, 0, size0) {
        s << t[0][j] << ' ';
    }
    F(i, 1, size) {
        s << endl;
        F(j, 0, size0) {
            s << t[i][j] << (j < size0-1 ? ' ' : '\0');
        }
    }
    return s; 
}
template<typename T> 
std::ostream& operator<<(std::ostream &s, std::set<T> t){
    ull size = SZ(t);
    FR(i, t) {
        s << i << ' ';
    }
    return s; 
}
template<typename T> 
std::ostream& operator<<(std::ostream &s, std::set<std::set<T>> t){
    FR(i, t) {
        FR(j, i) {
            s << j << ' ';
        }
        s << endl;
    }
    return s; 
}

int main() 
{
    IOS;

    WG(i, t) {
        getI(ull, n);

    }
}