Problem: Ksenia has an array a consisting of n positive integers a_1, a_2, …, a_n. 

In one operation she can do the following: 

  * choose three distinct indices i, j, k, and then 
  * change all of a_i, a_j, a_k to a_i ⊕ a_j ⊕ a_k simultaneously, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). 



She wants to make all a_i equal in at most n operations, or to determine that it is impossible to do so. She wouldn't ask for your help, but please, help her!

Input

The first line contains one integer n (3 ≤ n ≤ 10^5) — the length of a.

The second line contains n integers, a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — elements of a.

Output

Print YES or NO in the first line depending on whether it is possible to make all elements equal in at most n operations.

If it is possible, print an integer m (0 ≤ m ≤ n), which denotes the number of operations you do.

In each of the next m lines, print three distinct integers i, j, k, representing one operation. 

If there are many such operation sequences possible, print any. Note that you do not have to minimize the number of operations.

Examples

Input


5
4 2 1 7 2


Output


YES
1
1 3 4

Input


4
10 4 49 22


Output


NO

Note

In the first example, the array becomes [4 ⊕ 1 ⊕ 7, 2, 4 ⊕ 1 ⊕ 7, 4 ⊕ 1 ⊕ 7, 2] = [2, 2, 2, 2, 2].

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.util.List;


/**
 * Created by Katushka on 11.03.2020.
 */
public class Main {

    static void sortArray(int[] a) {
        Random random = new Random();

        for (int i = 0; i < a.length; i++) {
            int randomPos = random.nextInt(a.length);
            int t = a[i];
            a[i] = a[randomPos];
            a[randomPos] = t;
        }
        Arrays.sort(a);
    }

    static int[] readArray(int size, InputReader in, boolean subOne) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextInt() + (subOne ? -1 : 0);
        }
        return a;
    }

    static long[] readLongArray(int size, InputReader in) {
        long[] a = new long[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextLong();
        }
        return a;
    }

    static int[] getPartialSums(int[] a) {
        if (a.length == 0) {
            return new int[]{0};
        }
        int[] res = new int[a.length + 1];

        for (int i = 1; i <= a.length; i++) {
            res[i] = res[i - 1] + a[i - 1];
        }

        return res;
    }


    public static void main(String[] args) throws FileNotFoundException {
        long start = System.currentTimeMillis();

//        InputReader in = new InputReader(new FileInputStream("input.txt"));
//        PrintWriter out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("skicourse.out")));

        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = in.nextInt();
        long[] a = readLongArray(n, in);

        if (n % 2 == 0) {
            long xx = a[0];
            for (int i = 1; i < n; i++) {
                xx = xx ^ a[i];
            }
            if (xx != 0) {
                out.println("NO");
                out.close();
                return;
            }
        }
        List<int[]> operations = new ArrayList<>();
        List<long[]> xors = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            xors.add(new long[]{a[i], i});
        }

        while (xors.size() > 2) {
            List<long[]> newXors = new ArrayList<>();
            for (int i = 0; i < xors.size(); i += 3) {
                if (i + 2 < xors.size()) {
                    long x = xors.get(i)[0] ^ xors.get(i + 1)[0] ^ xors.get(i + 2)[0];
                    a[(int) xors.get(i)[1]] = x;
                    a[(int) xors.get(i + 1)[1]] = x;
                    a[(int) xors.get(i + 2)[1]] = x;
                    newXors.add(new long[]{x, xors.get(i)[1]});
                    operations.add(new int[]{(int) xors.get(i)[1], (int) xors.get(i + 1)[1], (int) xors.get(i + 2)[1]});
                } else {
                    if (i + 1 < xors.size()) {
                        newXors.add(xors.get(i + 1));
                    }
                    newXors.add(xors.get(i));
                }
            }
            xors = newXors;

        }

        long xor = xors.get(0)[0];
        int xorInd = (int) xors.get(0)[1];
        if (xors.size() == 2) {
            long x = xors.get(0)[0] ^ xors.get(1)[0] ^ a[1];
            a[(int) xors.get(0)[1]] = x;
            a[(int) xors.get(1)[1]] = x;
            a[1] = x;
            operations.add(new int[]{(int) xors.get(0)[1], (int) xors.get(1)[1], 1});
            xor = x;
            xorInd = 1;
        }
        Map<Long, Integer> prevOcc = new HashMap<>();
        for (int i = 0; i < n; i++) {
            if (a[i] == xor) {
                continue;
            }
            if (prevOcc.containsKey(a[i])) {
                operations.add(new int[]{prevOcc.get(a[i]), i, xorInd});
                prevOcc.remove(a[i]);
            } else {
                prevOcc.put(a[i], i);
            }
        }
        out.println("YES");

        out.println(operations.size());
        for (int i = 0; i < operations.size(); i++) {
            outputArray(operations.get(i), out);
        }

        out.close();

    }


    public static List<List<Integer>> getPerms(int n) {
        Set<Integer> notUsed = new TreeSet<>();
        for (int i = 0; i < n; i++) {
            notUsed.add(i);
        }
        ArrayList<List<Integer>> perms = getPerms(n, notUsed);
        for (List<Integer> perm : perms) {
            Collections.reverse(perm);
        }
        return perms;
    }

    public static ArrayList<List<Integer>> getPerms(int n, Set<Integer> notUsed) {
        if (n == 0) {
            return new ArrayList<>();
        }

        if (n == 1) {
            ArrayList<List<Integer>> res = new ArrayList<>();
            res.add(new ArrayList<>());
            res.get(0).add(notUsed.iterator().next());
            return res;
        }

        ArrayList<List<Integer>> res = new ArrayList<>();
        for (Integer num : notUsed) {
            TreeSet<Integer> s = new TreeSet<>(notUsed);
            s.remove(num);
            List<List<Integer>> resChild = getPerms(n - 1, s);
            for (List<Integer> nums : resChild) {
                nums.add(num);
            }
            res.addAll(resChild);
        }

        return res;
    }


    private static void outputArray(int[] ans, PrintWriter out) {
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < ans.length; i++) {
            long an = ans[i] + 1;
            str.append(an).append(' ');
        }
        out.println(str);
        out.flush();
    }

    private static void outputArray(List<Integer> ans, PrintWriter out) {
        StringBuilder str = new StringBuilder();
        for (long an : ans) {
            str.append(an).append(' ');
        }
        out.println(str);
        out.flush();
    }


    private static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public String nextString() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public char nextChar() {
            return next().charAt(0);
        }

        public String nextWord() {
            return next();
        }

        private List<Integer>[] readTree(int n) {
            List<Integer>[] result = new ArrayList[n];
            for (int i = 0; i < n; i++) {
                result[i] = new ArrayList<>();
            }
            for (int i = 0; i < n - 1; i++) {
                int u = nextInt() - 1;
                int v = nextInt() - 1;
                result[u].add(v);
                result[v].add(u);
            }
            return result;
        }

    }
}