There is a square field of size n × n in which two cells are marked. These cells can be in the same row or column.

You are to mark two more cells so that they are the corners of a rectangle with sides parallel to the coordinate axes.

For example, if n=4 and a rectangular field looks like this (there are asterisks in the marked cells):

$$$ \begin{matrix} . & . & * & . \\\ . & . & . & . \\\ * & . & . & . \\\ . & . & . & . \\\ \end{matrix} $$$

Then you can mark two more cells as follows

$$$ \begin{matrix} * & . & * & . \\\ . & . & . & . \\\ * & . & * & . \\\ . & . & . & . \\\ \end{matrix} $$$

If there are several possible solutions, then print any of them.

Input

The first line contains a single integer t (1 ≤ t ≤ 400). Then t test cases follow.

The first row of each test case contains a single integer n (2 ≤ n ≤ 400) — the number of rows and columns in the table.

The following n lines each contain n characters '.' or '*' denoting empty and marked cells, respectively.

It is guaranteed that the sums of n for all test cases do not exceed 400.

It is guaranteed that there are exactly two asterisks on the field. They can be in the same row/column.

It is guaranteed that the solution exists.

Output

For each test case, output n rows of n characters — a field with four asterisks marked corresponding to the statements. If there multiple correct answers, print any of them.

Example

Input


6
4
..*.
....
*...
....
2
*.
.*
2
.*
.*
3
*.*
...
...
5
.....
..*..
.....
.*...
.....
4
....
....
*...
*...


Output


*.*.
....
*.*.
....
**
**
**
**
*.*
*.*
...
.....
.**..
.....
.**..
.....
....
....
**..
**..
import java.util.* ;
import java.lang.* ;
import java.io.*;

public class javaTemplate {
	
	static FastReader sc = new FastReader();
	//	static Scanner sc = new Scanner(System.in) ;

	public static void main(String[] args) {
		
		
        int t = sc.nextInt() ;
		
		while(t -- != 0) {
			
			int n = sc.nextInt() ;
			char arr[][] = new char[n][n] ;
			ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>() ;
			ArrayList<Integer> ans ;
			for(int i = 0 ; i< n ; i++) {
				String s = sc.nextLine() ;
				for(int j = 0 ; j< n ; j++) {
					arr[i][j] = s.charAt(j) ;
					if(arr[i][j] == '*') {
						ans = new ArrayList<>() ;
						ans.add(i) ;
						ans.add(j) ;
						list.add(ans) ;
					}
					
				}
				
			}
			
	
					if(list.get(0).get(0) == list.get(1).get(0)) {
						if(list.get(0).get(0) == 0) {
							arr[list.get(0).get(0)+1][list.get(0).get(1)] = '*' ;
							arr[list.get(1).get(0)+1][list.get(1).get(1)] = '*' ;
						} else {
							arr[0][list.get(0).get(1)] = '*' ;
							arr[0][list.get(1).get(1)] = '*' ;
						}
					} else if(list.get(0).get(1) == list.get(1).get(1)) {
						if(list.get(0).get(1) == 0) {
							arr[list.get(0).get(0)][list.get(0).get(1)+1] = '*' ;
							arr[list.get(1).get(0)][list.get(1).get(1)+1] = '*' ;
						} else {
							arr[list.get(0).get(0)][0] = '*' ;
							arr[list.get(1).get(0)][0] = '*' ;
						}
					} else {
						arr[list.get(0).get(0)][list.get(1).get(1)] = '*' ;
						arr[list.get(1).get(0)][list.get(0).get(1)] = '*' ;
					}
			
			for(int i = 0 ; i< n ; i++) {
				for(int j = 0 ; j< n ; j++) {
					System.out.print(arr[i][j]);
				}
				System.out.println();
			}
			
			
			
		}
		
		
		
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	 
	
	


	
	
//_________________________//Template//________________________________________________________________________________________________
	
	
		//		FAST I/O
		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;
	        
	        public FastReader()
	        {
	            br = new BufferedReader(
	                new InputStreamReader(System.in));
	        }
	 
	        String next()
	        {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	 
	        long nextLong() { return Long.parseLong(next()); }
	 
	        double nextDouble()
	        {
	            return Double.parseDouble(next());
	        }
	 
	        String nextLine()
	        {
	            String str = "";
	            try {
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
		}
	
	
		
		
		
		
		
		
		
		
		
		//		LPS Array
		static void LPSArray(String pat, int M, int lps[]) {
			int i = 1 ;
			int length = 0 ;
			lps[0] = 0 ;
			
			while(i < M) {
				if(pat.charAt(i) == pat.charAt(length)) {
					length ++ ;
					lps[i] = length ;
					i ++ ;
				} else if(length != 0) {
					length = lps[length-1] ;
				} else {
					lps[i] = length ;
					i ++ ;
				}
			}
		}
		
		
		
		//		KMP Search
		static boolean kmpSearch(String pat, String txt) {
			boolean val = false ;
			int M = pat.length() ;
			int N = txt.length() ;
			
			int lps[] = new int[M] ;
			
			int j = 0 ;
			int i = 0 ;
			
			LPSArray(pat,M,lps) ;
			
			while(i < N) {
				if(pat.charAt(j) == txt.charAt(i)) {
					i ++ ;
					j ++ ;
				} else if(j != 0) {
					j = lps[j-1] ;
				} else {
					i ++ ;
				}
				
				if(j == M) {
					 val = true ;
					 j = lps[j-1] ;
				}
			}
			
			return val ;
		}
	
	
		
			
			
		
		
		
		//		Palindrom or Not
		static boolean isPalindrome(String str, int low, int high) {
					
					while (low < high) {
						if (str.charAt(low) != str.charAt(high)) return false;
					 	low++;
					 	high--;
					}
					return true;
				}
	
	
		// Euler Tortient fx
	static int Phi(int n) {
		
		int count = 0 ;
		for(int i = 1 ; i< n ; i++) {
			if(GCD(i,n) == 1) count ++ ;
		}
		return count ;
	}
	
	
	
		// Integer Sort
		static void sort(int[] a) 
		   {
				ArrayList<Integer> l=new ArrayList<>();
				for (int i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
		
		
		
		// Long Sort
		static void sort(long[] a) 
		   {
				ArrayList<Long> l=new ArrayList<>();
				for (long i:a) l.add(i);
				Collections.sort(l);
				for (int i=0; i<a.length; i++) a[i]=l.get(i);
			}
	
	
		
		// boolean Value
		static void val(boolean val)
	    {
	       System.out.println(val ? "YES" : "NO");
	       System.out.flush();
	    }
	
	
		
	
		// GCD
		public static int GCD(int a , int b) {
				if(b == 0) return a ;
				
				return GCD(b, a%b) ;
			}
	
		
		
		
		
		
		// sieve
		public static boolean [] sieveofEratosthenes(int n) {
			
			boolean isPrime[] = new boolean[n+1] ;
			Arrays.fill(isPrime, true);
			isPrime[0] = false ;
			isPrime[1] = false ;
			
			for(int i = 2 ; i * i <= n ; i++) {
				
				for(int j = 2 * i ; j<= n ; j+= i) {
					isPrime[j] = false ;
				}
			}
			
			return isPrime ;
		}
		
		
		
		
		// fastPower
		public static long fastPowerModulo(long a, long b, long n) {
			
			long res = 1 ;
			
			while(b > 0) {
			if((b&1) != 0) {
				res = (res * a % n) % n ;
			}
			
			a = (a % n * a % n) % n ;
			b = b >> 1 ;
			}
			
			return res ;
		}
	

}





