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.io.*;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Optional;
import java.util.Random;
import java.util.stream.*;


public class A3 {

    // 420 remainder: use long everywhere

    private final static boolean MULTIPLE_TESTS = true;

    private void solve() {
        int n = reader.readInt();
        writer.println(n);
        for (int i = 0; i < n; i++) {
            writer.print(i + 1);
            writer.print(' ');
        }
        writer.println();
    }

    private FastReader reader;
    private FastWriter writer;

    private void run() throws Exception {
        reader = new FastReader();
        writer = new FastWriter();

        int t = MULTIPLE_TESTS ? reader.readInt() : 1;

        for (int testNum = 0; testNum < t; testNum++) {
            solve();
        }

        writer.close();
        reader.close();
    }

    public static void main(String[] args) throws Exception {
        new A3().run();
    }

    private final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    private static class FastWriter implements AutoCloseable {
        @SuppressWarnings(value="all")
        private final static Optional<String> OUTPUT_FILENAME = Optional.empty();

        private final PrintWriter out;

        public FastWriter() throws FileNotFoundException {
            this.out = OUTPUT_FILENAME.isEmpty() ? new PrintWriter(System.out) : new PrintWriter(new File(OUTPUT_FILENAME.get()));
        }

        public void println() {
            out.println();
        }

        public <T> void print(T value) {
            out.print(value);
        }

        public <T> void println(T value) {
            out.println(value);
        }

        public <T> void print(List<? extends T> list) {
            for (var it = list.listIterator(); it.hasNext(); ) {
                out.print(it.next());
                if (it.hasNext()) {
                    out.print(' ');
                }
            }
        }

        public <T> void println(List<? extends T> list) {
            print(list);
            out.println();
        }

        public <T> void print(T[] array) {
            for (int i = 0; i < array.length; i++) {
                out.print(array[i]);
                if (i + 1 < array.length) {
                    out.print(' ');
                }
            }
        }

        public <T> void println(T[] array) {
            print(array);
            out.println();
        }

        public void print(int[] array) {
            for (int i = 0; i < array.length; i++) {
                out.print(array[i]);
                if (i + 1 < array.length) {
                    out.print(' ');
                }
            }
        }

        public void println(int[] array) {
            print(array);
            out.println();
        }

        public void print(long[] array) {
            for (int i = 0; i < array.length; i++) {
                out.print(array[i]);
                if (i + 1 < array.length) {
                    out.print(' ');
                }
            }
        }

        public void println(long[] array) {
            print(array);
            out.println();
        }

        public void print(double[] array) {
            for (int i = 0; i < array.length; i++) {
                out.print(array[i]);
                if (i + 1 < array.length) {
                    out.print(' ');
                }
            }
        }

        public void println(double[] array) {
            print(array);
            out.println();
        }

        @Override
        public void close() {
            out.close();
        }
    }

    private static class FastReader implements AutoCloseable {
        private final static String INPUT_FILENAME = "input.txt";

        private final InputStream inputStream;
        private final byte[] buffer = new byte[1024];

        private int bufferLen = 0;
        private int bufferPtr = 0;

        public FastReader() throws FileNotFoundException {
            this.inputStream = ONLINE_JUDGE ? System.in : new FileInputStream(INPUT_FILENAME);
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++) {
                array[i] = readInt();
            }
            return array;
        }

        public long[] readLongArray(int size) {
            long[] array = new long[size];
            for (int i = 0; i < size; i++) {
                array[i] = readLong();
            }
            return array;
        }

        public double[] readDoubleArray(int size) {
            double[] array = new double[size];
            for (int i = 0; i < size; i++) {
                array[i] = readLong();
            }
            return array;
        }

        public double readDouble() {
            return Double.parseDouble(readToken());
        }

        public String readToken() {
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while (!(isSpaceChar(b))) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public int readInt() {
            int num = 0, b;
            boolean minus = false;

            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));

            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public long readLong() {
            long num = 0;
            int b;
            boolean minus = false;

            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));

            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public int readByte() {
            if (bufferLen == -1) {
                throw new InputMismatchException();
            }
            if (bufferPtr >= bufferLen) {
                bufferPtr = 0;
                try {
                    bufferLen = inputStream.read(buffer);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (bufferLen <= 0) {
                    return -1;
                }
            }
            return buffer[bufferPtr++];
        }

        public char readChar() {
            return (char) skip();
        }

        private int skip() {
            int b;
            while ((b = readByte()) != -1 && isSpaceChar(b));
            return b;
        }

        private static boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }

        @Override
        public void close() throws Exception {
            inputStream.close();
            bufferPtr = bufferLen;
        }
    }

    private static class Tuple {
        public static <A, B> Tuple2<A, B> of(A first, B second) {
            return new Tuple2<>(first, second);
        }

        public static <A, B> List<Tuple2<A, B>> array(A[] first, B[] second) {
            if (first.length != second.length) {
                throw new RuntimeException(
                        String.format("Can't create tuples array from arrays with different length (%d != %d)",
                                first.length, second.length));
            }
            return IntStream.range(0, first.length)
                    .mapToObj(i -> Tuple.of(first[i], second[i]))
                    .collect(Collectors.toList());
        }

        public static <A, B, C> Tuple3<A, B, C> of(A first, B second, C third) {
            return new Tuple3<>(first, second, third);
        }

        public static <A, B, C> List<Tuple3<A, B, C>> array(A[] first, B[] second, C[] third) {
            if (first.length != second.length || second.length != third.length) {
                throw new RuntimeException(
                        String.format("Can't create tuples array from arrays with different length (%d, %d, %d)",
                                first.length, second.length, third.length));
            }
            return IntStream.range(0, first.length)
                    .mapToObj(i -> Tuple.of(first[i], second[i], third[i]))
                    .collect(Collectors.toList());
        }

        public static <A extends Comparable<A>, B extends Comparable<B>> Comparator<Tuple2<A, B>> tuple2Comparator() {
            return Comparator.comparing((Tuple2<A, B> t) -> t.first).thenComparing(t -> t.second);
        }

        public static <A extends Comparable<A>, B extends Comparable<B>, C extends Comparable<C>> Comparator<Tuple3<A, B, C>> tuple3Comparator() {
            return Comparator.comparing((Tuple3<A, B, C> t) -> t.first).thenComparing(t -> t.second).thenComparing(t -> t.third);
        }

        private static class Tuple2<A, B> extends Tuple {
            public final A first;
            public final B second;

            private Tuple2(A first, B second) {
                this.first = first;
                this.second = second;
            }

            @Override
            public String toString() {
                return "(" + first + ", " + second + ")";
            }
        }

        private static class Tuple3<A, B, C> extends Tuple2<A, B> {
            public final C third;

            private Tuple3(A first, B second, C third) {
                super(first, second);
                this.third = third;
            }

            @Override
            public String toString() {
                return "(" + first + ", " + second + ", " + third + ")";
            }
        }
    }

    private static class Utils {
        private static final Random RANDOM = new SecureRandom();

        public static <T extends Comparable<T>> void sort(T[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static void sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static void sort(long[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static void sort(double[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static <T> void sort(T[] array, Comparator<T> comparator) {
            shuffle(array);
            Arrays.sort(array, comparator);
        }

        public static <T> void shuffle(T[] array) {
            for (int i = array.length - 1; i > 0; i--) {
                int index = RANDOM.nextInt(i + 1);
                T a = array[index];
                array[index] = array[i];
                array[i] = a;
            }
        }

        public static void shuffle(int[] array) {
            for (int i = array.length - 1; i > 0; i--) {
                int index = RANDOM.nextInt(i + 1);
                int a = array[index];
                array[index] = array[i];
                array[i] = a;
            }
        }

        public static void shuffle(long[] array) {
            for (int i = array.length - 1; i > 0; i--) {
                int index = RANDOM.nextInt(i + 1);
                long a = array[index];
                array[index] = array[i];
                array[i] = a;
            }
        }

        public static void shuffle(double[] array) {
            for (int i = array.length - 1; i > 0; i--) {
                int index = RANDOM.nextInt(i + 1);
                double a = array[index];
                array[index] = array[i];
                array[i] = a;
            }
        }

        public static <T extends Comparable<T>> void sort(List<T> list) {
            Collections.shuffle(list);
            Collections.sort(list);
        }

        public static <T> void sort(List<T> list, Comparator<T> comparator) {
            Collections.shuffle(list);
            list.sort(comparator);
        }

        public static int randomInt(int fromIncluded, int toExcluded) {
            return fromIncluded + RANDOM.nextInt(toExcluded - fromIncluded);
        }

        public static Integer[] generify(int[] a) {
            return IntStream.of(a).boxed().toArray(Integer[]::new);
        }

        public static Long[] generify(long[] a) {
            return LongStream.of(a).boxed().toArray(Long[]::new);
        }

        public static Double[] generify(double[] a) {
            return DoubleStream.of(a).boxed().toArray(Double[]::new);
        }
    }
}