Everybody knows what an arithmetic progression is. Let us remind you just in case that an arithmetic progression is such sequence of numbers a1, a2, ..., an of length n, that the following condition fulfills: 

a2 - a1 = a3 - a2 = a4 - a3 = ... = ai + 1 - ai = ... = an - an - 1.

For example, sequences [1, 5], [10], [5, 4, 3] are arithmetic progressions and sequences [1, 3, 2], [1, 2, 4] are not.

Alexander has n cards containing integers. Arthur wants to give Alexander exactly one more card with a number so that he could use the resulting n + 1 cards to make an arithmetic progression (Alexander has to use all of his cards).

Arthur has already bought a card but he hasn't written a number on it. Help him, print all integers that you can write on a card so that the described condition fulfilled.

Input

The first line contains integer n (1 ≤ n ≤ 105) — the number of cards. The next line contains the sequence of integers — the numbers on Alexander's cards. The numbers are positive integers, each of them doesn't exceed 108.

Output

If Arthur can write infinitely many distinct integers on the card, print on a single line -1.

Otherwise, print on the first line the number of integers that suit you. In the second line, print the numbers in the increasing order. Note that the numbers in the answer can exceed 108 or even be negative (see test samples).

Examples

Input

3
4 1 7


Output

2
-2 10


Input

1
10


Output

-1


Input

4
1 3 5 9


Output

1
7


Input

4
4 3 4 5


Output

0


Input

2
2 4


Output

3
0 3 6
"""Template for Python Competitive Programmers prepared by Mayank Chaudhary """

#to use the print and division function of Python3
from __future__ import division, print_function

"""value of mod"""
MOD = 998244353
mod = 10**9 + 7

"""use resource"""
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])

"""for factorial"""

# def prepare_factorial():
#     fact = [1]
#     for i in range(1, 1000005):
#         fact.append((fact[-1] * i) % mod)
#     ifact = [0] * 1000005
#     ifact[1000004] = pow(fact[1000004], mod - 2, mod)
#     for i in range(1000004, 0, -1):
#         ifact[i - 1] = (i * ifact[i]) % mod
#
#     return fact, ifact

"""uncomment next 4 lines while doing recursion based question"""
# import threading
# threading.stack_size(2**27)
import sys
# sys.setrecursionlimit(30000)


"""uncomment modules according to your need"""
# from bisect import bisect_left, bisect_right, insort
# import itertools
# from math import floor, ceil, sqrt, degrees, atan, pi
# from heapq import heappop, heapify, heappush
# from random import randint as rn
# from Queue import Queue as Q
from collections import Counter, defaultdict, deque

'''
def modinv(n, p):
    return pow(n, p - 2, p)
'''


# def ncr(n, r,  fact, ifact):  # for using this uncomment the lines calculating fact and ifact
#     t = (fact[n] * (ifact[r]*ifact[n-r]) % mod)% mod
#     return t



def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()


# def GCD(x, y):
#     while (y):
#         x, y = y, x % y
#     return x
#
# def lcm(x, y):
#     return (x*y)//(GCD(x, y))
#
# def get_xor(n):
#     return [n,1,n+1,0][n%4]

"""*******************************************************"""



def main():

    n = int(input())
    Arr = get_array()

    if n==1:
        print(-1)     # infinite likh sakte hai na
        exit()

    if n==2:
        Arr.sort()
        a,b = Arr[0], Arr[1]

        if a==b:
            print(1)
            print(a)
        elif (b-a)&1:                # it is odd
            print(2)
            print(2*a-b, 2*b-a)
        else:
            print(3)
            print(2*a-b, (a+b)//2, 2*b-a)
        exit()

    if n==3:
        Arr.sort()
        a, b, c = Arr[0], Arr[1], Arr[2]

        if a==b==c:
            print(1)
            print(a)
        elif (b-a)==(c-b):    # 2, 4, 6 case
            print(2)
            print(2*a-b, 2*c-b)
        elif (b-a) == 2*(c-b):
            print(1)
            print((b+a)//2)
        elif (c-b) == 2*(b-a):
            print(1)
            print((b+c)//2)
        else:
            print(0)
        exit()

    Arr.sort()
    mydict = dict()
    for i in range(1, n):
        diff = Arr[i] - Arr[i-1]
        mydict[diff] = mydict.get(diff, 0)+1

    length = len(mydict)
    if length>2:
        print(0)
        exit()

    if length==1:
        diff = Arr[1] - Arr[0]
        if diff==0:
            print(1)
            print(Arr[0])
        else:
            print(2)
            print(Arr[0] - diff, Arr[-1] + diff)
        exit()

    if length == 2:
        # first find both the difference
        a = b = float('inf')
        for i in mydict:
            if a==float('inf'):
                a = i
            else:
                b = i

        freq_a = mydict[a]
        freq_b = mydict[b]

        if (freq_a > 1 and freq_b > 1) or (a>b and freq_a !=1) or (b>a and freq_b != 1):               # dono ki freq greater than 1 hai
            print(0)
            exit()

        if (a>b and a!=2*b) or (b>a and b!=2*a):
            print(0)
            exit()

        maxi = max(a, b)
        # print(maxi)
        print(1)
        for i in range(1, n):
            if Arr[i]-Arr[i-1] == maxi:
                print((Arr[i]+Arr[i-1])//2)
                break








""" -------- Python 2 and 3 footer by Pajenegod and c1729 ---------"""

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip

    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192


class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill();
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            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')

""" main function"""

if __name__ == '__main__':
    main()
    # threading.Thread(target=main).start()