772_C. Vulnerable Kerbals
You are given an integer m, and a list of n distinct integers between 0 and m - 1.

You would like to construct a sequence satisfying the properties:

  * Each element is an integer between 0 and m - 1, inclusive. 
  * All prefix products of the sequence modulo m are distinct. 
  * No prefix product modulo m appears as an element of the input list. 
  * The length of the sequence is maximized. 



Construct any sequence satisfying the properties above.

Input

The first line of input contains two integers n and m (0 ≤ n < m ≤ 200 000) — the number of forbidden prefix products and the modulus.

If n is non-zero, the next line of input contains n distinct integers between 0 and m - 1, the forbidden prefix products. If n is zero, this line doesn't exist.

Output

On the first line, print the number k, denoting the length of your sequence.

On the second line, print k space separated integers, denoting your sequence.

Examples

Input

0 5


Output

5
1 2 4 3 0


Input

3 10
2 9 1


Output

6
3 9 2 9 8 0

Note

For the first case, the prefix products of this sequence modulo m are [1, 2, 3, 4, 0].

For the second case, the prefix products of this sequence modulo m are [3, 7, 4, 6, 8, 0].
```python
maxn = 200500
g = [[] for i in range(maxn)] # Array de array g[i][j] en el cual  la posicion i representa gcd(a,m)
                              # y en el array [j] se guardan todos los ¨a¨ con gcd comunes
dp = [0 for i in range(maxn)] # guarda la profundidad mayor para cada nodo
ban = [0 for i in range(maxn)]  # Array donde se guardan los productos prefijos mod m prohibidos
nxt = [0 for i in range(maxn)] # Array que contiene la proxima posicion ¨i¨ a leer en el array g
m = 0                          #

def gcd(a, b):                 #maximo comun divisor de a y b
    if (b == 0):
        return a
    return gcd(b, a % b)


def exgcd(a, b):                # Algoritmo de Euclides extendido (recursivo),
    if b == 0:                  # el cual devuelve los menores x, y
        x = 1                   # tales que se cumple que
        y = 0                   # a * x + b * y = gcd(a, b)
        return a,x,y            #
    ret, x, y = exgcd(b, a % b) #
    tmp = x                     #
    x = y                       #
    y = tmp -int(a / b) * y     #
    return ret, x, y            #


def f(a, b):                                # resuelve ecuacion de congruencia lineal
    r1, x, y = exgcd(a, m)                  # haciendo uso del algoritmo de Euclides extendido
    if b % r1 != 0:                         # si !=0
        return -1                           # la ecuacion no tiene solucion
    x = ((x + m) % m * int(b / r1)) % m     # solucion de la ecuacion
    return x

def dfs(p):                     # Algoritmo DFS (Depth First Search) utilizado para encontrar
    if  dp[p]!=0:               # la secuencia de mayor longitud
        return                  #
    res = 0                     #
    for i in range(p*2,m,p):    # recorrido por los nodos
        if (len(g[i])>0):       #
            dfs(i)              #
        if (dp[i] > res):       #
           res = dp[i]          #
           nxt[p] = i           # guardar indice i para despues recorrer desde la raiz (1) todos los nodos que
    if len(g[p])>0:             # se encuentran en el camino mas largo e ir accediendo a los elementos asociados a i
       res+= len(g[p])          #
    dp[p] = res                 #


#print("teclee n y m, dar enter e introducir 2da linea listado separados por coma ")
a, b = input().split(' ')
n = int(a)
m = int(b)
if n>0:
    lista = input().split(' ')
for i in range(1,n+1):
    x = int(lista[i - 1])
    ban[x] = 1              #marcar elem x como prohibido
for i in range(1,m):
    if  ban[i] == 0:
        d = gcd(i, m)
        g[d].append(i)      #guardando  los numeros con gcd =d si no es un elemento prohibido
dfs(1)
ban0 = 0
if ban[0] == ban0:          #verificar si 0 no es elemento prohibido, en ese caso se añade a la secuencia
    ban0=1
print(dp[1] + ban0)         #en dp[1] se encuentra la longitud mayor, [1] (origen del recorrido)
u = 1
x = 1
sec = ""
while (u != 0):             # recorrer nxt para obtener los elementos que estan en la misma clase modulo m
    for i in range(0,len(g[u])): #
        v = g[u][i]
        print(str(f(x, v)) + " ", end=" ") #solucion de la ecuacion
        x = v
    u = nxt[u]              # obtener siguiente indice u para recorrer todos los elementos i asociados a u (gcd(i,m)=u)
if ban0==1 :
    print("0")



```