Problem: In addition to complaints about lighting, a lot of complaints about insufficient radio signal covering has been received by Bertown city hall recently. n complaints were sent to the mayor, all of which are suspiciosly similar to each other: in the i-th complaint, one of the radio fans has mentioned that the signals of two radio stations x_i and y_i are not covering some parts of the city, and demanded that the signal of at least one of these stations can be received in the whole city.

Of cousre, the mayor of Bertown is currently working to satisfy these complaints. A new radio tower has been installed in Bertown, it can transmit a signal with any integer power from 1 to M (let's denote the signal power as f). The mayor has decided that he will choose a set of radio stations and establish a contract with every chosen station. To establish a contract with the i-th station, the following conditions should be met:

  * the signal power f should be not less than l_i, otherwise the signal of the i-th station won't cover the whole city; 
  * the signal power f should be not greater than r_i, otherwise the signal will be received by the residents of other towns which haven't established a contract with the i-th station. 



All this information was already enough for the mayor to realise that choosing the stations is hard. But after consulting with specialists, he learned that some stations the signals of some stations may interfere with each other: there are m pairs of stations (u_i, v_i) that use the same signal frequencies, and for each such pair it is impossible to establish contracts with both stations. If stations x and y use the same frequencies, and y and z use the same frequencies, it does not imply that x and z use the same frequencies.

The mayor finds it really hard to analyze this situation, so he hired you to help him. You have to choose signal power f and a set of stations to establish contracts with such that:

  * all complaints are satisfied (formally, for every i ∈ [1, n] the city establishes a contract either with station x_i, or with station y_i); 
  * no two chosen stations interfere with each other (formally, for every i ∈ [1, m] the city does not establish a contract either with station u_i, or with station v_i); 
  * for each chosen station, the conditions on signal power are met (formally, for each chosen station i the condition l_i ≤ f ≤ r_i is met). 

Input

The first line contains 4 integers n, p, M and m (2 ≤ n, p, M, m ≤ 4 ⋅ 10^5) — the number of complaints, the number of radio stations, maximum signal power and the number of interfering pairs, respectively.

Then n lines follow, which describe the complains. Each line contains two integers x_i and y_i (1 ≤ x_i < y_i ≤ p) — the indices of the radio stations mentioned in the i-th complaint). All complaints are distinct.

Then p lines follow, which describe the radio stations. Each line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ M) — the constrains on signal power that should be satisfied if the city establishes a contract with the i-th station.

Then m lines follow, which describe the pairs of interfering radio stations. Each line contains two integers u_i and v_i (1 ≤ u_i < v_i ≤ p) — the indices of interfering radio stations. All these pairs are distinct.

Output

If it is impossible to choose signal power and a set of stations to meet all conditions, print -1.

Otherwise print two integers k and f in the first line — the number of stations in the chosen set and the chosen signal power, respectively. In the second line print k distinct integers from 1 to p — the indices of stations to establish contracts with (in any order). If there are multiple answers, print any of them; you don't have to minimize/maximize the number of chosen stations, and the same applies to signal power.

Examples

Input


2 4 4 2
1 3
2 3
1 4
1 2
3 4
1 4
1 2
3 4


Output


2 3
1 3 

Input


2 4 4 2
1 3
2 4
1 2
1 2
3 4
3 4
1 2
3 4


Output


-1

Solution (in PYTHON3):

Solution:
# ------------------- fast io --------------------
import os
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

# ------------------- fast io --------------------

def find_SCC(graph):
    SCC, S, P = [], [], []
    depth = [0] * len(graph)
    
    stack = list(range(len(graph)))
    while stack:
        node = stack.pop()
        if node < 0:
            d = depth[~node] - 1
            if P[-1] > d:
                SCC.append(S[d:])
                del S[d:], P[-1]
                for node in SCC[-1]:
                    depth[node] = -1
        elif depth[node] > 0:
            while P[-1] > depth[node]:
                P.pop()
        elif depth[node] == 0:
            S.append(node)
            P.append(len(S))
            depth[node] = len(S)
            stack.append(~node)
            stack += graph[node]
    SCC = SCC[::-1]
    cx = [-1] * (len(graph))
    for i in range(len(SCC)):
        for j in SCC[i]:
            cx[j] = i
    return cx


for _ in range(int(input()) if not True else 1):
    # n = int(input())
    n, p, M, m = map(int, input().split())
    # a, b = map(int, input().split())
    # c, d = map(int, input().split())
    # a = list(map(int, input().split()))
    # b = list(map(int, input().split()))
    # s = input()
    
    graph = [[] for __ in range(2 * p + 2 * M + 1)]
    
    for i in range(n):
        x, y = map(int, input().split())
        x2 = (x + p)
        y2 = (y + p)
        graph[x2] += [y]
        graph[y2] += [x]
    
    for x in range(1, p + 1):
        l, r = map(int, input().split())
        x2 = (x + p)
        l += 2 * p
        r += 2 * p + 1
        graph[l+M] += [x2]
        graph[x] += [l]
        if r + M != 2 * p + 2 * M + 1:
            graph[r] += [x2]
            graph[x] += [r + M]
    
    for i in range(m):
        x, y = map(int, input().split())
        x2 = (x + p)
        y2 = (y + p)
        graph[x] += [y2]
        graph[y] += [x2]
    
    for i in range(1, M):
        graph[2 * p + i + M] += [2 * p + i + M + 1]
        graph[2 * p + i + 1] += [2 * p + i]
    
    cx = find_SCC(graph)
    ans = []
    for i in range(1, p + 1):
        if cx[i] > cx[i + p]:
            ans += [i]
    
    if not ans:
        print(-1)
        quit()
    
    for freq in range(M, 0, -1):
        if cx[2 * p + freq] > cx[2 * p + freq + M]:
            break
    print(len(ans), freq)
    print(*ans)