#include <iostream>
#include <algorithm>
#include <iterator>
#include <iomanip>
#include <utility>
#include <vector>
#include <limits>
#include <tuple>
#include <cmath>
using namespace std;

typedef long long ll;
using db = long double;

const int max_n = 100000, max_q = 100000, max_k = 5;

inline ll sqr(int x) { return 1ll * x * x; }
struct point
{
	int x, y; ll dis;
	point(int _x = 0, int _y = 0) : x(_x), y(_y), dis(sqr(x) + sqr(y)) { }
	point operator-(const point& rhs) const {
		return point(x - rhs.x, y - rhs.y);
	}
};

vector<point> a, b;
vector<vector<point>> hul;
int ck[max_q];
vector<tuple<point, int, ll>> qr;
vector<db> cand[max_q];

inline ll dot(const point& lhs, const point& rhs) { return 1ll * lhs.x * rhs.x + 1ll * lhs.y * rhs.y; }
inline ll cross(const point& lhs, const point& rhs) { return 1ll * lhs.x * rhs.y - 1ll * rhs.x * lhs.y; }

db inters(const point& ln, const point& dr)
{
	if (dot(ln, dr) <= 0)
		return numeric_limits<db>::infinity();
	db coef[2][3] = {
		{ 2. * ln.x, 2. * ln.y, 1. * ln.dis },
		{ 1. * dr.y, -1. * dr.x, 0. }
	};
	if (coef[0][0] == 0)
		swap(coef[0], coef[1]);
	db rto = coef[1][0] / coef[0][0];
	for (int i = 0; i < 3; i++)
		coef[1][i] -= rto * coef[0][i];
	rto = coef[0][1] / coef[1][1];
	for (int i = 0; i < 3; i++)
		coef[0][i] -= rto * coef[1][i];
	// cerr << coef[0][2] / coef[0][0] << " " << coef[1][2] / coef[1][1] << endl;
	return hypot(coef[0][2] / coef[0][0], coef[1][2] / coef[1][1]);
}

signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int n, q, stv = 0;
	
	cin >> n;
	a.reserve(n);
	
	for (int i = 0, x, y; i < n; i++)
	{
		cin >> x >> y;
		if (x == 0 && y == 0)
			stv++;
		else
			a.emplace_back(x, y);
	}
	
	for (int _ = 0; _ < max_k; _++)
	{
		// cerr << _ << " " << a.size() << endl;
		
		hul.emplace_back();
		hul[_].reserve(a.size());
		vector<point>& stk = hul[_];
		
		auto it = min_element(a.begin(), a.end(), [](auto lhs, auto rhs) {
			return lhs.dis < rhs.dis;
		});
		auto stp = *it;
		swap(*it, *a.begin());
		stk.push_back(stp);
		
		vector<tuple<point, ll>> tmp(a.size() - 1);
		transform(a.begin() + 1, a.end(), tmp.begin(), [&](auto x) {
			return make_tuple(x, cross(stp, x));
		});
		sort(tmp.begin(), tmp.end(), [](auto& lhs, auto& rhs) {
			return ((get<1>(lhs) >= 0) ^ (get<1>(rhs) >= 0)) ? 
				get<1>(lhs) > get<1>(rhs) : cross(get<0>(lhs), get<0>(rhs)) > 0;
		});
		
		auto check = [&](point& lp, point& mp, point& rp) {
			return cross(lp, rp) > 0 && 
				__int128(cross(lp, rp)) * dot(rp - mp, lp - mp) +
				__int128(dot(lp, rp)) * cross(rp - mp, lp - mp) >= 0;
		};
		
		for (auto& _$ : tmp)
		{
			auto& pt = get<0>(_$);
			// cerr << pt.x << " " << pt.y << " " << get<1>(_$) << endl;
			while (stk.size() > 1)
			{
				if (cross(stk.back(), pt) == 0 && dot(pt, stk.back()) > 0 && pt.dis < stk.back().dis)
				{
					b.push_back(stk.back());
					stk.pop_back();
				}
				else if (check(end(stk)[-2], stk.back(), pt))
				{
					b.push_back(stk.back());
					stk.pop_back();
				}
				else
					break;
			}
			if (cross(stk.back(), pt) == 0 && dot(pt, stk.back()) > 0 && pt.dis >= stk.back().dis)
				b.push_back(pt);
			else if (check(stk.back(), pt, stk.front()))
				b.push_back(pt);
			else
				stk.push_back(pt);
		}
		a.swap(b);
		if (a.empty())
			break;
		b.clear();
	}
	/*
	for (auto& x : hul)
	{
		for (auto& y : x)
			cerr << "(" << y.x << "," << y.y << ") ";
		cerr << endl;
	}
	*/
	
	cin >> q;
	qr.reserve(q);
	for (int i = 0; i < q; i++)
	{
		int x, y;
		cin >> x >> y >> ck[i];
		if (x != 0 || y != 0)
			qr.emplace_back(point(x, y), i, -1);
	}
	
	for (int _ = 0; _ < max_k && _ < int(hul.size()); _++)
	{
		auto& stk = hul[_];
		int cs = stk.size();
		
		for (auto& x : qr)
			get<2>(x) = cross(stk.front(), get<0>(x));
		sort(qr.begin(), qr.end(), [](auto& lhs, auto& rhs) {
			return ((get<2>(lhs) >= 0) ^ (get<2>(rhs) >= 0)) ? 
				get<2>(lhs) > get<2>(rhs) : cross(get<0>(rhs), get<0>(lhs)) < 0;
		});
		for (int i = 0, j = 0; i < int(qr.size()); i++)
		{
			auto [pt, id, _$] = qr[i];
			// cerr << pt.x << "," << pt.y << endl;
			
			while (dot(stk[j], pt) <= 0 && cross(stk[j], stk[(j + 1) % cs]) > 0)
				j = (j + 1) % cs;
			while (inters(stk[j], pt) > inters(stk[(j + 1) % cs], pt))
				j = (j + 1) % cs;
			// cerr << stk[j].x << " " << stk[j].y << "  " << pt.x << " " << pt.y << endl;
			
			if (cs < (ck[id] - _) * 2)
			{
				for (int l = 0; l < cs; l++)
					cand[id].push_back(inters(stk[l], pt));
			}
			else if (ck[id] - _ > 0)
			{
				for (int tc = 0, aj = j, bj = (j + 1) % cs; tc < ck[id] - _; tc++, aj--, bj++)
				{
					if (aj < 0) aj += cs;
					if (bj == cs) bj = 0;
					// cerr << aj << " " << bj << " ";
					cand[id].push_back(inters(stk[aj], pt));
					cand[id].push_back(inters(stk[bj], pt));
				}
				// cerr << " ---> " << cs << endl;
			}
		}
	}
	
	cout << fixed;
	for (int i = 0; i < q; i++)
	{
		sort(cand[i].begin(), cand[i].end());
		// for (auto x : cand[i])
		// 	cerr << x << " ";
		// cerr << endl;
		if (ck[i] <= stv)
			cout << "0.0000000000";
		else if (int(cand[i].size()) < ck[i] - stv || cand[i][ck[i] - stv - 1] == numeric_limits<db>::infinity())
			cout << "-1";
		else
			cout << setprecision(10) << cand[i][ck[i] - stv - 1];
		cout << "\n";
	}
	
	return 0;
}