Note that the only difference between String Transformation 1 and String Transformation 2 is in the move Koa does. In this version the letter y Koa selects must be strictly greater alphabetically than x (read statement for better understanding). You can make hacks in these problems independently.

Koa the Koala has two strings A and B of the same length n (|A|=|B|=n) consisting of the first 20 lowercase English alphabet letters (ie. from a to t).

In one move Koa:

  1. selects some subset of positions p_1, p_2, …, p_k (k ≥ 1; 1 ≤ p_i ≤ n; p_i ≠ p_j if i ≠ j) of A such that A_{p_1} = A_{p_2} = … = A_{p_k} = x (ie. all letters on this positions are equal to some letter x).

  2. selects a letter y (from the first 20 lowercase letters in English alphabet) such that y>x (ie. letter y is strictly greater alphabetically than x).

  3. sets each letter in positions p_1, p_2, …, p_k to letter y. More formally: for each i (1 ≤ i ≤ k) Koa sets A_{p_i} = y.

Note that you can only modify letters in string A.




Koa wants to know the smallest number of moves she has to do to make strings equal to each other (A = B) or to determine that there is no way to make them equal. Help her!

Input

Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 10) — the number of test cases. Description of the test cases follows.

The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of strings A and B.

The second line of each test case contains string A (|A|=n).

The third line of each test case contains string B (|B|=n).

Both strings consists of the first 20 lowercase English alphabet letters (ie. from a to t).

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

Output

For each test case:

Print on a single line the smallest number of moves she has to do to make strings equal to each other (A = B) or -1 if there is no way to make them equal.

Example

Input


5
3
aab
bcc
4
cabc
abcb
3
abc
tsr
4
aabd
cccd
5
abcbd
bcdda


Output


2
-1
3
2
-1

Note

  * In the 1-st test case Koa: 
    1. selects positions 1 and 2 and sets A_1 = A_2 =  b (\color{red}{aa}b → \color{blue}{bb}b). 
    2. selects positions 2 and 3 and sets A_2 = A_3 =  c (b\color{red}{bb} → b\color{blue}{cc}). 

  * In the 2-nd test case Koa has no way to make string A equal B.

  * In the 3-rd test case Koa: 
    1. selects position 1 and sets A_1 =  t (\color{red}{a}bc → \color{blue}{t}bc). 
    2. selects position 2 and sets A_2 =  s (t\color{red}{b}c → t\color{blue}{s}c). 
    3. selects position 3 and sets A_3 =  r (ts\color{red}{c} → ts\color{blue}{r}). 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintWriter;
import java.util.HashMap;

public class C {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
	    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	    
	    int t = sc.nextInt();
	    while(t-- > 0) {
	    	int n = sc.nextInt();
	    	String s1 = sc.nextLine();
	    	String s2 = sc.nextLine();
	    	
	    	boolean possible = true;
	    	for(int i = 0; i < n; i++) {
	    		if(s1.charAt(i) > s2.charAt(i))
	    			possible = false;
	    	}
	    	
	    	if(!possible) {
	    		out.println(-1);
	    		continue;
	    	}
	    	
	    	// build relations
	    	DisjointSet letters = new DisjointSet();
	    	for(int i = 0; i < 20; i++) {
	    		letters.makeSet(i);
	    	}
	    	for(int i = 0; i < n; i++) {
	    		letters.union(s1.charAt(i) - 'a', s2.charAt(i) - 'a');
	    	}
	    	
	    	HashMap<Integer, Integer> setCounts = new HashMap<>();
	    	for(int i = 0; i < 20; i++) {
	    		setCounts.merge(letters.findSet(i), 1, Integer::sum);
	    	}
	    	
	    	int ans = 0;
	    	for(int key : setCounts.keySet()) {
	    		ans += setCounts.get(key) - 1;
	    	}
	    	
	    	out.println(ans);
	    }
	    
	    out.close();
	}
	
	static class Node {
		int rank;
		int data;
		Node parent = null;
		
		Node(int rank, int data) {
			this.rank = rank;
			this.data = data;
		}
	}
	
	static class DisjointSet {	
		private HashMap<Integer, Node> map = new HashMap<>();
		
		public void makeSet(int data) {
			Node n = new Node(0, data);
			map.put(data, n);
		}
		
		public int findSet(int elem) {
			Node curr = map.get(elem);
			if(curr.parent == null)
				return elem;
			
			curr.parent = map.get(findSet(curr.parent.data));
			return curr.parent.data;
		}
		
		public void union(int a, int b) {
			int rep1 = findSet(a);
			int rep2 = findSet(b);
			
			if(rep1 == rep2) return;
			
			if(map.get(rep1).rank == map.get(rep2).rank) {
				map.get(rep2).parent = map.get(rep1);
				map.get(rep1).rank++;
			}
			
			if(map.get(rep1).rank > map.get(rep2).rank) {
				map.get(rep2).parent = map.get(rep1);
			}else {
				map.get(rep1).parent = map.get(rep2);
			}
		}
		
		public int setSize() {
			return map.size();
		}
	}
	
	private static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;
 
        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }
 
        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }
 
        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }
 
        public int nextInt() {
            return (int)nextLong();
        }
 
        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }
 
        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }
 
        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }
 
        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }
 
        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }
 
        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }
 
        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }
}
