题目大意：有若干牛圈和两个连接起来的的中转点S1，S2。每个牛圈需要选择其中一个中转点与之连接，从而使任意两个牛圈能够连通。有若干对牛圈里的牛互相hate或是互相like。若两个牛圈里的牛互相hate，就不能连接到同一个中转点上，而如果互相like，就必须连接到同一个中转点上。连接方案还要使两个牛圈之间的距离的最大值尽可能小，并求出这个值。

思路：2-SAT+二分，对每个牛圈x，令x为与S1连接，¬x为与S2连接。接下来，对于每对互相hate的奶牛所在的牛圈a，b不能连接到同一个中转点上，所以连边（a，¬b），（¬b，a），（b，¬a），（¬a，b），对于每对互相like的奶牛所在的牛圈a，b必须连接到同一个中转点上，所以连边（a，b），（b，a），（¬a，¬b），（¬b，¬a）。之后要让所有连接起来的牛圈之间的距离的最大值尽量小，可以用二分，对每个距离，枚举所有相互连接的牛圈，牛圈（a，b）之间的连接方式又可以分为4种情况：

1）都连接在S1上

2）都连接在S2上

3）a连接在S1上并且b连接在S2上

4）a连接在S2上并且b连接在S1上

如果哪种连接方式使a,b的距离大于当前距离，就加边来限制这种连接。对于情况1），就连边（a，¬b）和（b，¬a）情况2）类似地去连边（¬a，b）和（¬b，a），对于情况3）就连边（a，b）和（¬b，¬a）情况4）类似地去连边（b，a）和（¬a，¬b）

最后如果二分没能找到结果就说明无法连接。

代码如下：

//POJ.2749
//Author: Prgl
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)

typedef pair<int, int>P;
typedef vector<int>vec;

#define INF 0x3f3f3f3f
const double EPS = 1e-18;
const int MOD = 1e9 + 7;
const int maxv = 1001;
const int maxn = 501;

int V;
vec G[maxv], rG[maxv];
stack<int>s;
bool used[maxv];
int cmp[maxv];

int N, A, B;
int sx1, sy1, sx2, sy2, D;
int X[maxn], Y[maxn];
P a[maxn], b[maxn];
int d1[maxn], d2[maxn], d[maxn];
bool one[maxn];

inline void add_edge(int from, int to)
{
    G[from].push_back(to);
    rG[to].push_back(from);
}

void add_edge_hate(int from, int to)
{
    add_edge(from, to + N);
    add_edge(to, from + N);
    add_edge(from + N, to);
    add_edge(to + N, from);
}

void add_edge_like(int from, int to)
{
    add_edge(from + N, to + N);
    add_edge(to + N, from + N);
    add_edge(from, to);
    add_edge(to, from);
}

inline int dis(int x1, int y1, int x2, int y2)
{
    return abs(x1 - x2) + abs(y1 - y2);
}

void dfs(int v)
{
    used[v] = true;
    for (int i = 0; i < G[v].size(); i++)
    {
        if (!used[G[v][i]])
            dfs(G[v][i]);
    }
    s.push(v);
}

void rdfs(int v, int k)
{
    cmp[v] = k;
    used[v] = true;
    for (int i = 0; i < rG[v].size(); i++)
    {
        if (!used[rG[v][i]])
            rdfs(rG[v][i], k);
    }
}

int scc()
{
    memset(used, 0, sizeof(used));
    for (int v = 0; v < V; v++)
    {
        if (!used[v])
            dfs(v);
    }
    memset(used, 0, sizeof(used));
    int k = 0;
    while (!s.empty())
    {
        int v = s.top();
        s.pop();
        if (!used[v])
            rdfs(v, k++);

    }

    return k;
}

bool C(int md)
{
    for (int i = 0; i < V; i++)
    {
        G[i].clear();
        rG[i].clear();
    }
    for (int i = 0; i < A; i++)
    {
        int u = a[i].first - 1, v = a[i].second - 1;
        add_edge_hate(u, v);
    }
    for (int i = 0; i < B; i++)
    {
        int u = b[i].first - 1, v = b[i].second - 1;
        add_edge_like(u, v);
    }
    for (int i = 0; i < N - 1; i++)
    {
        for (int j = i + 1; j < N; j++)
        {
            if (d1[i] + d1[j] > md)
            {
                add_edge(i, j + N);
                add_edge(j, i + N);
            }
            if (d2[i] + d2[j] > md)
            {
                add_edge(j + N, i);
                add_edge(i + N, j);
            }
            if (D + d1[i] + d2[j] > md)
            {
                add_edge(i, j);
                add_edge(j + N, i + N);
            }
            if (D + d2[i] + d1[j] > md)
            {
                add_edge(j, i);
                add_edge(i + N, j + N);
            }
        }
    }
    scc();
    for (int i = 0; i < N; i++)
    {
        if (cmp[i] == cmp[i + N])
            return false;
    }

    return true;
}

void solve()
{
    V = N * 2;
    D = dis(sx1, sy1, sx2, sy2);
    for (int i = 0; i < N; i++)
    {
        d1[i] = dis(X[i], Y[i], sx1, sy1);
        d2[i] = dis(X[i], Y[i], sx2, sy2);
    }
    int lo = -1, hi = 12000001;
    while (hi - lo > 1)
    {

        int mi = (hi + lo) / 2;
        if (C(mi))
            hi = mi;
        else
            lo = mi;
    }
    if (lo == 12000000)
        cout << -1 << endl;
    else
        cout << hi << endl;
}

int main()
{
    IOS;
    cin >> N >> A >> B;
    cin >> sx1 >> sy1 >> sx2 >> sy2;
    for (int i = 0; i < N; i++)
        cin >> X[i] >> Y[i];
    for (int i = 0; i < A; i++)
    {
        int u, v;
        cin >> u >> v;
        a[i] = P(u, v);
    }
    for (int i = 0; i < B; i++)
    {
        int u, v;
        cin >> u >> v;
        b[i] = P(u, v);
    }
    solve();

    return 0;
}