import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class G {

    // Define the Problem class with difficulty and index
    static class Problem {
        int difficulty;
        int index;

        public Problem(int difficulty, int index) {
            this.difficulty = difficulty;
            this.index = index;
        }
    }

    public static void main(String[] args) throws IOException {
        // Initialize BufferedReader for efficient input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // Read the first line and parse n, p, q, s
        String[] firstLine = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(firstLine[0]);
        int p = Integer.parseInt(firstLine[1]);
        int q = Integer.parseInt(firstLine[2]);
        int s = Integer.parseInt(firstLine[3]);

        // Read p classical problems
        Problem[] classical = new Problem[p];
        for (int i = 0; i < p; i++) {
            int difficulty = Integer.parseInt(br.readLine().trim());
            classical[i] = new Problem(difficulty, i);
        }

        // Read q creative problems
        Problem[] creative = new Problem[q];
        for (int i = 0; i < q; i++) {
            int difficulty = Integer.parseInt(br.readLine().trim());
            creative[i] = new Problem(difficulty, i);
        }

        // Sort creative problems in descending order of difficulty once before the loop
        Arrays.sort(creative, new Comparator<Problem>() {
            @Override
            public int compare(Problem a, Problem b) {
                return Integer.compare(b.difficulty, a.difficulty);
            }
        });

        // Define the comparator for the TreeSet (sorted by difficulty, then index)
        Comparator<Problem> problemComparator = new Comparator<Problem>() {
            @Override
            public int compare(Problem a, Problem b) {
                if (a.difficulty != b.difficulty) {
                    return Integer.compare(a.difficulty, b.difficulty);
                }
                return Integer.compare(a.index, b.index);
            }
        };

        // Initialize binary search boundaries
        int lower = 0;
        int upper = 1_000_000_001;

        // Binary search to find the minimal possible mid
        while (upper > lower) {
            int mid = lower + (upper - lower) / 2;

            // Initialize TreeSet with classical problems
            TreeSet<Problem> treeSet = new TreeSet<>(problemComparator);
            treeSet.addAll(Arrays.asList(classical));

            int here = 0;

            // Iterate over creative problems sorted in descending order
            for (Problem problem : creative) {
                // Calculate the limit using Math.min
                int limit = Math.min(s - problem.difficulty, problem.difficulty + mid);

                // Create a dummy problem to use with floor
                Problem key = new Problem(limit, Integer.MAX_VALUE);

                // Find the floor problem in the TreeSet
                Problem other = treeSet.floor(key);

                // Check if the found problem satisfies the difficulty constraint
                if (other != null && other.difficulty >= (problem.difficulty - mid)) {
                    treeSet.remove(other);
                    here++;
                }

                // Early exit if we've already found enough pairs
                if (here >= n) {
                    break;
                }
            }

            // Adjust binary search boundaries based on the number of pairs found
            if (here >= n) {
                upper = mid;
            } else {
                lower = mid + 1;
            }
        }

        // After binary search, check if a valid solution was found
        if (upper == 1_000_000_001) {
            System.out.println(-1);
        } else {
            System.out.println(upper);
        }
    }
}