Problem: A big football championship will occur soon! n teams will compete in it, and each pair of teams will play exactly one game against each other.

There are two possible outcomes of a game:

  * the game may result in a tie, then both teams get 1 point; 
  * one team might win in a game, then the winning team gets 3 points and the losing team gets 0 points. 



The score of a team is the number of points it gained during all games that it played.

You are interested in a hypothetical situation when all teams get the same score at the end of the championship. A simple example of that situation is when all games result in ties, but you want to minimize the number of ties as well.

Your task is to describe a situation (choose the result of each game) so that all teams get the same score, and the number of ties is the minimum possible.

Input

The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.

Then the test cases follow. Each test case is described by one line containing one integer n (2 ≤ n ≤ 100) — the number of teams.

Output

For each test case, print (n(n - 1))/(2) integers describing the results of the games in the following order: the first integer should correspond to the match between team 1 and team 2, the second — between team 1 and team 3, then 1 and 4, ..., 1 and n, 2 and 3, 2 and 4, ..., 2 and n, and so on, until the game between the team n - 1 and the team n.

The integer corresponding to the game between the team x and the team y should be 1 if x wins, -1 if y wins, or 0 if the game results in a tie.

All teams should get the same score, and the number of ties should be the minimum possible. If there are multiple optimal answers, print any of them. It can be shown that there always exists a way to make all teams have the same score.

Example

Input


2
2
3


Output


0 
1 -1 1 

Note

In the first test case of the example, both teams get 1 point since the game between them is a tie.

In the second test case of the example, team 1 defeats team 2 (team 1 gets 3 points), team 1 loses to team 3 (team 3 gets 3 points), and team 2 wins against team 3 (team 2 gets 3 points).

Solution (in PYTHON3):

Solution:
#------------------Important Modules------------------#
from sys import stdin,stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
from random import *
input=stdin.readline
prin=stdout.write
from random import sample
from collections import Counter,deque
from fractions import *
from math import sqrt,ceil,log2,gcd
#dist=[0]*(n+1)
mod=10**9+7
"""
class DisjSet: 
    def __init__(self, n): 
        
        self.rank = [1] * n 
        self.parent = [i for i in range(n)] 
    def find(self, x): 
        if (self.parent[x] != x): 
              
             

            self.parent[x] = self.find(self.parent[x]) 
              
            
        return self.parent[x] 
  
  
    
    def union(self, x, y): 
          
         
        xset = self.find(x) 
        yset = self.find(y) 
  
        if xset == yset: 
            return
  
        if self.rank[xset] < self.rank[yset]: 
            self.parent[xset] = yset 
  
        elif self.rank[xset] > self.rank[yset]: 
            self.parent[yset] = xset 
  
        else: 
            self.parent[yset] = xset 
            self.rank[xset] = self.rank[xset] + 1
  

"""

def f(arr,i,j,d,dist):
    if i==j:
        return 
    nn=max(arr[i:j])
    for tl in range(i,j):
        if arr[tl]==nn:
            dist[tl]=d
            #print(tl,dist[tl])
            f(arr,i,tl,d+1,dist)
            f(arr,tl+1,j,d+1,dist)
    #return dist
            
        
def ps(n):
    cp=0;lk=0;arr={}
    #print(n)
    #cc=0;
    while n%2==0:
        n=n//2
        #arr.append(n);arr.append(2**(lk+1))
        lk+=1
    
    
    
        
    for ps in range(3,ceil(sqrt(n))+1,2):
        lk=0
        cc=0
        while n%ps==0:
            n=n//ps
            #cc=1
            #arr.append(n);arr.append(ps**(lk+1))
            lk+=1
        
            
            
    if n!=1:
        #lk+=1
        #arr[n]=1
        #ans*=n;
        lk+=1
        return False
        #return arr
    
    #print(arr)
    
    return True


#count=0
#dp=[[0 for i in range(m)] for j in range(n)]
#[int(x) for x in input().strip().split()]
def gcd(x, y): 
      
    while(y): 
        x, y = y, x % y 
      
    return x 
          
# Driver Code         
def factorials(n,r):
    #This calculates ncr mod 10**9+7
    slr=n;dpr=r
    qlr=1;qs=1
    mod=10**9+7
    
    for ip in range(n-r+1,n+1):
        qlr=(qlr*ip)%mod
    for ij in range(1,r+1):
        qs=(qs*ij)%mod
    #print(qlr,qs)
    ans=(qlr*modInverse(qs))%mod
    return ans

        
        
def modInverse(b):
    qr=10**9+7
    return pow(b, qr - 2,qr)

#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
  def wrapped_func(*args, **kwargs):
    if stack: return f(*args, **kwargs)
    to = f(*args, **kwargs)
    while True:
      if type(to) is GeneratorType:
        stack.append(to)
        to = next(to)
        continue
      stack.pop()
      if not stack: break
      to = stack[-1].send(to)
    return to
  return wrapped_func
def power(arr):
  listrep = arr
  subsets = []
  for i in range(2**len(listrep)):
    subset = []
    for k in range(len(listrep)):            
      if i & 1<<k:
        subset.append(listrep[k])
    subsets.append(subset)        
  return subsets
def pda(n) :
    list = [] 
    for i in range(1, int(sqrt(n) + 1)) :
         if (n % i == 0) :
            if (n // i == i) :
                list.append(i)
            else :
                list.append(n//i);list.append(i)
                 
    # The list will be printed in reverse    
    return list
def dis(xa,ya,xb,yb):
    return sqrt((xa-xb)**2+(ya-yb)**2)
#### END ITERATE RECURSION ####
 
#===============================================================================================
#----------Input functions--------------------#
def ii():
    return int(input())
def ilist():
    return [int(x) for x in input().strip().split()]
def islist():
    return list(map(str,input().split().rstrip()))
def inp():
    return input().strip()
def google(test,ans):
    return "Case #"+str(test)+": "+str(ans);
def overlap(x1,y1,x2,y2):
    if x2>y1:
        return y1-x2
    if y1>y2:
        return y2-x2
    return y1-x2;


###-------------------------CODE STARTS HERE--------------------------------###########
def pal(s):
    k=len(s)
    n=len(s)//2
    for i in range(n):
        if s[i]==s[k-1-i]:
            continue
        else:
            return 0
    return 1

    
#########################################################################################
t=int(input())
#t=1
for p in range(t):
    n=ii()
    total=(n*(n-1))//2
    tie=((total%n)*2)//n
    win=lose=(n-1-tie)//2
    #print(win,tie)
    wins=[0]*(n+1)
    loses=[0]*(n+1)
    ties=[0]*(n+1)
    for i in range(1,n+1):
        wins[i]=win;loses[i]=lose
        ties[i]=tie
    dp=[[0 for i in range(n+1)] for j in range(n+1)]
    for i in range(1,n+1):
        for j in range(i+1,n+1):
            if wins[i]>0:
                dp[i][j]=1;
                wins[i]-=1
                loses[j]-=1
            elif ties[i]>0:
                dp[i][j]=0
                ties[i]-=1
                ties[j]-=1
            elif loses[i]>0:
                dp[i][j]=-1
                loses[i]-=1
                wins[j]-=1
    arr=[]
    for i in range(1,n+1):
        for j in range(i+1,n+1):
            arr.append(dp[i][j])
    print(*arr)