Problem: Sasha likes investigating different math objects, for example, magic squares. But Sasha understands that magic squares have already been studied by hundreds of people, so he sees no sense of studying them further. Instead, he invented his own type of square — a prime square. 

A square of size n × n is called prime if the following three conditions are held simultaneously: 

  * all numbers on the square are non-negative integers not exceeding 10^5; 
  * there are no prime numbers in the square; 
  * sums of integers in each row and each column are prime numbers. 



Sasha has an integer n. He asks you to find any prime square of size n × n. Sasha is absolutely sure such squares exist, so just help him!

Input

The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases.

Each of the next t lines contains a single integer n (2 ≤ n ≤ 100) — the required size of a square.

Output

For each test case print n lines, each containing n integers — the prime square you built. If there are multiple answers, print any.

Example

Input


2
4
2


Output


4 6 8 1
4 9 9 9
4 10 10 65
1 4 4 4
1 1
1 1

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Q1 {
	private void solve(Scan scan, Print print) throws Exception 
	{
		final int lim=151;
		TreeSet<Integer> set = new TreeSet<Integer>();
		boolean iscomp[] = new boolean[lim];
		for (int i = 2; i < iscomp.length; i++) 
		{
			if (!iscomp[i]) {
				set.add(i);
				for (int j = 2 * i; j < iscomp.length; j += i) {
					iscomp[j] = true;
				}
			}
		}
		int T = scan.nextInt();
		while (T-- > 0) 
		{
			int N=scan.nextInt();
			int ans[][]=new int[N][N];
			int sum=set.ceiling(N);
			int arr[]=new int[N];
			int i=0;
			while(i<N && set.contains(sum))
			{
				arr[i]=1;
				i++;
				sum--;
			}
			arr[i]=sum;
			i++;
			while(i<N)
			{
				arr[i]=0;
				i++;
			}
			for(i=0;i<N;i++)
			{
				for(int j=0;j<N;j++)
				{
					ans[i][j]=arr[(i+j)%N];
				}
			}
			for(i=0;i<N;i++)
			{
				for(int j=0;j<N;j++)
				{
					print.print(ans[j][i]+" ");
				}
				print.print("\n");
			}
		}
	}

	public static void main(String args[]) throws Exception {
		Scan scan = new Scan();
		Print print = new Print();
		Q1 o = new Q1();
		o.solve(scan, print);
		print.close();
	}

	public static class Print {
		private final BufferedWriter bw;

		public Print() {
			this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
		}

		public void print(Object object) throws IOException {
			bw.append("" + object);
		}

		public void println(Object object) throws IOException {
			print(object);
			bw.append("\n");
		}

		public void println(int object[]) throws IOException {
			print(Arrays.toString(object));
			bw.append("\n");
		}

		public void print(int object[]) throws IOException {
			print(Arrays.toString(object));
		}

		public void println(long object[]) throws IOException {
			print(Arrays.toString(object));
			bw.append("\n");
		}

		public void print(long object[]) throws IOException {
			print(Arrays.toString(object));
		}

		public void println(boolean object[]) throws IOException {
			print(Arrays.toString(object));
			bw.append("\n");
		}

		public void print(boolean object[]) throws IOException {
			print(Arrays.toString(object));
		}

		public void println(Object object[]) throws IOException {
			print(Arrays.deepToString(object));
			bw.append("\n");
		}

		public void print(Object object[]) throws IOException {
			print(Arrays.deepToString(object));
		}

		public void close() throws IOException {
			bw.close();
		}
	}

	static class Scan {
		private byte[] buf = new byte[1024 * 1024 * 4];
		private int index;
		private InputStream in;
		private int total;

		public Scan() {
			in = System.in;
		}

		public int scan() throws IOException {
			if (total < 0)
				throw new InputMismatchException();
			if (index >= total) {
				index = 0;
				total = in.read(buf);
				if (total <= 0)
					return -1;
			}
			return buf[index++];
		}

		public int nextInt() throws IOException {
			int integer = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		public double nextDouble() throws IOException {
			double doub = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n) && n != '.') {
				if (n >= '0' && n <= '9') {
					doub *= 10;
					doub += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			if (n == '.') {
				n = scan();
				double temp = 1;
				while (!isWhiteSpace(n)) {
					if (n >= '0' && n <= '9') {
						temp /= 10;
						doub += (n - '0') * temp;
						n = scan();
					} else
						throw new InputMismatchException();
				}
			}
			return doub * neg;
		}

		public long nextLong() throws IOException {
			long ret = 0;
			long c = scan();
			while (c <= ' ') {
				c = scan();
			}

			boolean neg = (c == '-');
			if (neg) {
				c = scan();
			}

			do {
				ret = ret * 10 + c - '0';
			} while ((c = scan()) >= '0' && c <= '9');

			if (neg) {
				return -ret;
			}
			return ret;
		}

		public String next() throws IOException {
			StringBuilder sb = new StringBuilder();
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			while (!isWhiteSpace(n) || n == ' ') {
				sb.append((char) n);
				n = scan();
			}
			return sb.toString();
		}

		public void next(int arr[]) throws IOException {
			for (int i = 0; i < arr.length; i++) {
				arr[i] = nextInt();
			}
		}

		public void next(long arr[]) throws IOException {
			for (int i = 0; i < arr.length; i++) {
				arr[i] = nextLong();
			}
		}

		public char[] next(char c) throws IOException {
			char arr[] = next().toCharArray();
			return arr;
		}

		private boolean isWhiteSpace(int n) {
			if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
				return true;
			return false;
		}
	}
}