Problem: There are n bags with candies, initially the i-th bag contains i candies. You want all the bags to contain an equal amount of candies in the end. 

To achieve this, you will:

  * Choose m such that 1 ≤ m ≤ 1000

  * Perform m operations. In the j-th operation, you will pick one bag and add j candies to all bags apart from the chosen one.




Your goal is to find a valid sequence of operations after which all the bags will contain an equal amount of candies. 

  * It can be proved that for the given constraints such a sequence always exists.

  * You don't have to minimize m.

  * If there are several valid sequences, you can output any.

Input

Each test contains multiple test cases.

The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.

The first and only line of each test case contains one integer n (2 ≤ n≤ 100). 

Output

For each testcase, print two lines with your answer. 

In the first line print m (1≤ m ≤ 1000) — the number of operations you want to take. 

In the second line print m positive integers a_1, a_2, ..., a_m (1 ≤ a_i ≤ n), where a_j is the number of bag you chose on the j-th operation.

Example

Input


2
2
3


Output


1
2
5
3 3 3 1 2

Note

In the first case, adding 1 candy to all bags except of the second one leads to the arrangement with [2, 2] candies.

In the second case, firstly you use first three operations to add 1+2+3=6 candies in total to each bag except of the third one, which gives you [7, 8, 3]. Later, you add 4 candies to second and third bag, so you have [7, 12, 7], and 5 candies to first and third bag — and the result is [12, 12, 12].

Solution (in JAVA):

Solution:
import java.util.*;
import java.math.*;
import java.io.*; 
 public class A{

static FastReader scan=new FastReader();
 public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
  static LinkedList<Pair>edges[][];
  static LinkedList<Integer>Same[];
  static LinkedList<Integer>Dif[];
  static LinkedList<Integer>integers[];
static int []dx={1,-1,0,0};
static int []dy={0,0,1,-1};
int dx_8[]={1,1,1,0,0,-1,-1,-1};
int dy_8[]={-1,0,1,-1,1,-1,0,1};

static boolean prime[];
static long LCM(long a,long b){
    return (Math.abs(a*b))/gcd(a,b);
   }
   static long gcd(long a, long b) {
    if(a!=0&&b!=0)
        while((a%=b)!=0&&(b%=a)!=0);
    return a^b;
}
static int countSetBits(int n) 
    { 
        int count = 0; 
        while (n > 0) { 
            count += n & 1; 
            n >>= 1; 
        } 
        return count; 
    } 
 static void sieve(long n) 
    { 
        
        prime = new boolean[(int)n+1]; 
        for(int i=0;i<n;i++) 
            prime[i] = true; 
          
        for(int p = 2; p*p <=n; p++) 
        { 
           
            if(prime[p] == true) 
            { 
                
                for(int i = p*p; i <= n; i += p) 
                    prime[i] = false; 
            } 
        } 
    }  
    
    static int count;
 
  static boolean canTransmit[][]=new boolean[1000+5][1000+5];

    
    
    static boolean vis[][];
    static boolean light[][];
    static char grid[][]; 
            
           static boolean isprime(long x)
           {
            for(long i=2;i*i<=x;i++)
                if(x%i==0)
                    return false;
                return true;
           }
           static int ans=0,perm=0,FOR=0;
           static int n,m;
           static boolean valid(int x,int y)
           {
            return (x>=0&&x<n&&y>=0&&y<n&&grid[x][y]!='.');
           }
    static ArrayList<Pair>BRAINFUCK;
    static int area[]=new int[1000000];
    static int region[][]=new int[1001][1001];
    static int permiter[]=new int[1000000];

static int R;
    static void dfs(int x,int y)
    {
       // System.out.println(x+" "+y);
         if (x < 0 || x >= n || y < 0 || y >= n || !light[x][y] || vis[x][y]) return;
     vis[x][y]=true;
     if(edges[x][y].size()>0)
     {
        for(Pair p:edges[x][y]){
      if(!light[p.x][p.y]){
        light[p.x][p.y]=true;
        ans++;
        
        for(int i=0;i<4;i++)
        {
               if (p.x + dx[i] >= n || p.x+ dx[i] < 0) continue;
                    if (p.y + dy[i] >= n || p.y + dy[i] < 0) continue;
                    if(vis[p.x+dx[i]][p.y+dy[i]])
            dfs(p.x,p.y);
        }}
    }

        
     }
      for(int i=0;i<4;i++)
        {
            dfs(x+dx[i],y+dy[i]);
        }
        
    } 
    static int ret=0;
    static void findp(){
        ret=0;
       for(int i=0;i<n;i++)
       {
        for(int j=0;j<n;j++)
        {
            
            int r=region[i][j];
            if(r==0)
                continue;
            try{
            if(region[i-1][j]==0){
                 //out.println(r);
                permiter[r]++;
            }
        }
        catch(IndexOutOfBoundsException e)
        {
            permiter[r]++;
        }
            if(region[i][j+1]==0)
                permiter[r]++;
            if(region[i+1][j]==0)
                permiter[r]++;
            try{
            if(region[i][j-1]==0)
                permiter[r]++;
        }
        catch(IndexOutOfBoundsException e)
        {
            permiter[r]++;
        }
        


    }

       }

    }
    static long arr[];
    static int sz[]=new int[(int)1e5+5];
   
static int upper_bound(long e)
{
    int l=0,r=arr.length;
    while(l<r)
    {
        int mid=(l+r)/2;
        if(arr[mid]>e)
            r=mid;
        else 
            l=mid+1;
    }
    return l;
}

public static void main(String[] args)  throws IOException 
{
//java.util.Scanner scan=new java.util.Scanner(new File("lightson.in"));
 //PrintWriter out = new PrintWriter (new FileWriter("lightson.out"));
  //  System.out.println(~-1);
    

        //System.out.println(0^1);

//SUCK IT UP AND DO IT ALRIGHT
    //System.out.println((-1*1)%mod);
    int t=scan.nextInt();
    while(t-->0){
    int n=scan.nextInt();
    out.println(n);
    for(int i=1;i<=n;i++)
        out.print(i+" ");
    out.println();
    

}

 out.close();

//SEE UP 

}

static long powMod(long base, long exp, long mod) {
       if (base == 0 || base == 1) return base;
       if (exp == 0) return 1;
       if (exp == 1) return base % mod;
       long R = powMod(base, exp/2, mod) % mod;
       R *= R;
       R %= mod;
       if ((exp & 1) == 1) {
           return base * R % mod;
       }
       else return R % mod;
   }
static double dis(double x1,double y1,double x2,double y2)
{
    return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
static long mod(long x,long y)
    {
        if(x<0)
            x=x+(-x/y+1)*y;
        return x%y;
    }
 public static  long pow(long b, long e) {
            long r = 1;
            while (e > 0) {
                if (e % 2 == 1) r = r * b ;
                b = b * b;
                e >>= 1;
            }
            return r;
        }
private static void sort(long[] arr) {
        List<Long> list = new ArrayList<>();
        for (long object : arr) list.add(object);
        Collections.sort(list);
        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
    }
 public static class FastReader {
        BufferedReader br;
        StringTokenizer root;
        
 
        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        boolean hasNext(){
            String line;
            while(root.hasMoreTokens())
                return true;
            return false;
        }
 
        String next() {
            while (root == null || !root.hasMoreTokens()) {
                try {
                    root = new StringTokenizer(br.readLine());
                } catch (Exception addd) {
                    addd.printStackTrace();
                }
            }
            return root.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(next());
        }
 
        double nextDouble() {
            return Double.parseDouble(next());
        }
 
        long nextLong() {
            return Long.parseLong(next());
        }
 
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (Exception addd) {
                addd.printStackTrace();
            }
            return str;
        }
         public int[] nextIntArray(int arraySize) {
            int array[] = new int[arraySize];
 
            for (int i = 0; i < arraySize; i++) {
                array[i] = nextInt();
            }
 
            return array;
        }
}
 static class Pair implements Comparable<Pair>{
        public int x, y;
        public Pair(int x1, int y1) {
            x=x1;
            y=y1;
        }
        @Override
        public int hashCode() {
            return (int)(x + 31 * y);
        }
        public String toString() {
            return x + " " + y;
        }
        @Override
        public boolean equals(Object o){
            if (o == this) return true;
            if (o.getClass() != getClass()) return false;
            Pair t = (Pair)o;
            return t.x == x && t.y == y;
        }
public int compareTo(Pair o)
{
    return (x-o.y)-(o.x-y);

    }

static class pair{
    int i;
    int j;
pair(int i,int j){
    this.i=i;
    this.j=j;
}}}
 static class tuple{
        int x,y,z;
        tuple(int a,int b,int c){
            x=a;
            y=b;
            z=c;
        }
    }
    static class Edge{
        int d,w;
        Edge(int d,int w)
        {
            this.d=d;
            this.w=w;
        }
    }
}