You are given a sequence s consisting of n digits from 1 to 9.

You have to divide it into at least two segments (segment — is a consecutive sequence of elements) (in other words, you have to place separators between some digits of the sequence) in such a way that each element belongs to exactly one segment and if the resulting division will be represented as an integer numbers sequence then each next element of this sequence will be strictly greater than the previous one.

More formally: if the resulting division of the sequence is t_1, t_2, ..., t_k, where k is the number of element in a division, then for each i from 1 to k-1 the condition t_{i} < t_{i + 1} (using numerical comparing, it means that the integer representations of strings are compared) should be satisfied.

For example, if s=654 then you can divide it into parts [6, 54] and it will be suitable division. But if you will divide it into parts [65, 4] then it will be bad division because 65 > 4. If s=123 then you can divide it into parts [1, 23], [1, 2, 3] but not into parts [12, 3].

Your task is to find any suitable division for each of the q independent queries.

Input

The first line of the input contains one integer q (1 ≤ q ≤ 300) — the number of queries.

The first line of the i-th query contains one integer number n_i (2 ≤ n_i ≤ 300) — the number of digits in the i-th query.

The second line of the i-th query contains one string s_i of length n_i consisting only of digits from 1 to 9.

Output

If the sequence of digits in the i-th query cannot be divided into at least two parts in a way described in the problem statement, print the single line "NO" for this query.

Otherwise in the first line of the answer to this query print "YES", on the second line print k_i — the number of parts in your division of the i-th query sequence and in the third line print k_i strings t_{i, 1}, t_{i, 2}, ..., t_{i, k_i} — your division. Parts should be printed in order of the initial string digits. It means that if you write the parts one after another without changing their order then you'll get the string s_i.

See examples for better understanding.

Example

Input


4
6
654321
4
1337
2
33
4
2122


Output


YES
3
6 54 321
YES
3
1 3 37
NO
YES
2
21 22
/*
01001011 01000001 01000001 01010011 01001000 00100000 01000011 01001111 01000100
01000101 00100000 01000100 01000101 01001011 01001000 00100000 01001100 01000101
00100000 01001100 01000001 01001011 01001001 01000100 01011001 01000001 00100000
01010000 01000001 01010100 00100000 01001010 01000001 01000001 01010100 01001001
00100001 0001010
 */

/*
01001000 01000001 01010010 00100000 01001100 01001001 01001110 01000101 00100000
01001101 01000101 01001001 01001110 00100000 01001101 01000101 01010011 01010011
01000001 01000111 01000101 00100000 01001110 01000001 01001000 01001001 00100000
01001000 01001111 01000111 01000001 00100001
 */

/*
01000001 01000010 01001000 01001001 00100000 01010100 01000001 01001011 00100000
01010100 01010010 01000001 01001110 01010011 01001100 01000001 01010100 01000101
00100000 01010100 01010010 01000001 01001110 01010011 01001100 01000001 01010100
01000101 00100000 01001011 01000001 01010010 00100000 01010010 01000001 01001000
01000101 00100000 01001000 01001111 00100001
 */

/*
01001000 01001111 01010000 01000101 00100000 01001001 00100000 01010111 01000001
01010011 01010100 01000101 01000100 00100000 01011001 01001111 01010101 01010010
00100000 01010100 01001001 01001101 01000101 00100000 01000001 01001110 01000100
00100000 01001101 01000001 01000100 01000101 00100000 01011001 01001111 01010101
00100000 01010011 01001101 01001001 01001100 01000101 00100000 00111010 00101001
 */

import java.io.*;
import java.util.InputMismatchException;

/*
        CODE WRITTEN BY RITWIK SHANKER
        JUET
        161B180
*/

public class EA59
{
    public static void main(String[] args) throws Exception
    {
        InputReader in = new InputReader(System.in);
        OutputWriter out = new OutputWriter(System.out);
        int t = in.readInt();
        while (t-- > 0)
        {
            int n = in.readInt();
            String s = in.readString();
            if (n == 2)
            {
                char c = s.charAt(0);
                char c2 = s.charAt(1);
                if (c >= c2)
                {
                    out.printLine("NO");
                }
                else
                {
                    out.printLine("YES");
                    out.printLine("2");
                    out.printLine(c + " " + c2);
                }
            }
            else
            {
                out.printLine("YES");
                out.printLine("2");
                out.printLine(s.charAt(0) + " " + s.substring(1, n));
            }
        }
    }

    //FAST IO
    private static class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream)
        {
            this.stream = stream;
        }

        public int read()
        {
            if (numChars == -1)
            {
                throw new InputMismatchException();
            }
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = stream.read(buf);
                } catch (IOException e)
                {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do
            {
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String readString()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public double readDouble()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                {
                    return res * Math.pow(10, readInt());
                }
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                    {
                        return res * Math.pow(10, readInt());
                    }
                    if (c < '0' || c > '9')
                    {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public long readLong()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do
            {
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c)
        {
            if (filter != null)
            {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next()
        {
            return readString();
        }

        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }

    private static class OutputWriter
    {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream)
        {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer)
        {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects)
        {
            for (int i = 0; i < objects.length; i++)
            {
                if (i != 0)
                {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
            writer.flush();
        }

        public void printLine(Object... objects)
        {
            print(objects);
            writer.println();
            writer.flush();
        }

        public void close()
        {
            writer.close();
        }

        public void flush()
        {
            writer.flush();
        }
    }
}