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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.*;
 
 
public class D {
    private static final FastReader fs = new FastReader();
    private static final PrintWriter out = new PrintWriter(System.out);
    
    private static int n;
    private static long[] a;
    
    private static void solve() {
    	n = fs.nextInt();
    	a = new long[n];
    	
    	long xor = 0;
    	for(int i = 0; i<n; i++) {
    		a[i] = fs.nextLong();
    		xor ^= a[i];
    	}
    	
    	boolean ok = (xor == 0 ? true : false);
    	
    	if(cf.even(n)^ok) {
    		out.println("NO");
    		return;
    	}
    	
    	out.println("YES");
    	ArrayList<int[]> ans = new ArrayList<>();
    	ans.add(new int[] {0,1,2});
    	for(int i = 3; i+1<n; i+=2) {
    		ans.add(new int[] {0,i,i+1});
    	}
    	if(cf.even(n))
    		ans.add(new int[] {0,n-2,n-1});
    	ans.add(new int[] {0,1,2});
    	for(int i = 3; i+1<n-2; i+=2) {
    		ans.add(new int[] {0,i,i+1});
    	}
    	out.println(ans.size());
    	for(int[] ele : ans) {
    		out.print((++ele[0]) + " " + (++ele[1]) + " " + (++ele[2]));
    		out.println();
    	}
    }
 
    public static void main(String[] args) {
        Thread t = new Thread(null,null,"",1 << 28) {
            public void run() {
                int test_case = 1;
                //test_case = fs.nextInt();
                for(int cs = 1; cs <= test_case; cs++) {
                    solve();
                }
                out.close();
            }
        };
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
 
        int [] readintarray(int n) {
            int res [] = new int [n];
            for(int i = 0; i<n; i++)res[i] = nextInt();
            return res;
        }
        long [] readlongarray(int n) {
            long res [] = new long [n];
            for(int i = 0; i<n; i++)res[i] = nextLong();
            return res;
        }
    }
    
    private static class cf{
    	public static int min(int x,int y) {
    		return Math.min(x, y);
    	}
    	public static int max(int x,int y) {
    		return Math.max(x, y);
    	}
    	public static long min(long x,long y) {
    		return Math.min(x, y);
    	}
    	public static long max(long x,long y) {
    		return Math.min(x, y);
    	}
    	public static boolean even(int x) {
    		return x%2 == 0 ? true : false;
    	}
    	public static boolean even(long x) {
    		return x%2 == 0 ? true : false;
    	}
    	public static int power(int base,int exponent) {
    		int res = 1;
    		while(exponent > 0) {
    			if(!even(exponent))
    				res *= base;
    			exponent >>= 1;
            	base *= base;
    		}
    		return res;
    	}
    	public static long power(long base,long exponent) {
    		long res = 1;
    		while(exponent > 0) {
    			if(!even(exponent))
    				res *= base;
    			exponent >>= 1;
            	base *= base;
    		}
    		return res;
    	}
    	public static long mul(long a,long b,long mod) {
    		return (a%mod * b%mod)%mod;
    	}
    	public static long add(long a,long b,long mod) {
    		return (a%mod + b%mod)%mod;
    	}
    	public static long sub(long a,long b,long mod) {
    		return ((a%mod-b%mod)%mod+mod)%mod;
    	}
    	public static long power(long base,long exponent,long mod) {
    		long res = 1;
    		base %= mod;
    		while(exponent > 0) {
    			if(!even(exponent))
    				res = mul(res,base,mod);
    			exponent >>= 1;
            	base = mul(base,base,mod);
    		}
    		return res;
    	}
    }
}