#include <iostream>
#include <bits/stdc++.h>
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ull unsigned long long
#define int long long
#define pre(a,b) cout<<fixed<<setprecision(a)<<b<<"\n";//a for precision b for answer
//#define mp make_pair
#define max3(x,y,z) max(x,max(y,z))
#define min3(x,y,z) min(x,min(y,z))
#define pb push_back

#define min(a,b) (a<b?a:b)
#define forn(n) for(ll i=0;i<n;i++)
#define ff first
#define ss second
#define MAX 1e18;
#define all(x) (x).begin(),(x).end()
#define lb lower_bound
#define ub upper_bound
#define vmin *min_element
#define vmax *max_element
#define pii pair<int,int>
const int mod = 1e9 + 7;
const int N=1e6+1;
const int N2 = 1e5+1;
#define pi 3.141592653589793238


using namespace std;


int fun (vector<int>&v)
{
    int mini = INT_MAX;
    int n = v.size();
    int s =0;
    vector<int>ans(n);

    //ans.push_back(0);
for(int i=0; i<v.size(); i++)
{

    
       mini = min(v[i],mini);
        s+= v[i];
        
        ans[i] = s*mini ;
   
   if(ans[i]<v[i]*v[i])
   {
   	ans[i] = v[i]*v[i];
   	mini = v[i];
   	s = v[i];
   }
        
        
}

int ams =0;
for(int i=0; i<v.size(); i++)
{
    ams = max(ams,ans[i]);
}
//for(int x:ans) cout<<x<<" ";

    return ams;
 }
 
 

void solve()
{
int n;
cin>>n;
string s1;
string s2;
string s3;

cin>>s1>>s2>>s3;

for(int i=0; i<n; i++)
cout<<'0';


for(int i=0; i<n; i++)
cout<<'1';

cout<<'0';


}
signed  main()
{
IOS;


//generatefibo(80);
//memset(dp,-1,sizeof(dp));
//  freopen("input.txt","r",stdin);
//  freopen("new.txt","w",stdout);
 int t = 1;
cin>>t;

 while(t--)
 {
    IOS;
     solve();
     cout<<endl;
 }
 

 }

//cccccccccccccccccccccccccccccccccccccccc

/* header file */
#include <bits/stdc++.h>
/* config */
namespace config {
__attribute__((constructor)) void _setup_ () noexcept {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout << std::fixed << std::setprecision(10);
}
} // namespace setup
/* iostream */
template<class Tp> std::istream &operator>> (std::istream &is, std::vector<Tp> &v) noexcept { for (Tp &x : v) is >> x; return is; }
template<class Tp> std::ostream &operator<< (std::ostream &os, const std::vector<Tp> &v) noexcept { std::cerr << '['; for (size_t i = 0; i < size(v); i++) { os << v[i]; if (i + 1 != size(v)) os << ' '; } std::cerr << ']'; return os; }
/* chmin / chmax */
template<class Tp, class Compare = std::greater<Tp>> constexpr bool chmin (Tp &a, const Tp &b, Compare comp = Compare{}) noexcept { if (comp(a, b)) { a = b; return true; } return false; }
template<class Tp, class Compare = std::less<Tp>> constexpr bool chmax (Tp &a, const Tp &b, Compare comp = Compare{}) noexcept { return chmin<Tp, Compare>(a, b, comp); }
/* zero judgement */
template<class Tp, Tp ZERO = Tp(0)> constexpr bool zero (const Tp &x) noexcept { return x == ZERO; }
template<class Tp, Tp ZERO = Tp(0), class... Args> constexpr bool zero (const Tp &x, const Args& ...args) noexcept { return zero(x) and zero(args...); }
/* python-like min / max */
template<class... Args> constexpr auto min (const Args&... args) noexcept { return std::min(std::initializer_list<std::common_type_t<Args...>>{args...}); }
template<class... Args> constexpr auto max (const Args&... args) noexcept { return std::max(std::initializer_list<std::common_type_t<Args...>>{args...}); }
/* python-like standard input */
template<class... Args> void input (Args&... args) noexcept { (std::cin >> ... >> args); }
/* python-like standard output */
void print () noexcept { std::cout << '\n'; }
template<class Tp, class... Args> void print (const Tp &first, const Args&... args) noexcept { std::cout << first; (std::cout << ... << (std::cout << ' ', args)); std::cout << '\n'; }
template<class Tp> void drop (const Tp &x) noexcept { std::cout << x << '\n'; std::exit(0); }
/* error output */
void error () noexcept { std::cerr << '\n'; }
template<class Tp, class... Args> void error (const Tp &first, const Args&... args) noexcept { std::cerr << first; (std::cout << ... << (std::cerr << ' ', args)); std::cerr << '\n'; }
template<class Tp> void dumpout (const Tp &x) noexcept { std::cerr << x << '\n'; std::exit(0); }
/* infinity class */
struct { template<class Tp> constexpr operator Tp() noexcept { return std::numeric_limits<Tp>::max() / 2; } constexpr auto operator- () noexcept; } infty;
struct { template<class Tp> constexpr operator Tp() noexcept { return std::numeric_limits<Tp>::lowest() / 2; } constexpr auto operator- () noexcept; } negative_infty;
constexpr auto decltype(infty)::operator- () noexcept { return negative_infty; }
constexpr auto decltype(negative_infty)::operator- () noexcept { return infty; }
/* alias */
template<class Tp> using matrix = std::vector<std::vector<Tp>>;
using i32 = std::int_fast32_t;
using u32 = std::uint_fast32_t;
using i64 = std::int_fast64_t;
using u64 = std::uint_fast64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;

/*----------------------------------------------------------------------< template >----------------------------------------------------------------------*/

int main() {
	int t;
	input(t);
	while (t--) {
		usize n;
		std::string a, b, c;
		input(n, a, b, c);
		print(std::string(n, '0') + std::string(n, '1') + "0");
	}
	return 0;
}