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 JAVA):

Solution:
import java.util.*;
import java.io.*;

public class RadioStations {
    static int N;
    static ArrayList<Integer>[] graph;
    static Integer[] arr;
    static int[] comp;
    static int[] pre, ll;
    static int v;
    public static void main(String[] args) {
        FastScanner scanner = new FastScanner();
        PrintWriter out = new PrintWriter(System.out,false);
        int n = scanner.nextInt();
        int p = scanner.nextInt();
        int M = scanner.nextInt();
        int m = scanner.nextInt();
        v = p + M-1;
        N = v * 2;
        graph = new ArrayList[N];
        arr = new Integer[N];
        comp = new int[N];
        for(int i =0; i < N; i++) {
            arr[i] = i;
            graph[i] = new ArrayList<>();
        }
        pre = new int[N];
        ll = new int[N];
        Arrays.fill(pre, -1);
        for(int i = 0; i < n; i++) {
            int x= scanner.nextInt()-1, y= scanner.nextInt()-1;
            addOR(x<<1,y<<1);
        }
        for(int i = 0; i < p; i++) {
            int l = scanner.nextInt(), r = scanner.nextInt();
            if (l > 1) {
                addOR((l-2+p) <<1, i * 2 + 1);
            }
            if (r < M) {
                addOR((r-1+p)*2+1, i*2 + 1);
            }
        }
        for(int i = 0; i< m; i++) {
            int u = scanner.nextInt()-1, v = scanner.nextInt()-1;
            addOR(2*u+1, 2*v+1);
        }
        for(int i = 2; i < M; i++) {
            addOR((i-2+p)*2, (i-1+p)*2+1);
        }
        stack = new ArrayDeque<>(N/4);
        for(int i = 0; i < 2 * v; i++) {
            if (pre[i] == -1) dfs(i);
        }
        int pow = 1;
        ArrayList<Integer> vals = new ArrayList<>(N/4);
        for(int i = 0; i < v; i++) {
            if (comp[i<<1] == comp[i*2+1]) {
                System.out.println(-1);
                return;
            }
            else if (comp[i << 1] < comp[i*2+1]) {
                if (i < p) vals.add(arr[i+1]);
                else pow = Math.max(pow, i - p +2);
            }
        }
        out.println(vals.size() + " " + pow);
        for(int index: vals) out.print(index + " ");
        out.println();
        out.flush();
    }
    static int cnt = 0;
    static ArrayDeque<Integer> stack;
    static void dfs(int v) {
        pre[v] = cnt++;
        ll[v] = pre[v];
        stack.push(arr[v]);
        for(int u: graph[v]) {
            if (pre[u] == -1) dfs(u);
            ll[v] = Math.min(ll[v], ll[u]);
        }
        if (pre[v] == ll[v]) {
            while(true) {
                int cur = stack.pop();
                comp[cur] = curscc;
                ll[cur] = N+1;
                if (cur == v) break;
            }
            curscc++;
        }
    }
    static int curscc = 0;
    static void addOR(int ind1, int ind2) {
        addEdge(ind1 ^ 1, ind2);
        addEdge(ind2 ^ 1, ind1);
    }
    static void addEdge(int ind1, int ind2) {
        graph[ind1].add(arr[ind2]);
    }
    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }
        public FastScanner() {
            this(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
    }
}