During the hypnosis session, Nicholas suddenly remembered a positive integer n, which doesn't contain zeros in decimal notation. 

Soon, when he returned home, he got curious: what is the maximum number of digits that can be removed from the number so that the number becomes not prime, that is, either composite or equal to one?

For some numbers doing so is impossible: for example, for number 53 it's impossible to delete some of its digits to obtain a not prime integer. However, for all n in the test cases of this problem, it's guaranteed that it's possible to delete some of their digits to obtain a not prime number.

Note that you cannot remove all the digits from the number.

A prime number is a number that has no divisors except one and itself. A composite is a number that has more than two divisors. 1 is neither a prime nor a composite number.

Input

Each test contains multiple test cases.

The first line contains one positive integer t (1 ≤ t ≤ 10^3), denoting the number of test cases. Description of the test cases follows.

The first line of each test case contains one positive integer k (1 ≤ k ≤ 50) — the number of digits in the number.

The second line of each test case contains a positive integer n, which doesn't contain zeros in decimal notation (10^{k-1} ≤ n < 10^{k}). It is guaranteed that it is always possible to remove less than k digits to make the number not prime.

It is guaranteed that the sum of k over all test cases does not exceed 10^4.

Output

For every test case, print two numbers in two lines. In the first line print the number of digits, that you have left in the number. In the second line print the digits left after all delitions. 

If there are multiple solutions, print any.

Example

Input


7
3
237
5
44444
3
221
2
35
3
773
1
4
30
626221626221626221626221626221


Output


2
27
1
4
1
1
2
35
2
77
1
4
1
6

Note

In the first test case, you can't delete 2 digits from the number 237, as all the numbers 2, 3, and 7 are prime. However, you can delete 1 digit, obtaining a number 27 = 3^3.

In the second test case, you can delete all digits except one, as 4 = 2^2 is a composite number.
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using db = long double; // or double, if TL is tight
using str = string;     // yay python!

using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;

using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;

#define tcT template <class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT > using V = vector<T>;
tcT, size_t SZ > using AR = array<T, SZ>;
tcT > using PR = pair<T, T>;

// pairs,
#define mp make_pair
#define f first
#define s second

// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pb push_back
#define eb emplace_back
#define pf push_front
#define rtn return

#define lb lower_bound
#define ub upper_bound
tcT > int lwb(V<T> &a, const T &b)
{
    return int(lb(all(a), b) - bg(a));
}

// loops
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i, 0, a)
#define ROF(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i, a) ROF(i, 0, a)
#define rep(a) F0R(_, a)
#define each(a, x) for (auto &a : x)

const int MOD = 31607;
const int MX = 2e5 + 5;
const ll INF = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x)
{ // assert(x >= 0); // make C++11 compatible until USACO updates ...
    return x == 0 ? 0 : 31 - __builtin_clz(x);
} // floor(log2(x))
constexpr int p2(int x) { return 1 << x; }
constexpr int msk2(int x) { return p2(x) - 1; }

ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); } // divide a by b rounded down

tcT > bool ckmin(T &a, const T &b)
{
    return b < a ? a = b, 1 : 0;
} // set a = min(a,b)
tcT > bool ckmax(T &a, const T &b)
{
    return a < b ? a = b, 1 : 0;
}

tcTU > T fstTrue(T lo, T hi, U f)
{
    hi++;
    assert(lo <= hi); // assuming f is increasing
    while (lo < hi)
    { // find first index such that f is true
        T mid = lo + (hi - lo) / 2;
        f(mid) ? hi = mid : lo = mid + 1;
    }
    return lo;
}
tcTU > T lstTrue(T lo, T hi, U f)
{
    lo--;
    assert(lo <= hi); // assuming f is decreasing
    while (lo < hi)
    { // find first index such that f is true
        T mid = lo + (hi - lo + 1) / 2;
        f(mid) ? lo = mid : hi = mid - 1;
    }
    return lo;
}
tcT > void remDup(vector<T> &v)
{ // sort and remove duplicates
    sort(all(v));
    v.erase(unique(all(v)), end(v));
}
tcTU > void erase(T &t, const U &u)
{ // don't erase
    auto it = t.find(u);
    assert(it != end(t));
    t.erase(it);
} // element that doesn't exist from (multi)set

#define tcTUU tcT, class... U

inline namespace Helpers
{
    //////////// is_iterable
    // https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
    // this gets used only when we can call begin() and end() on that type
    tcT, class = void > struct is_iterable : false_type
    {
    };
    tcT > struct is_iterable<T, void_t<decltype(begin(declval<T>())),
                                       decltype(end(declval<T>()))>> : true_type
    {
    };
    tcT > constexpr bool is_iterable_v = is_iterable<T>::value;

    //////////// is_readable
    tcT, class = void > struct is_readable : false_type
    {
    };
    tcT > struct is_readable<T,
                             typename std::enable_if_t<
                                 is_same_v<decltype(cin >> declval<T &>()), istream &>>> : true_type
    {
    };
    tcT > constexpr bool is_readable_v = is_readable<T>::value;

    //////////// is_printable
    // // https://nafe.es/posts/2020-02-29-is-printable/
    tcT, class = void > struct is_printable : false_type
    {
    };
    tcT > struct is_printable<T,
                              typename std::enable_if_t<
                                  is_same_v<decltype(cout << declval<T>()), ostream &>>> : true_type
    {
    };
    tcT > constexpr bool is_printable_v = is_printable<T>::value;
}

inline namespace Input
{
    tcT > constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
    tcTUU > void re(T &t, U &...u);
    tcTU > void re(pair<T, U> &p); // pairs

    // re: read
    tcT > typename enable_if<is_readable_v<T>, void>::type re(T &x) { cin >> x; } // default
    tcT > void re(complex<T> &c)
    {
        T a, b;
        re(a, b);
        c = {a, b};
    }                                                                // complex
    tcT > typename enable_if<needs_input_v<T>, void>::type re(T &i); // ex. vectors, arrays
    tcTU > void re(pair<T, U> &p) { re(p.f, p.s); }
    tcT > typename enable_if<needs_input_v<T>, void>::type re(T &i)
    {
        each(x, i) re(x);
    }
    tcTUU > void re(T &t, U &...u)
    {
        re(t);
        re(u...);
    } // read multiple

    // rv: resize and read vectors
    void rv(size_t) {}
    tcTUU > void rv(size_t N, V<T> &t, U &...u);
    template <class... U>
    void rv(size_t, size_t N2, U &...u);
    tcTUU > void rv(size_t N, V<T> &t, U &...u)
    {
        t.rsz(N);
        re(t);
        rv(N, u...);
    }
    template <class... U>
    void rv(size_t, size_t N2, U &...u)
    {
        rv(N2, u...);
    }

    // dumb shortcuts to read in ints
    void decrement() {} // subtract one from each
    tcTUU > void decrement(T &t, U &...u)
    {
        --t;
        decrement(u...);
    }
#define ints(...)    \
    int __VA_ARGS__; \
    re(__VA_ARGS__);
#define int1(...)      \
    ints(__VA_ARGS__); \
    decrement(__VA_ARGS__);
}

inline namespace ToString
{
    tcT > constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;

    // ts: string representation to print
    tcT > typename enable_if<is_printable_v<T>, str>::type ts(T v)
    {
        stringstream ss;
        ss << fixed << setprecision(15) << v;
        return ss.str();
    } // default
    tcT > str bit_vec(T t)
    { // bit vector to string
        str res = "{";
        F0R(i, sz(t))
        res += ts(t[i]);
        res += "}";
        return res;
    }
    str ts(V<bool> v) { return bit_vec(v); }
    template <size_t SZ>
    str ts(bitset<SZ> b) { return bit_vec(b); }                     // bit vector
    tcTU > str ts(pair<T, U> p);                                    // pairs
    tcT > typename enable_if<needs_output_v<T>, str>::type ts(T v); // vectors, arrays
    tcTU > str ts(pair<T, U> p) { return "(" + ts(p.f) + ", " + ts(p.s) + ")"; }
    tcT > typename enable_if<is_iterable_v<T>, str>::type ts_sep(T v, str sep)
    {
        // convert container to string w/ separator sep
        bool fst = 1;
        str res = "";
        for (const auto &x : v)
        {
            if (!fst)
                res += sep;
            fst = 0;
            res += ts(x);
        }
        return res;
    }
    tcT > typename enable_if<needs_output_v<T>, str>::type ts(T v)
    {
        return "{" + ts_sep(v, ", ") + "}";
    }

    // for nested DS
    template <int, class T>
    typename enable_if<!needs_output_v<T>, vs>::type
    ts_lev(const T &v) { return {ts(v)}; }
    template <int lev, class T>
    typename enable_if<needs_output_v<T>, vs>::type
    ts_lev(const T &v)
    {
        if (lev == 0 || !sz(v))
            return {ts(v)};
        vs res;
        for (const auto &t : v)
        {
            if (sz(res))
                res.bk += ",";
            vs tmp = ts_lev<lev - 1>(t);
            res.ins(end(res), all(tmp));
        }
        F0R(i, sz(res))
        {
            str bef = " ";
            if (i == 0)
                bef = "{";
            res[i] = bef + res[i];
        }
        res.bk += "}";
        return res;
    }
}

inline namespace Output
{
    template <class T>
    void pr_sep(ostream &os, str, const T &t) { os << ts(t); }
    template <class T, class... U>
    void pr_sep(ostream &os, str sep, const T &t, const U &...u)
    {
        pr_sep(os, sep, t);
        os << sep;
        pr_sep(os, sep, u...);
    }
    // print w/ no spaces
    template <class... T>
    void pr(const T &...t) { pr_sep(cout, "", t...); }
    // print w/ spaces, end with newline
    void ps() { cout << "\n"; }
    template <class... T>
    void ps(const T &...t)
    {
        pr_sep(cout, " ", t...);
        ps();
    }
    // debug to cerr
    template <class... T>
    void dbg_out(const T &...t)
    {
        pr_sep(cerr, " | ", t...);
        cerr << endl;
    }
    void loc_info(int line, str names)
    {
        cerr << "Line(" << line << ") -> [" << names << "]: ";
    }
    template <int lev, class T>
    void dbgl_out(const T &t)
    {
        cerr << "\n\n"
             << ts_sep(ts_lev<lev>(t), "\n") << "\n"
             << endl;
    }
#ifdef LOCAL
#define dbg(...) loc_info(__LINE__, #__VA_ARGS__), dbg_out(__VA_ARGS__)
#define dbgl(lev, x) loc_info(__LINE__, #x), dbgl_out<lev>(x)
#else // don't actually submit with this
#define dbg(...) 0
#define dbgl(lev, x) 0
#endif
}

inline namespace FileIO
{
    void setIn(str s) { freopen(s.c_str(), "r", stdin); }
    void setOut(str s) { freopen(s.c_str(), "w", stdout); }
    void setIO(str s = "")
    {
        cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
        // cin.exceptions(cin.failbit);
        // throws exception when do smth "illegal",
        // ex. try to read letter into int
        if (sz(s))
            setIn(s + ".in"), setOut(s + ".out"); // for old USACO
    }
}

/**
* Description: modular arithmetic operations 
* Source: 
    * KACTL
    * https://codeforces.com/blog/entry/63903
    * https://codeforces.com/contest/1261/submission/65632855 (tourist)
    * https://codeforces.com/contest/1264/submission/66344993 (ksun)
    * also see https://github.com/ecnerwala/cp-book/blob/master/src/modnum.hpp (ecnerwal)
* Verification: 
    * https://open.kattis.com/problems/modulararithmetic
*/

template <int MOD, int RT>
struct mint
{
    static const int mod = MOD;
    static constexpr mint rt() { return RT; } // primitive root for FFT
    int v;
    explicit operator int() const { return v; } // explicit -> don't silently convert to int
    mint() { v = 0; }
    mint(ll _v)
    {
        v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
        if (v < 0)
            v += MOD;
    }
    friend bool operator==(const mint &a, const mint &b)
    {
        return a.v == b.v;
    }
    friend bool operator!=(const mint &a, const mint &b)
    {
        return !(a == b);
    }
    friend bool operator<(const mint &a, const mint &b)
    {
        return a.v < b.v;
    }
    friend void re(mint &a)
    {
        ll x;
        re(x);
        a = mint(x);
    }
    friend str ts(mint a) { return ts(a.v); }

    mint &operator+=(const mint &m)
    {
        if ((v += m.v) >= MOD)
            v -= MOD;
        return *this;
    }
    mint &operator-=(const mint &m)
    {
        if ((v -= m.v) < 0)
            v += MOD;
        return *this;
    }
    mint &operator*=(const mint &m)
    {
        v = int((ll)v * m.v % MOD);
        return *this;
    }
    mint &operator/=(const mint &m) { return (*this) *= inv(m); }
    friend mint pow(mint a, ll p)
    {
        mint ans = 1;
        assert(p >= 0);
        for (; p; p /= 2, a *= a)
            if (p & 1)
                ans *= a;
        return ans;
    }
    friend mint inv(const mint &a)
    {
        assert(a.v != 0);
        return pow(a, MOD - 2);
    }

    mint operator-() const { return mint(-v); }
    mint &operator++() { return *this += 1; }
    mint &operator--() { return *this -= 1; }
    friend mint operator+(mint a, const mint &b) { return a += b; }
    friend mint operator-(mint a, const mint &b) { return a -= b; }
    friend mint operator*(mint a, const mint &b) { return a *= b; }
    friend mint operator/(mint a, const mint &b) { return a /= b; }
};
vector<bool> check(100);
void solve()
{
    int k;
    re(k);
    vi cnt(10, 0);
    str s;
    re(s);
    F0R(i, k)
    {
        if (s[i] == '1' || s[i] == '4' || s[i] == '6' || s[i] == '8' || s[i] == '9')
        {
            ps(1);
            ps(s[i]);
            rtn;
        }
    }
    F0R(i, k)
    {

        if (s[i] == '2')
        {
            if (i != 0)
            {
                for (int i = 0; i < 10; i++)
                {
                    if (cnt[i] != 0)
                    {
                        ps(2);
                        pr(i, 2);
                        ps("");
                        rtn;
                    }
                }
            }
            cnt[2] += 1;
        }
        else
        {

            if (s[i] == '5')
            {
                for (int i = 0; i < 10; i++)
                {
                    if (cnt[i] != 0)
                    {
                        ps(2);
                        pr(i, 5);
                        ps("");
                        rtn;
                    }
                }
            }
            if (s[i] == '7')
            {
                if (cnt[2] > 0)
                {
                    ps(2);
                    ps(27);
                    rtn;
                }
            }
            cnt[int(s[i]) - 48] += 1;
        }
    }
    F0R(i, 10)
    {
        if (cnt[i] >= 2)
        {
            ps(2);
            pr(i, i);
            ps("");
            rtn;
        }
    }
    ps("no");
}

int main()
{
    setIO();
    for (int i = 0; i < 100; i++)
    {
        check[i] = false;
    }
    int t;
    re(t);
    while (t--)
    {
        solve();
    }
}