#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int Lim = 10;

map<array<int, 3>, string> dp, mp;

string re;
array<int, 3> freq;

string calc(int k, string s = re) {
    string res;
    for (int i = 0; i + k <= size(s); ++i) {
        res = max(res, s.substr(i, k));
    }
    return res;
}

void rec() {
    if (!re.empty()) {
        for (int k = 1; k <= size(re); ++k) {
            freq[2] = k;
            string res = calc(k);
            if (dp[freq].empty() || dp[freq] > res) {
                dp[freq] = res;
                mp[freq] = re;
            }
        }
    }
    for (int x = 1; x <= 2; ++x) {
        if (freq[x - 1] < Lim) {
            ++freq[x - 1];
            re += char('0' + x);
            rec();
            --freq[x - 1];
            re.pop_back();
        }
    }
}

constexpr int A = 10;

vector<int> put(int n, int rem, bool g = true) {
    vector<int> res(n);
    if (rem == 0) {
        return res;
    } else {
        if (rem == n) {
            return vector(n, 1);
        }
        if (g) {
            res[n - 1] = 1;
            rem -= 1;
            n -= 1;
        }
        if (rem * 2 < n) {
            vector<int> f = put(n, n - rem, false);
            reverse(f.begin(), f.end());
            for (int &x : f) {
                x = 1 - x;
            }
            copy(f.begin(), f.end(), res.begin());
            return res;
        } else {
            int s = rem / (n - rem);
            int rr = n - rem;
            for (int i = 0, p = n - 1; i < rem; ++i) {
                assert(p >= 0);
                res[p--] = 1;
                if (i % s == 0 && rr > 0) {
                    assert(p >= 0);
                    --rr;
                    res[p--] = 0;
                }
            }
            return res;
        }
    }
}

string even(array<int, 3> d) {
    if (d[1] == 0 || d[2] == 0) {
        return string(d[1], '1') + string( d[2], '2');
    }
    if (d[1] > d[2]) {
        string res;
        int cnt = d[1] / d[2];
        int rem = d[1] - d[2] * cnt;
        vector<int> p = put(d[2], rem);
        for (int i = 0; i < d[2]; ++i) {
            res += '2';
            res += string(cnt + p[i], '1');
        }
        return res;
    } else {
        string res;
        int cnt = d[2] / d[1];
        int rem = d[2] - d[1] * cnt;
        vector<int> p = put(d[1], rem);
        reverse(p.begin(), p.end());
        for (int i = 0; i < d[1]; ++i) {
            res += string(cnt + p[i], '2');
            res += '1';
        }
        return res;
    }
}

string smart(int one, int two, int k) {
    int n = one + two;
    int d[3]{0, one, two};
    int x = d[2] ? 2 : 1;
    vector<int> ans(n);

    for (int i = 1; i < k; ++i) {
        ans[n - i] = x;
        if (--d[x] == 0) {
            x -= 1;
        }
    }

    if (d[2] == 0) {
        for (int i = k; i <= n; ++i) {
            ans[n - i] = 1;
        }
    } else {
        string s = even({d[0], d[1], d[2]}) + string(k - 1, '2');
        return s;
    }

    string str;
    for (int i = 0; i < n; ++i) {
        str += char('0' + ans[i]);
    }

    return str;
}

string stupid(int one, int two, int k) {
    return mp[{one, two, k}];
}

void solve() {
    int k;
    cin >> k;

    int d[A]{}, dd[A]{};
    for (int i = 1; i < A; ++i) {
        cin >> d[i];
        dd[i] = d[i];
    }

    const int n = accumulate(d, d + A, 0);
    if (n == 1) {
        for (int i = A - 1; i >= 0; --i) {
            if (d[i]) {
                cout << i << '\n';
                return;
            }
        }
    }
    vector<int> ans(n);

    if (k == 2) {
        ans[n - 1] = A - 1;
        while (!d[ans.back()]) {
            --ans.back();
        }
        --d[ans.back()];
        int x = ans.back();
        while (!d[x]) {
            --x;
        }

        int p = n - 2;
        for (int i = 1; i < x; ++i) {
            while (d[i]--) {
                ans[p--] = i;
                if (d[x] > 0) {
                    ans[p--] = x;
                    --d[x];
                }
            }
        }
        while (d[x]--) {
            ans[p--] = x;
        }
    } else {
        cout << smart(d[1], d[2], k) << '\n';
        return;
    }

    for (int i = 0; i < n; ++i) {
        cout << ans[i];
        --dd[ans[i]];
    }
    for (int x : dd) {
        assert(x == 0);
    }
    cout << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    if (0) {
        rec();

        for (int one = 0; one <= Lim; ++one) {
            for (int two = 0; two <= Lim; ++two) {
                if (!one && !two) {
                    continue;
                }
                for (int k = 1; k <= one + two; ++k) {
                    string wrong = smart(one, two, k);
                    string correct = stupid(one, two, k);
                    string resWrong = calc(k, wrong);
                    string resCorrect = calc(k, correct);
                    if (resWrong != resCorrect) {
                        cout << "found!\n";
                        cout << k << endl << one << " " << two << endl;
                        cout << "wrong: " << wrong << endl << "correct: " << correct << endl;
                        return 0;
                    }
                }
            }
        }
    }

    int test = 1;
    cin >> test;

    while (test--) {
        solve();
    }

    return 0;
}