1157_F. Maximum Balanced Circle
There are n people in a row. The height of the i-th person is a_i. You can choose any subset of these people and try to arrange them into a balanced circle.

A balanced circle is such an order of people that the difference between heights of any adjacent people is no more than 1. For example, let heights of chosen people be [a_{i_1}, a_{i_2}, ..., a_{i_k}], where k is the number of people you choose. Then the condition |a_{i_j} - a_{i_{j + 1}}| ≤ 1 should be satisfied for all j from 1 to k-1 and the condition |a_{i_1} - a_{i_k}| ≤ 1 should be also satisfied. |x| means the absolute value of x. It is obvious that the circle consisting of one person is balanced.

Your task is to choose the maximum number of people and construct a balanced circle consisting of all chosen people. It is obvious that the circle consisting of one person is balanced so the answer always exists.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of people.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the height of the i-th person.

Output

In the first line of the output print k — the number of people in the maximum balanced circle.

In the second line print k integers res_1, res_2, ..., res_k, where res_j is the height of the j-th person in the maximum balanced circle. The condition |res_{j} - res_{j + 1}| ≤ 1 should be satisfied for all j from 1 to k-1 and the condition |res_{1} - res_{k}| ≤ 1 should be also satisfied.

Examples

Input


7
4 3 5 1 2 2 1


Output


5
2 1 1 2 3


Input


5
3 7 5 1 5


Output


2
5 5 


Input


3
5 1 4


Output


2
4 5 


Input


7
2 2 3 2 1 2 2


Output


7
1 2 2 2 2 3 2 
```python
import sys
from collections import namedtuple
from itertools import groupby
input = sys.stdin.readline

def main():
    Data = namedtuple('Data', ['arr', 'l', 'r'])

    _ = int(input())
    a = list(map(int, input().split()))

    f = [ [0, 0] for i in range(max(a) + 2) ]

    for x in a:
        f[x][0] = x
        f[x][1] += 1

    best = 0
    opt = None

    for k, v in groupby(f, key = lambda x: 1 if x[1] else 0):
        if not k:
            continue

        v = list(v)
        i = lst = len(v) - 1
        t = [0] * (len(v) + 1)

        while i >= 0:
            t[i] = t[i + 1] + v[i][1]

            if t[i] - t[lst + 1] > best:
                best = t[i] - t[lst + 1]
                opt = Data(v, i, lst)

            if v[i][1] == 1:
                lst = i

            i -= 1

    ans = []

    for i in range(opt.l, opt.r + 1):
        ans.append(opt.arr[i][0])
        opt.arr[i][1] -= 1

    for i in range(opt.r, opt.l - 1, -1):
        while opt.arr[i][1]:
            ans.append(opt.arr[i][0])
            opt.arr[i][1] -= 1

    print(len(ans))
    print(" ".join(map(str, ans)))

main()

```