description: A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
  
  You are given an integer n. Your goal is to construct and print exactly n different regular bracket sequences of length 2n.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 50) — the number of test cases.
  
  Each test case consists of one line containing one integer n (1 ≤ n ≤ 50).
  
  Output
  
  For each test case, print n lines, each containing a regular bracket sequence of length exactly 2n. All bracket sequences you output for a testcase should be different (though they may repeat in different test cases). If there are multiple answers, print any of them. It can be shown that it's always possible.
  
  Example
  
  Input
  
  
  3
  3
  1
  3
  
  
  Output
  
  
  ()()()
  ((()))
  (()())
  ()
  ((()))
  (())()
  ()(())
solution: import java.util.*;
  import java.io.*;
  import java.lang.*;
  
  public class Main {
      //input
      static out op = new out();
      static inp ip = new inp();
      static FastReader sc = new FastReader();
      static BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out));
      static long inf = (long)1e9+7;
     
     static long mod = (long)1e18+7;
     static long z = 0;
  
     static void sol() throws Exception{
        
        int n = ip.in();
        int[][] arr = new int[n][n];
        for(int i=1;i<n;i++){
           Arrays.fill(arr[i],0);
           arr[i][i-1] = 1; 
        }
        
        String[] s = {"()","(())"};
        StringBuffer sb = new StringBuffer();
        for(int i=0;i<n;i++){
           for(int j=0;j<n-1;j++){
              sb.append(s[arr[i][j]]);
           }
           if(i==0)sb.append(s[0]);
           sb.append("\n");
        }
        
        op.sb(sb+"");
     }
     
     static long gcd(long a,long b){
       if(b==0)
       return a;
       return gcd(b,a%b);
     }
     
     public static void main(String[] args) throws Exception { 
         
        int t = ip.in();
        while(t-- > 0){
           sol();
        }
        op.output.flush();
      }
      static class Node implements Comparable<Node>{
         int data;
         int ind;
        //  Node left,right;
        //  Node(){
        //       left = null;
        //       right = null;
        //  }
         Node(int data,int ind){
              this.data = data;
              this.ind = ind;
         }
      
           @Override
           public int compareTo(Node o) {
               if(this.data == o.data)
               return o.ind - this.ind;
               // TODO Auto-generated method stub
               return this.data - o.data;
           }
      }
  }
  
  
  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; 
      }
  
  }
  class inp{
      FastReader sc = new FastReader();
      int in(){
          int a = sc.nextInt();
          return a;
      }
      long lin(){
          long a = sc.nextLong();
          return a;
      }
      char cin(){
          char c = sc.next().charAt(0);
          return c;
      }
      char[] cain(){
          char[] a = sc.nextLine().toCharArray();
          return a;
      }
      int[] arrin(int n){
          int [] arr = new int[n];
          for(int i=0;i<n;i++)
              arr[i] = in();
  
          return arr;
      }
      int[] mm_arr(int[] arr){
          int max = Integer.MIN_VALUE;
          int min = Integer.MAX_VALUE;
          for(int i=0;i<arr.length;i++){
              max = Math.max(max,arr[i]);
              min = Math.min(min,arr[i]);
          }
          int ans[] = {max,min};
          return ans;
      }
      int[] srt(int[] arr){
          Arrays.sort(arr);
          return arr;
      }
      long pow(long a,long b){
          if(b == 0)return 1;
          long res = pow(a,b/2);
          //System.out.println(res + " " + b + " " + (b&1));
          if((b&1) == 0)return res*res;
          return a*res*res; 
      }
  
     //  boolean[] prime(){
     //     boolean prime[] = new boolean[100000001];
     //     Arrays.fill(prime,true);
     //     for (int p = 2; p * p <= 10000000; p++)
     //     {
     //          // If prime[p] is not changed,
     //          // then it is a prime
     //          if (prime[p] == true)
     //          {
     //              // Update all multiples
     //              // of p greater than or
     //              // equal to the square of it
     //              // numbers which are multiple
     //              // of p and are less than p^2
     //              // are already been marked.
     //              for (int i = p * p; i <= 10000000; i += p)
     //                 prime[i] = false;
     //          }
     //     }
     //     return prime;
     //  }
  }
  class out{
      BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out)); 
  
      void sb(String s) throws IOException {
          output.write(s);
      }
      void sbln(Object s) throws IOException {
          output.write(s+"\n");
      }
      void yes() throws IOException{
          output.write("YES\n");
      }
      void no() throws IOException{
          output.write("NO\n");
      }
  }