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 PYTHON3):

Solution:
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
 
import os
import sys
from io import BytesIO, IOBase
import heapq as h 
from bisect import bisect_left, bisect_right
import time
 
from types import GeneratorType
BUFSIZE = 8192
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
 
#start_time = time.time()
 
def getInts():
    return [int(s) for s in input().split()]
 
def getInt():
    return int(input())
 
def getStrs():
    return [s for s in input().split()]
 
def getStr():
    return input()
 
def listStr():
    return list(input())
 
def getMat(n):
    return [getInts() for _ in range(n)]
 
MOD = 10**9+7
 
"""
11000, 10010, 00101
 
In a three-way bitwise XOR, the bits which appear an odd number of times end up being 1
 
The bits which appear an even number of times end up 0
 
Can we set everything to 0
 
001
100
111
010
010
 
001010
000100
110001
010110
 
111111
 
 
 
(A*B*C)*(A*B*C)*D
=D
 
Every move creates 3 elements which are the same
 
[A,B,C,D,E,F,G]
[X,X,X,D,E,F,G] 1 2 3
[X,X,Y,Y,Y,F,G] 3 4 5
[X,X,Y,Y,Z,Z,Z] 5 6 7
[X,X,Y,Y,Z,Z,Z] 3 4 5
[Z,Z,Z,Z,Z,Z,Z] 1 2 3
 
odd always possible
 
even?
 
[A,X,B,B,Y,C]
 
[A,A,B,B,C,C]
 
Can I get make the array into pairs
 
 
[A,B,C,D,E,F]
 
[A,A,A,D,E,F]
[A,A,B,B,E,F]
[A,A,
 
Turn them all into pairs
 
If A,B,C = D then we have four elements the same
 
Take three elements
[A,A,A]
 
Treat the rest of the array
[B,C,D,E,F]
 
->
 
Take the XOR of all of them, and if it equals A, winner
 
 
"""
 
 
def solve():
    N = getInt()
    A = getInts()
    if N % 2 == 1:
        print("YES")
        print(N-2)
        for j in range(1,N-1,2):
            print(j,j+1,j+2)
        for j in range(N-4,0,-2):
            print(j,j+1,j+2)
        return
    # N % 2 = 0
    x = A[0]^A[1]^A[2]
    y = 0
    for j in range(3,N):
        y ^= A[j]
    if x != y:
        print("NO")
        return
    print("YES")
    print(N-4)
    print(1,2,3)
    for j in range(4,N-1,2):
        print(j,j+1,j+2)
    for j in range(N-4,3,-2):
        print(j,j+1,j+2)
    return
    
#for _ in range(getInt()):
solve()
 
#print(time.time()-start_time)