#include <bits/stdc++.h>

using i64 = long long;

struct Point {
    i64 x = 0;
    i64 y = 0;
};

Point operator-(const Point &a, const Point &b) {
    return {a.x - b.x, a.y - b.y};
}

int sgn(const Point &a) {
    return a.y > 0 || (a.y == 0 && a.x > 0) ? 1 : -1;
}

i64 cross(const Point &a, const Point &b) {
    return a.x * b.y - a.y * b.x;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m, e;
    std::cin >> n >> m >> e;

    std::vector<Point> a(n), b(m);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i].x >> a[i].y;
    }
    for (int i = 0; i < m; i++) {
        std::cin >> b[i].x >> b[i].y;
    }

    std::vector<std::vector<int>> adj(n);
    std::vector<int> to(2 * e);
    for (int i = 0; i < e; i++) {
        int x, y;
        std::cin >> x >> y;
        x--, y--;
        to[2 * i] = y;
        to[2 * i + 1] = x;
        adj[x].push_back(2 * i);
        adj[y].push_back(2 * i + 1);
    }

    std::vector<int> pos(2 * e);
    for (int i = 0; i < n; i++) {
        std::sort(adj[i].begin(), adj[i].end(),
            [&](int j, int k) {
                Point u = a[to[j]] - a[i];
                Point v = a[to[k]] - a[i];
                if (sgn(u) != sgn(v)) {
                    return sgn(u) == 1;
                }
                return cross(u, v) > 0;
            });
        for (int j = 0; j < adj[i].size(); j++) {
            pos[adj[i][j]] = j;
        }
    }

    std::vector<std::vector<int>> polygon;
    std::vector<i64> area;
    std::vector<bool> vis(2 * e);
    for (int i = 0; i < 2 * e; i++) {
        if (vis[i]) {
            continue;
        }
        std::vector<int> p;
        int j = i;
        i64 sum = 0;
        while (!vis[j]) {
            p.push_back(j);
            vis[j] = true;
            sum += cross(a[to[j ^ 1]], a[to[j]]);
            j = adj[to[j]][(pos[j ^ 1] - 1 + adj[to[j]].size()) % adj[to[j]].size()];
        }
        polygon.push_back(p);
        area.push_back(sum);
    }

    std::vector<int> ans(e);
    for (auto o : b) {
        for (int i = 0; i < polygon.size(); i++) {
            int t = area[i] < 0 ? 1 : 0;
            for (auto j : polygon[i]) {
                Point u = a[to[j ^ 1]];
                Point v = a[to[j]];
                if (u.x < o.x && v.x >= o.x && cross(v - o, u - o) > 0) {
                    t--;
                }
                if (v.x < o.x && u.x >= o.x && cross(u - o, v - o) > 0) {
                    t++;
                }
            }
            assert(t == 0 || t == 1);
            if (t == 1) {
                for (auto j : polygon[i]) {
                    ans[j / 2] = 1;
                }
            }
        }
    }
    for (int i = 0; i < e; i++) {
        std::cout << ans[i];
    }
    std::cout << "\n";

    return 0;
}