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:
# abc means a xor b xor c
#
# a b c -> abc abc abc
#
#
# a b c d -> abc abc abc d
#         -> abc d   d   d    only YES if abc=d (abcd=0)
#
#
# a b c d e -> abc abc abc d e
#           -> abc abc abcde abcde abcde
#              ^   ^   ^
#           -> abcde abcde abcde abcde abcde
#
#
# a b c d e f -> abc abc abc d e f
#             -> abc abc abc def def def   odd number of abc
#                                          only YES if abc=def (abcdef=0)
#
# a b c d e f g -> abc abc abc d e f g
#               -> abc abc abc def def def g
#                  ^           ^           ^
#               -> abcdefg abc abc abcdefg def def abcdefg
#                  ^       ^   ^
#               -> abcdefg abcdefg abcdefg abcdefg def def abcdefg
#               -> abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg
#
#
# a b c d e f g
# abc abc abc d e f g
# abc abc abcde abcde abcde f g
# abc abc abcde abcde abcdefg abcdefg abcdefg
# abc abc abcdefg abcdefg abcdefg abcdefg abcdefg
# abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg
#
# induction: assume true for n-2 and can be done in n-4 steps.
# for n:
#     a1 a2 a3 ... an
#     (1 step, position 012)
#     a1a2a3 a1a2a3 a1a2a3 a4 a5 ... an
#                  [         n-2        ]
#                   (n-4 steps)
#                   234
#                   456
#                   678 ...
#                   456
#                   234
#
#     a1a2a3 a1a2a3 [a1a2...an   a1a2...an   a1a2...an]
#     ^      ^       ^
#     (1 step)
#     012
#
#     Total n-2 steps. induction is correct

n = int(input())
a = list(map(int,input().split()))
if n % 2 != 0:
    print('YES')
    print(n-2)
    for i in range(n):
        print(i*2+1,i*2+2,i*2+3) # 123,345,567,...,n-2 n-1 n
        if i*2+3 == n:
            break
    for i in range(2,n):
        if n-i*2+2 < 3:
            break
        print(n-i*2,n-i*2+1,n-i*2+2)
        # n-4 n-3 n-2, n-6 n-5 n-4, ... , 123


else:
    xor = 0
    for num in a:
        xor = xor ^ num
    if xor != 0:
        print('NO')
    else:
        n -= 1
        print('YES')
        print(n-2)
        for i in range(n):
            print(i*2+1,i*2+2,i*2+3) # 123,345,567,...,n-2 n-1 n
            if i*2+3 == n:
                break
        for i in range(2,n):
            if n-i*2+2 < 3:
                break
            print(n-i*2,n-i*2+1,n-i*2+2)
            # n-4 n-3 n-2, n-6 n-5 n-4, ... , 123