#include <bits/stdc++.h>

using i64 = long long;
using real = long double;
using i128 = __int128;

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

    real norm(){
        return std::hypot(x,y);
    }
};

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

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

int sgn(const Point &a) {
	if (a.x == 0 && a.y == 0) {
		return 0;
	}
	if (a.y > 0 || (a.y == 0 && a.x > 0)) {
		return 1;
	} else {
		return 2;
	}
}

bool operator<(const Point &a, const Point &b) {
	if (sgn(a) != sgn(b)) {
		return sgn(a) < sgn(b);
	}
	return cross(a, b) > 0;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::cout << std::fixed << std::setprecision(10);

    int R, F, N;
    std::cin >> R >> F >> N;

    std::vector<int> d(R);
    for (int i = 0; i < R; i++) {
        std::cin >> d[i];
    }
    std::sort(d.begin(), d.end());
    std::vector<Point> t(F);
    for (int i = 0; i < F; i++) {
        int x, y;
        std::cin >> x >> y;
        t[i] = {x, y};
    }
    std::sort(t.begin(), t.end());

    while (N--) {
        int x, y;
        std::cin >> x >> y;
        Point p = {x, y};
        real dis = p.norm();

    
        int j = std::lower_bound(t.begin(), t.end(), p) - t.begin();
        real ans = INFINITY;
        for (auto b : {t[j % F], t[(j - 1 + F) % F]}) {
        	real rdis = dot(p, b) / b.norm();
            int k = std::lower_bound(d.begin(), d.end(), rdis) - d.begin();
            for (auto v : {d[k % R], d[(k - 1 + R) % R]}) {
            	real t = (real)(v - rdis) * (v - rdis) + ((i128)dot(p, p) * dot(b, b) - (i128)dot(b, p) * dot(b, p)) / (real)dot(b, b);
            	ans = std::min(ans, std::sqrt(std::abs(t)));
            }
        }
        std::cout << ans << "\n";
    }

    return 0;
}