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
/*Author: Satyajeet Singh, Delhi Technological University*/
import java.io.*;
import java.util.*;
import java.text.*; 
import java.lang.*;

public class Main {
	static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));		
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static long mod=(long)1e9+7;
	static long mod1=998244353;
	static boolean sieve[];
	static ArrayList<Integer> primes;
	static ArrayList<Long> factorial;
	static ArrayList<HashSet<Integer>> graph;
/****************************************Solutions Begins***************************************************/
	
	public static void main (String[] args) throws Exception {
		String st[]=br.readLine().split(" ");
		int t=Integer.parseInt(st[0]);
		for(int i1=0;i1<t;i1++){
			st=br.readLine().split(" ");
			int n=Integer.parseInt(st[0]);
			st=br.readLine().split(" ");
			String str=st[0];
			int aa=0,bb=0;
			if(n==2){
			aa=str.charAt(0)-'0';
			bb=str.charAt(1)-'0';
			}

			if(n==1||(n==2&&aa>=bb)){
				out.println("NO");
			}
			else{
				out.println("YES");
				out.println(2);
				out.println(str.charAt(0)+" "+str.substring(1));
			}
		}
/****************************************Solutions Ends*****************************************************/
		out.flush();
		out.close();
    }
/****************************************Template Begins***************************************************/
/***************************************Precision Printing**********************************************/
	static void printPrecision(double d){
		DecimalFormat ft = new DecimalFormat("0.000000"); 
		out.println(ft.format(d));
	}
/******************************************Graph***********************************************************/
	static void Makegraph(int n){
		graph=new ArrayList<>();
		for(int i=0;i<n;i++){
			graph.add(new HashSet<>());
		}
	}
	static void addEdge(int a,int b){
		graph.get(a).add(b);
		graph.get(b).add(a);
	}	
/*******************************************************TRIPLET********************************************/
	static class tripletComparator implements Comparator<triplet>{
		public int compare(triplet p1,triplet p2){
			if(p1.u<p2.u){
				return 1;
			}
			else if(p1.u>p2.u){
				return -1;
			}
			else{
				return 0;
			}
		}
	}
	static class triplet{
		int u;
		int v;
		int i;
		public triplet(int u,int v,int i){
			this.u=u;
			this.v=v;
			this.i=i;
		}
		public String toString() {
			return "[u=" + u + ", v=" + v + ", i="+i+"]";
		}
	}
/*********************************************PAIR*************************************************/
	static class PairComp implements Comparator<Pair>{
		public int compare(Pair p1,Pair p2){
			if(p1.u>p2.u){
				return 1;
			}
			else if(p1.u<p2.u){
				return -1;
			}
			else{
				return 0;
			}
		}
	}
	static class Pair implements Comparable<Pair> {
		int u;
		int v;
		int index=-1;
		public Pair(int u, int v) {
			this.u = u;
			this.v = v;
		}
 
		public int hashCode() {
			int hu = (int) (u ^ (u >>> 32));
			int hv = (int) (v ^ (v >>> 32));
			return 31 * hu + hv;
		}
 
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return u == other.u && v == other.v;
		}
 
		public int compareTo(Pair other) {
			if(index!=other.index)
				return Long.compare(index, other.index);
			return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
		}
 
		public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}
	}
/*******************************************LONG PAIR******************************************/
	static class PairCompL implements Comparator<Pairl>{
		public int compare(Pairl p1,Pairl p2){
			if(p1.u>p2.u){
				return 1;
			}
			else if(p1.u<p2.u){
				return -1;
			}
			else{
				return 0;
			}
		}
	}
static class Pairl implements Comparable<Pair> {
		long u;
		long v;
		int index=-1;
		public Pairl(long u, long v) {
			this.u = u;
			this.v = v;
		}
 
		public int hashCode() {
			int hu = (int) (u ^ (u >>> 32));
			int hv = (int) (v ^ (v >>> 32));
			return 31 * hu + hv;
		}
 
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return u == other.u && v == other.v;
		}
 
		public int compareTo(Pair other) {
			if(index!=other.index)
				return Long.compare(index, other.index);
			return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
		}
 
		public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}
	}
/*****************************************DEBUG***********************************************************/
	public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
/*****************************************NUMBER THEORY***********************************************/

/************************************MODULAR EXPONENTIATION************************************/
	static long modulo(long a,long b,long c) {
		long x=1;
		long y=a;
		while(b > 0){
			if(b%2 == 1){
				x=(x*y)%c;
			}
			y = (y*y)%c; // squaring the base
			b /= 2;
		}
		return  x%c;
	}
/*********************************************GCD*****************************/
	static long gcd(long x, long y)
	{
		if(x==0)
			return y;
		if(y==0)
			return x;
		long r=0, a, b;
		a = (x > y) ? x : y; // a is greater number
		b = (x < y) ? x : y; // b is smaller number
		r = b;
		while(a % b != 0)
		{
			r = a % b;
			a = b;
			b = r;
		}
		return r;
	}
/*******************************************SIEVE*********************************/
	static void sieveMake(int n){
		sieve=new boolean[n];
		Arrays.fill(sieve,true);
		sieve[0]=false;
		sieve[1]=false;
		for(int i=2;i*i<n;i++){
			if(sieve[i]){
				for(int j=i*i;j<n;j+=i){
					sieve[j]=false;
				}
			}
		}
		primes=new ArrayList<Integer>();
		for(int i=0;i<n;i++){
			if(sieve[i]){
				primes.add(i);
			}
		}		
	}
/***************************************FACTORIAL*********************************************************/
	static void fact(int n){
		factorial=new ArrayList<>();
		factorial.add((long)1);
		for(int i=1;i<=n;i++){
			factorial.add((factorial.get(i-1)*i)%mod);
		}
	}
/*******************************************ncr*********************************************************/
	static long ncr(int n,int k){
		long aa=modulo(factorial.get(n-k),mod-2,mod);
		long bb=modulo(factorial.get(k),mod-2,mod);
		long cc=factorial.get(n);
		long ans=(aa*cc)%mod;
		ans=(ans*bb)%mod;
		return ans;
	}
/***************************************STRING REVERSE****************************************************/
	static String reverse(String str){
		char r[]=new char[str.length()];
		int j=0;
		for(int i=str.length()-1;i>=0;i--){
			r[j]=str.charAt(i);
			j++;
		}
		return new String(r);
	}
}
/*******************************************************End***********************************************************/