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.awt.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.List;

/**
 * Codeforces
 * 
 * 
 */
public class Codeforcess {

    public static boolean has1inbetween(String s, int i, int j) {
        boolean ans = true;
        char ch[] = s.toCharArray();

        for (int b = i + 1; b < j && b < s.length() && i < ch.length && j < ch.length; b++) {
            if (ch[i] == '1') {
                ans = false;
            }
        }
        return ans;
    }

    public static int segregate(int arr[], int size) {
        int j = 0, i;
        for (i = 0; i < size; i++) {
            if (arr[i] <= 0) {
                int temp;
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                // increment count of non-positive
                // integers
                j++;
            }
        }

        return j;
    }

    public static long lowComMultiple(long a, long b) {
        long min = a * b;
        long start = Math.min(a, b);
        long ans = -1;
        for (int i = (int) start; i <= min; i++) {
            if (i % a == 0 && i % b == 0) {
                ans = i;
                break;
            }
        }
        return ans;
    }

    public static int solution(int[] A) {
        int n = A.length;

        // To mark the occurrence of elements
        boolean[] present = new boolean[n + 1];

        // Mark the occurrences
        for (int i = 0; i < n; i++) {

            if (A[i] > 0 && A[i] <= n)
                present[A[i]] = true;
        }

        // Find the first element which didn't
        // appear in the original array
        for (int i = 1; i <= n; i++)
            if (!present[i])
                return i;

        return n + 1;
    }

    public static ArrayList<Long> digit(long num) {
        long dig = 0;
        // long length = 0;
        ArrayList<Long> digi = new ArrayList<>();
        while (num > 0) {
            dig = num % 10;
            digi.add(dig);
            num = num / 10;

        }
        // return dig; //System.out.printf("%d", +revnum);

        return digi;
    }

    static int[] shuffle(int a[], int n) {
        for (int i = 0; i < n; i++) {

            // getting the random index
            int t = (int) Math.random() * a.length;

            // and swapping values a random index
            // with the current index
            int x = a[t];
            a[t] = a[i];
            a[i] = x;
        }
        return a;
    }

    public static long addDigits(long num) {
        long digit = 0;
        // long sum = 0;
        long dig = -1;

        while (num != 0) {
            digit = num % 10;
            dig = digit;
            num = num / 10;
            break;
        }
        return dig;
    }

    public static int addDigit(long num) {
        long digit = 0;
        // long sum = 0;
        int count = 0;

        while (num != 0) {
            digit = num % 10;
            count++;
            num = num / 10;

        }
        return count;
    }

    public static class Pair<A, B> {
        private A first;
        private B second;

        public Pair(A first, B second) {
            this.first = first;
            this.second = second;
        }

        public A getFirst() {
            return first;
        }

        public B getSecond() {
            return second;
        }

        public void setFirst(A first) {
            this.first = first;
        }

        public void setSecond(B second) {
            this.second = second;
        }
    }

    static void findPair(int values[], int n, Pair<Integer, Integer> ans) {
        // Pair<Integer, Integer> ans = new Pair<Integer,Integer>(0, 0);
        int size = values.length;
        int i = 0, j = 1;
        int minLen = Integer.MAX_VALUE;
        int in = -1;
        int jn = -1;
        while (i < size && j < size) {

            if (i != j && values[j] - values[i] == n) {

                if (j - i < minLen) {
                    in = i;
                    jn = j;
                }
                break;
                // System.out.print("Pair Found: " + "( " + values[i] + ", " + values[j] + "
                // )");
                // return "1";
            } else if (values[j] - values[i] < n)
                j++;
            else
                i++;
        }

        if (in == -1 && jn == -1) {
            ans.setFirst(-1);
            ans.setSecond(-1);
        } else {
            ans.setFirst(in + 1);
            ans.setSecond(jn + 1);
        }

        // return ans;
    }

    public static String findMinDays(int[] values, int[] profit) {

        StringBuilder str = new StringBuilder();
        ArrayList<Pair<Integer, Integer>> ans = new ArrayList<>();
        Pair<Integer, Integer> p = new Pair<Integer, Integer>(0, 0);
        for (int i = 0; i < profit.length; i++) {
            findPair(values, profit[i], p);
            ans.add(p);
        }

        for (int i = 0; i < ans.size(); i++) {
            if (ans.get(i).getFirst() != -1 || ans.get(i).getSecond() != -1) {
                str.append(ans.get(i).getFirst());
                str.append(" ");
                str.append(ans.get(i).getSecond() + ",");
            } else {
                str.append(-1 + ",");
            }
        }

        String s;
        str.setCharAt(str.length() - 1, ' ');
        s = str.toString();
        return s;

    }

    public static long fact(long n) {
        BigInteger res = new BigInteger("1");
        for (long i = 2; i <= n; i++)
            res = res.multiply(BigInteger.valueOf(i));
        return res.longValue();
    }

    public static long nCr(long n, long r) {
        long den = (fact(r) * fact(n - r));
        long num = fact(n);
        if (den <= 0 || num < 0)
            return 1;
        else
            return num / den;

    }

    public static int[] seq(int n, int x, int y) {
        int best = Integer.MAX_VALUE;
        int[] bestArr = new int[n];
        for (int start = 1; start <= 50; start++) {
            for (int diff = 1; diff <= 50; diff++) {
                boolean X = false, Y = false;
                int[] a = ap(n, start, diff);
                for (int i = 0; i < n; i++) {
                    if (a[i] == x)
                        X = true;
                    if (a[i] == y)
                        Y = true;

                }
                if (X && Y && a[n - 1] < best) {
                    best = a[n - 1];
                    bestArr = a;
                }
            }
        }
        return bestArr;
    }

    public static int[] ap(int n, int start, int diff) {
        int arr[] = new int[n];
        arr[0] = start;
        for (int i = 1; i < n; i++) {
            arr[i] = arr[i - 1] + diff;
        }
        return arr;
    }

    public static int cntSame(String s) {
        int ans = 0;
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i - 1) == s.charAt(i)) {
                ans++;

            }
        }
        if (ans % 2 == 0)
            ans = ans / 2;

        return ans;
    }

    public void dump() {
        // Scanner sc = new Scanner(System.in);
        // int t = sc.nextInt();
        // while (t-- > 0) {
        // int n = sc.nextInt();
        // int m = sc.nextInt();

        // // int mArr[][] = new int[n][m];
        // ArrayList<ArrayList<Integer>> mArr = new ArrayList<>();
        // ArrayList<Integer> temp = new ArrayList<>();
        // for (int i = 0; i < n; i++) {
        // temp = new ArrayList<>();
        // for (int j = 0; j < m; j++) {
        // temp.add(sc.nextInt());
        // }
        // mArr.add(i, temp);
        // }
        // ArrayList<ArrayList<Integer>> nArr = new ArrayList<>();
        // ArrayList<Integer> temp1 = new ArrayList<>();
        // for (int i = 0; i < m; i++) {
        // temp1 = new ArrayList<>();
        // for (int j = 0; j < n; j++) {
        // temp1.add(sc.nextInt());
        // }
        // nArr.add(i, temp1);
        // }
        // ArrayList<Integer> rowOrder = new ArrayList<>();
        // for (int i = 0; i < m; i++) {
        // rowOrder.add(nArr.get(0).get(i));
        // }

        // ArrayList<ArrayList<Integer>> rowCol = new ArrayList<>();
        // int p = 0;
        // for (int i = 0; i < n; i++) {
        // int rowOrdElem = rowOrder.get(p);
        // if (nArr.get(i).contains(rowOrdElem)) {
        // rowCol.add(nArr.get(i));
        // p++;
        // } else {
        // int row = 0;
        // for (int k = 0; k < nArr.get(i).size(); k++) {
        // for (int l = 0; l < rowOrder.size(); l++) {
        // if (nArr.get(row).get(k) == rowOrder.get(l)) {
        // rowCol.add(l, nArr.get(row));
        // row++;
        // } else {
        // row++;
        // }
        // }
        // }
        // }

        // }
        // for (int i = 0; i < rowCol.size(); i++) {
        // for (int j = 0; j < rowCol.get(i).size(); j++) {
        // System.out.print(rowCol.get(i).get(j) + " ");
        // }
        // System.out.println();
        // }

        // }

    }

    public static void main(String[] args) {

        try {
            Scanner sc = new Scanner(System.in);
            int t = sc.nextInt();

            while (t-- > 0) {
                int n = sc.nextInt();
                System.out.println(n);
                StringBuilder sb = new StringBuilder();
                for (int i = 1; i <= n; i++) {
                    sb.append(i + " ");
                }
                System.out.println(sb.toString().trim());

            }

        } catch (Exception e) {
            System.out.println(e);
        }

    }

}