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:
// package codeforce.cf682;

import java.io.PrintWriter;
import java.util.Scanner;
/*
* when you see three of xor you should think about the case a b b and it becomes a
* when the length is odd, it perfectly match
* when the length is even, we are running into some problem, we have one this left
* then we look into the problem, we can see that the xor of all the number if just use
* one value as the marker, and get through with every other pair
* for example : a, b, c, d -> a ^ c ^ d and they become the result of a ^ c ^ d, and we use this
* result to xor with other pair, the end result is that we have xor result
* no matter how many times we apply such value
* therefore we know that only when the whole xor value be 0 can we have answer for
* even length, we know the final answer is same which is 0 for all the value to be "xor"ed
* therefore, the answer is good right now, we cannot reach same all the value unless the total
* value is zero
*
*
* */
public class D {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
//        int t = sc.nextInt();
        int t = 1;
        for (int i = 0; i < t; i++) {
            solve(sc, pw);
        }
        pw.close();
    }

    static void solve(Scanner in, PrintWriter out){
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        int v = 0;
        for(int x : arr) v ^= x;
        if (n % 2 == 0){
            if (v != 0){
                out.println("NO");
                return;
            }
        }
        out.println("YES");
        if (n % 2 == 1){
            out.println((n - 1));
            for (int i = 1; i < n; i += 2) {
                out.println(1+" "+(i + 1)+" "+(i + 2));
            }
            for (int i = 1; i < n; i += 2) {
                out.println(1+" "+(i + 1)+" "+(i + 2));
            }
        }else{
            out.println((n - 2));
            for (int i = 1; i < n - 1; i += 2) {
                out.println(1+" "+(i + 1)+" "+(i + 2));
            }
            for (int i = 1; i < n - 1; i += 2) {
                out.println(1+" "+(i + 1)+" "+(i + 2));
            }
        }

    }
}