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.math.*;
import java.util.*;

public class CF682d {
	static PrintWriter pw;

	static class FastReader {
		private InputStream mIs;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public FastReader() {
			this(System.in);
		}

		public FastReader(InputStream is) {
			mIs = is;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = mIs.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String next() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long l() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int i() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double d() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public void scanIntArr(int[] arr) {
			for (int li = 0; li < arr.length; ++li)
				arr[li] = i();
		}

		public void scanIntIndexArr(int[] arr) {
			for (int li = 0; li < arr.length; ++li) {
				arr[li] = i() - 1;
			}
		}

		public void printIntArr(int[] arr) {
			for (int li = 0; li < arr.length; ++li)
				pw.print(arr[li] + " ");
			pw.println();
		}

		public void printLongArr(long[] arr) {
			for (int li = 0; li < arr.length; ++li)
				pw.print(arr[li] + " ");
			pw.println();
		}

		public void scanLongArr(long[] arr) {
			for (int i = 0; i < arr.length; ++i) {
				arr[i] = l();
			}
		}

		public void shuffle(int[] arr) {
			for (int i = arr.length; i > 0; --i) {
				int r = (int) (Math.random() * i);
				int temp = arr[i - 1];
				arr[i - 1] = arr[r];
				arr[r] = temp;
			}
		}

		public int findMax(int[] arr) {
			return Arrays.stream(arr).max().getAsInt();
		}
	}

	public static void main(String[] args) throws IOException {
		FastReader fr = new FastReader();
		pw = new PrintWriter(System.out);
		int i, j, n, m, temp, t, k;
		n = fr.i();
		int a[] = new int[n];
		int xor = 0;
		for(i=0;i<n;i++) {
			a[i]=fr.i();
			xor = xor^a[i];
		}
		if(n%2==0 && xor!=0) {
			pw.println("NO");
		}
		else {
			if(n%2==0)
				--n;
			pw.println("YES");
			int op1 = (n-3)/2+1;
			int op2 = (n-3)/2;
			pw.println(op1+op2);
			int ct=0;
			for(i=1,ct=1;ct<=op1;i+=2,++ct) {
				pw.println(i+" "+(i+1)+" "+(i+2));
			}
			for(i=1,ct=1;ct<=op2;i+=2,++ct) {
				pw.println(i+" "+(i+1)+" "+n);
			}
		}
		
		pw.flush();
		pw.close();
	}
}