#include "bits/stdc++.h"
using namespace std;

#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define RFOR(i,b,a) for (int i = (b) - 1; i >= (a); i--)
#define ITER(it,a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)
#define FILL(a,value) memset(a, value, sizeof(a))

#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;

const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const LL LINF = INF * (LL) INF;

const double EPS = 1e-7;
const int MAX = 200200;

struct point
{
    double x, y;
	int id;
    point() {}
    point(double x, double y, int id) : x(x), y(y), id(id) {};
    point operator-(const point& p)const
    {
        return point (x - p.x, y - p.y, id);
    }
    point operator+(const point& p)const
    {
        return point (x + p.x, y + p.y, id);
    }
    double operator*(const point & p) const
    {
        return x * p.y - y * p.x;
    }
    point operator*(double k) const
    {
        return point(k * x, k * y, id);
    }
    double d2() const
    {
        return x * x + y * y;
    }
    double len() const
    {
        return sqrt(d2());
    }
    bool operator==(const point & p) const
    {
        return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
    }
    bool operator<(const point & p) const
    {
        if (abs(x - p.x) > EPS)return x < p.x;
        if (abs(y - p.y) > EPS)return y < p.y;
        return 0;
    }
    point rotate(double cosx, double sinx) const //ccw
    {
        double xx = x * cosx - y * sinx;
        double yy = x * sinx + y * cosx;
        return point(xx, yy, id);
    }
    point rotate(double ang) const //ccw
    {
        return rotate(cos(ang), sin(ang));
    }
    point scale(double l) const  //assuming len of vector > 0
    {
        l /= len();
        return point(l * x, l * y, id);
    }
    double dot(const point& p) const
    {
        return x * p.x + y * p.y;
    }
    double polar() const // (-PI; PI]
    {
        double ang = atan2(y, x);
        //if (ang < -EPS)ang += 2 * PI; // if need [0; 2 * PI)
        return ang;
    }
    int hp() const //halfpalne relative to X-axis
    {
        return y < -EPS || (abs(y) < EPS && x < -EPS);
    }
};

bool cmpVec(const point& a, const point& b) //sort by polar angle [0; 2*PI)
{
    if (a.hp() != b.hp())return a.hp() < b.hp();
    return a * b > EPS;
}
int sign(double x)
{
    if (abs(x) < EPS)return 0;
    return x > 0 ? 1 : -1;
}

double RES[MAX];

vector<point> v;
VI r;

double getAns(point a, point v)
{
	v = v * (1 / v.len());
	int l = 0, r = SZ(::r) - 1;
	while(r - l > 3)
	{
		int m = (r - l) / 3;
		int m1 = l + m;
		int m2 = r - m;

		point p1 = v * ::r[m1];
		point p2 = v * ::r[m2];

		double d1 = (p1 - a).len();
		double d2 = (p2 - a).len();
		if (d1 < d2) r = m2;
		else l = m1;
	}

	double res = 1e47;
	FOR (i, l, r + 1)
	{
		point p = v * ::r[i];
		double d = (p - a).len();
		res = min(res, d);
	}
	return res;
}

void solve()
{
	point lastPoint;
	FOR (i, 0, SZ(v))
	{
		if (v[i].id == -1) lastPoint = v[i];
	}

	FOR (i, 0, SZ(v))
	{
		if (v[i].id == -1) lastPoint = v[i];
		else
		{
			double cur = getAns(v[i], lastPoint);
			RES[v[i].id] = min(RES[v[i].id], cur);
		}
	}
}


int main(int argc, char* argv[])
{
	//ios::sync_with_stdio(false); cin.tie(0);

	int r, f, n;
	scanf("%d%d%d", &r, &f, &n);
	FOR (i, 0, r)
	{
		int x;
		scanf("%d", &x);
		::r.PB(x);
	}

	sort(ALL(::r));

	FOR (i, 0, f)
	{
		int x, y;
		scanf("%d%d", &x, &y);

		v.PB(point(x, y, -1));
	}
	FOR (i, 0, n)
	{
		int x, y;
		scanf("%d%d", &x, &y);
		v.PB(point(x, y, i));
		RES[i] = 1e47;
	}


	sort(ALL(v), cmpVec);
	solve();
	reverse(ALL(v));
	solve();

	FOR (i, 0, n)
	{
		printf("%.13f\n", RES[i]);
	}

}