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

using namespace std;
using namespace __gnu_pbds;

// #pragma GCCoptimize("O3")
// #pragma GCCtarget("sse4")
// #pragma GCCoptimize("unroll-loops")

#define vi vector<int>
#define PB push_back
#define vll vector<long long>
#define ll long long
#define all(x) x.begin(), x.end()
#define F first
#define S second
#define ld long double
#define vld vector<long double>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define GCD __gcd
#define INT __int128

#define ordered_set tree<ll, null_type, less_equal<ll>, rb_tree_tag,tree_order_statistics_node_update>

const ll mod = 998244353;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const int inf = 1e9;

struct segtree {

    int size;
    vll values;

    void init(int n){
        size = 1;
        while (size <= n) size *= 2ll;
        values.assign(2 * size, -INF);
    }

    void set(int i, ll v, int x, int lx, int rx){
        if (rx - lx == 1){
            values[x] = v;
            return;
        }
        int m = (lx + rx) / 2;
        if (i < m) set(i, v, 2 * x + 1, lx, m);
        else set(i, v, 2 * x + 2, m, rx);
        values[x] = max(values[2 * x + 1], values[2 * x + 2]);
    }

    void set(int i, ll v){
        set(i, v, 0, 0, size);
    }

    ll calc(int l, int r, int x, int lx, int rx){
        if (rx <= l || r <= lx) return -INF;
        if (l <= lx && rx <= r) return values[x];
        int m = (lx + rx) / 2;
        return max(calc(l, r, 2 * x + 1, lx, m), calc(l, r, 2 * x + 2, m, rx));
    }

    ll calc(int l, int r){
        return calc(l, r, 0, 0, size);
    }

};

void solve(int tst){    

    ll n, c, r;
    cin >> n >> c >> r;

    vll a(n);
    string ans = "";

    for (int i = 0; i < n; i++) cin >> a[i];

    ll vora_laagbe = 0, vorte_parbo = c, cur = c;

    for (int i = 0; i < n; i++){
        if (a[i] > c){
            cout << "Impossible\n";
            return;
        }
        cur -= a[i];
        vora_laagbe += a[i];
        vorte_parbo += min(r, c - cur);
        cur += min(r, c - cur);
        if (vora_laagbe > vorte_parbo){
            cout << "Impossible\n";
            return;
        }
    }

    cur = c;

    stack<int> zero;

    vora_laagbe -= c;
    vora_laagbe = max(vora_laagbe, 0ll);

    segtree st;
    st.init(n + 10);

    vll fuel(n + 10);


    for (int i = 0; i < n; i++){
        if (cur >= a[i]){
            // cout << vora_laagbe << "\n";
            cur -= a[i];
            if (vora_laagbe && cur + r <= c){
                cur += r;
                ans += '1';
                vora_laagbe = max(vora_laagbe - r, 0ll);
            }
            else if (i + 1 < n && cur < a[i + 1]){
                vora_laagbe = max(vora_laagbe - min(r, c - cur), 0ll);
                cur += min(r, c - cur);
                ans += '1';
            }
            else {
                ans += '0';
                zero.push(i);
            }
            st.set(i, cur);
            fuel[i] = cur;
        }
        else {
            if (zero.empty()) {
                cout << "Impossible\n";
                return;
            }
            int last = zero.top();
            zero.pop();
            ans[last] = '1';
            ll val1 = min(r, c - fuel[last]);
            ll val2 = c - st.calc(last, i);
            val2 = min(val2, c);
            cur += max(min(val1, val2), 0ll);
            vora_laagbe -= max(min(val1, val2), 0ll);
            if (cur < a[i]){
                cout << "Impossible\n";
                return;
            }
            i--;
        }
    }

    cout << ans << "\n";


}

int main(){

    ios_base::sync_with_stdio(0);
    cin.tie(0);
    // pre();
    int tc = 1;
    cin >> tc;
    for (int i = 1; i <= tc; i++){
        solve(i);
    }
    return 0;
}