Little Dima has two sequences of points with integer coordinates: sequence (*a*<sub class="lower-index">1</sub>, 1), (*a*<sub class="lower-index">2</sub>, 2), ..., (*a*<sub class="lower-index">*n*</sub>, *n*) and sequence (*b*<sub class="lower-index">1</sub>, 1), (*b*<sub class="lower-index">2</sub>, 2), ..., (*b*<sub class="lower-index">*n*</sub>, *n*).

Now Dima wants to count the number of distinct sequences of points of length 2·*n* that can be assembled from these sequences, such that the *x*-coordinates of points in the assembled sequence will not decrease. Help him with that. Note that each element of the initial sequences should be used exactly once in the assembled sequence.

Dima considers two assembled sequences (*p*<sub class="lower-index">1</sub>, *q*<sub class="lower-index">1</sub>), (*p*<sub class="lower-index">2</sub>, *q*<sub class="lower-index">2</sub>), ..., (*p*<sub class="lower-index">2·*n*</sub>, *q*<sub class="lower-index">2·*n*</sub>) and (*x*<sub class="lower-index">1</sub>, *y*<sub class="lower-index">1</sub>), (*x*<sub class="lower-index">2</sub>, *y*<sub class="lower-index">2</sub>), ..., (*x*<sub class="lower-index">2·*n*</sub>, *y*<sub class="lower-index">2·*n*</sub>) distinct, if there is such *i* (1 ≤ *i* ≤ 2·*n*), that (*p*<sub class="lower-index">*i*</sub>, *q*<sub class="lower-index">*i*</sub>) ≠ (*x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>).

As the answer can be rather large, print the remainder from dividing the answer by number *m*.
The first line contains integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>). The second line contains *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>). The third line contains *n* integers *b*<sub class="lower-index">1</sub>, *b*<sub class="lower-index">2</sub>, ..., *b*<sub class="lower-index">*n*</sub> (1 ≤ *b*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>). The numbers in the lines are separated by spaces.

The last line contains integer *m* (2 ≤ *m* ≤ 10<sup class="upper-index">9</sup> + 7).
n = int(input())      #tamaño de las sucesiones
a_n = input().split() #sucesion a_n
b_n = input().split() #sucesion b_n
k = int(input())      #numero para obtener un resultado de la forma km + r con 0 <= r < k

def solution(n, a_n, b_n, k):
    c_n = {}              #sucesion c_n que representa la union de a_n con b_n
    d_n = {}              #sucesion d_n que representa la intercepcion de a_n con b_n
    result = 1            #resultado de la operacion

    for a_i, b_i in zip(a_n, b_n):          #recorremos a_n y b_n al mismo tiempo
        if a_i == b_i:                      #si ambos elementos son iguales quiere decir que su par <x,y> es el mismo
            d_n[a_i] = d_n.get(a_i,0) + 2   #ya que estamos iterando por la misma posicion en ambas sucesiones
                                            #luego estos elementos pertenecen a la sucesion d_n
        c_n[a_i] = c_n.get(a_i,0) + 1
        c_n[b_i] = c_n.get(b_i,0) + 1       #añadimos ambos elementos a la sucesion c_n

    #procedemos a allar el valor del resultado, este seria la combinacion de todas las posibles
    #combinaciones de cada uno de los elementos que tengan el mismo valor: c_1*c_2*...*c_n
    #por ende recorremos la sucesion c_n completa
    for c_i, cant in c_n.items():
        #ahora debemos de hallar las posibles combinaciones de c_i, estas se dividen en 2
        #las que pertenecen a d_n y las que no pertenecen a d_n; notemos que si esta repetida
        #significa que las posibles combinaciones entre ellas se van a repetir por 2,
        #ya que solo existen un maximo de 2 elementos repetidos por cada d_i
        cant_rep = d_n.get(c_i,0)

        #hallamos las combinaciones de los elementos repetidos como 
        #la combinacion sin repeticion de todos los elementos entre 2
        for i in range(cant - cant_rep + 1, cant, 2): result = (result * i * (i + 1) // 2) % k

        #hallamos las combinaciones de los elementos no repetidos como 
        #la combinacion sin repeticion de todos los elementos
        for i in range(1, cant - cant_rep + 1): result = (result * i) % k

        #repetimos el proceso hasta el final de c_n; nocese que se multiplica directamente
        #el valor del resultado y que en cada multiplicacion se aplica el resto de la misma
        #esto es porque en la ecuacion general de: combin = km + r; setiene que si multiplicamos
        #la ecuacion por un c quedaria: c*combin = c*km + c*r => combin' = km' + c*r => en la 
        #proxima multiplicacion solo queda hallar de nuevo el % k del resto c*r que queda y seria: 
        #combin' = km' + km'' + r' => combin' = k(m' + m'') + r'; y r' seria nuestro nuevo resto

    return result

print(solution(n, a_n, b_n, k))