#include <bits/stdc++.h>
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define F(i, x, y) for (int i = (x); i <= (y); i++)
#define R(i, x, y) for (int i = (x); i >= (y); i--)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)


using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
bool Mbe;

namespace big{

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;

struct BigDecimal {
private:
	int _size;
	int *_digits;
public:
	static const int IDLE_DIGITS = 13;
	static const int MAX_BITS = 30;
	static const int MAX_VALUE = (1 << MAX_BITS);
	static const int MAX_MASK = (1 << MAX_BITS) - 1;
	static const int conv_width = floor(log10(MAX_VALUE - 1));
	static const i64 conv_pow = pow(10, conv_width);
	static const int DIG = 50;
	static const int DLEN = ceil((DIG + IDLE_DIGITS) * log2(10) / MAX_BITS);
	int long_size(i64 x) {
		int res = 1; x = abs(x);
		while (x >>= MAX_BITS)
			++ res;
		return res;
	}
	void load_long(i64 x) {
		if (x == 0)
			_size = 0, _digits = nullptr;
		else {
			_size = long_size(x) + DLEN;
			_digits = new int[_size];
			memset(_digits, 0, sizeof(int) * _size);
			if (x < 0) _size = -_size;
			int ptr = DLEN; x = abs(x);
			while (x) {
				_digits[ptr ++] = x & MAX_MASK;
				x >>= MAX_BITS;
			}
		}
	}
	BigDecimal(): _size(0), _digits(nullptr) {}
	BigDecimal(int x) { load_long(x); }
	BigDecimal(i64 x)  { load_long(x); }
	BigDecimal(const char *str) {
		bool flg = false;
		if (*str == '-')
			flg = true, ++ str;
		const char *int_part = str;
		while (*int_part != '\0' && *int_part != '.')
			++ int_part;
		int int_len = int_part - str;
		_size = DLEN + ceil(int_len * log2(10) / MAX_BITS);
		_digits = new int[_size];
		memset(_digits, 0, sizeof(int) * _size);

		static i64 _pow10[conv_width + 1] = {0};
		if (_pow10[0] == 0) {
			_pow10[0] = 1;
			for (int i = 1; i <= conv_width; i ++)
				_pow10[i] = _pow10[i - 1] * 10;
		}

		int k, cur_width = 0, top_pos = DLEN;
		i64 cur_num = 0;
		while (str < int_part) {
			k = (*str) ^ 48;
			++ cur_width;
			cur_num = cur_num * 10 + k;
			if ((++ str) == int_part || cur_width == conv_width) {
				for (int i = DLEN; i < top_pos; i ++) {
					cur_num += _pow10[cur_width] * _digits[i];
					_digits[i] = cur_num & MAX_MASK;
					cur_num >>= MAX_BITS;
				}
				while (cur_num) {
					_digits[top_pos ++] = cur_num & MAX_MASK;
					cur_num >>= MAX_BITS;
				}
				cur_width = 0;
			}
		}

		if (*int_part == '.') {
			const char *dec_part = ++ int_part;
			const char *end = dec_part;
			while (*end != '\0')
				++ end;
			if (dec_part != end) {
				int dec_len = ceil((double)(end - dec_part) / conv_width);
				int *assist = new int[dec_len];
				memset(assist, 0, sizeof(int) * dec_len);

				for (int i = 0; i < dec_len; i ++) {
					for (int j = conv_width - 1; j >= 0; j --) {
						if (*dec_part == '\0')
							break;
						assist[i] += _pow10[j] * ((*dec_part++) ^ 48);
					}
				}

				for (int i = DLEN - 1; i >= 0; i --) {
					i64 carry = 0;
					for (int j = dec_len - 1; j >= 0; j --) {
						carry += (i64)MAX_VALUE * assist[j];
						assist[j] = carry % conv_pow;
						carry /= conv_pow;
					}
					_digits[i] = carry;
				}

				if (assist[0] >= conv_pow / 2) {
					for (int i = 0; i < _size; i ++) {
						if (++ _digits[i] >= MAX_VALUE)
							_digits[i] = 0;
						else
							break;
					}
				}

				delete[] assist;
			}
		}
		if (flg)
			_size = -_size;
		normalize();
	}
	~BigDecimal() {
		delete[] _digits;
	}
	void copy_from_other(const BigDecimal &bd) {
		_size = bd._size;
		if (_digits != nullptr)
			delete[] _digits, _digits = nullptr;
		if (_size != 0) {
			_digits = new int[abs(_size)];
			memcpy(_digits, bd._digits, sizeof(int) * abs(_size));
		}
	}
	BigDecimal(const BigDecimal &bd): _digits(nullptr) {
		copy_from_other(bd);
	}
	BigDecimal &operator=(const BigDecimal &bd) {
		if (this != &bd)
			copy_from_other(bd);
		return *this;
	}
	void swap(BigDecimal &bd) {
		std::swap(_size, bd._size);
		std::swap(_digits, bd._digits);
	}
	static BigDecimal epsilon() {
		BigDecimal res;
		res._size = 1;
		res._digits = new int[1];
		res._digits[0] = 1;
		return res;
	}
	int size() const { return abs(_size); }
	int int_size() const { return std::max(abs(_size) - DLEN, 0); }
	bool is_zero() const { return _size == 0; }
	bool is_nega() const { return _size < 0; }
	bool is_posi() const { return _size > 0; }
	void negate() { _size = -_size; }
	void normalize() {
		int i = size();
		while (i != 0 && _digits[i - 1] == 0)
			-- i;
		_size = (_size >= 0 ? i : -i);
	}
	void align(int new_size) {
		if (_size == 0)
			return;
		if (new_size <= 0) {
			_size = 0;
			delete[] _digits;
			_digits = nullptr;
			return;
		}
		int *temp = new int[new_size];
		memset(temp, 0, sizeof(int) * new_size);
		int valid = std::min(size(), new_size);
		memcpy(temp + std::max(0, new_size - valid)
			, _digits + std::max(0, size() - valid)
			, sizeof(int) * valid);
		if (is_nega())
			new_size = -new_size;
		_size = new_size;
		if (_digits != nullptr)
			delete[] _digits;
		_digits = temp;
	}
	void print(int MAX_DIG = DIG) {
		if (is_nega())
			putchar('-');
		int work_len = std::max((int)DLEN, size());
		int *assist = new int[work_len + 1];
		memset(assist, 0, sizeof(int) * (work_len + 1));
		if (size())
			memcpy(assist, _digits, sizeof(int) * size());

		char *dec_result = new char[MAX_DIG + 1];
		for (int i = 0; i <= MAX_DIG; i += conv_width) {
			i64 carry = 0;
			for (int j = 0; j < DLEN; j ++) {
				carry += conv_pow * assist[j];
				assist[j] = carry & MAX_MASK;
				carry >>= MAX_BITS;
			}
			for (int j = 0; j < conv_width; j ++) {
				int pos = i + conv_width - 1 - j;
				if (pos <= MAX_DIG)
					dec_result[pos] = ('0' + carry % 10);
				carry /= 10;
			}
		}

		if (dec_result[MAX_DIG] >= '5') {
			bool carry = true;
			for (int i = MAX_DIG - 1; i >= 0 && carry; i --) {
				if (dec_result[i] == '9')
					dec_result[i] = '0';
				else
					++ dec_result[i], carry = false;
			}
			if (carry) {
				for (int i = DLEN; i <= work_len; i ++) {
					if (++ assist[i] >= MAX_VALUE)
						assist[i] = 0;
					else
						break;
				}
			}
		}

		int top_pos = work_len;
		while (top_pos >= DLEN && assist[top_pos] == 0)
			-- top_pos;
		if (top_pos == DLEN - 1)
			putchar('0');
		else {
			int estimate_len = ceil((top_pos - DLEN + 1) * log10(MAX_VALUE));
			estimate_len = (estimate_len + conv_width - 1) / conv_width * conv_width;
			char *int_result = new char[estimate_len];
			for (int i = 0; i < estimate_len; i += conv_width) {
				i64 carry = 0;
				for (int j = top_pos; j >= (int)DLEN; j --) {
					carry = (carry << MAX_BITS) ^ assist[j];
					assist[j] = carry / conv_pow;
					carry = carry % conv_pow;
				}
				while (top_pos >= DLEN && assist[top_pos] == 0)
					-- top_pos;
				for (int j = 0; j < conv_width; j ++)
					int_result[i + j] = ('0' + carry % 10), carry /= 10;
			}
			bool printed = false;
			for (int i = estimate_len - 1; i >= 0; i --)
				if (printed |= int_result[i] != '0')
					putchar(int_result[i]);
			delete[] int_result;
		}
		putchar('.');
		for (int i = 0; i < MAX_DIG; i ++)
			putchar(dec_result[i]);
		delete[] dec_result;
	}
	friend int compare(const BigDecimal &a, const BigDecimal &b) {
		if (a._size != b._size)
			return a._size - b._size;
		for (int i = a.size() - 1; i >= 0; i --) if (a._digits[i] != b._digits[i])
			return a._size > 0 ? a._digits[i] - b._digits[i] : b._digits[i] - a._digits[i];
		return 0;
	}
	friend bool operator<(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) < 0;
	}
	friend bool operator>(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) > 0;
	}
	friend bool operator<=(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) <= 0;
	}
	friend bool operator>=(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) >= 0;
	}
	friend bool operator==(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) == 0;
	}
	friend bool operator!=(const BigDecimal &a, const BigDecimal &b) {
		return compare(a, b) != 0;
	}

	void mul_num(i64 x) {
		if (is_zero())
			return;
		if (x < 0) x = -x, negate();
		int l = size();
		(is_nega() ? _size -= long_size(x) : _size += long_size(x));
		int *new_num = new int[size()];
		u64 carry = 0, low = x & MAX_MASK, high = x >> MAX_BITS;
		int i = 0;
		for (; i < l; i ++) {
			carry += low * _digits[i];
			new_num[i] = carry & MAX_MASK;
			carry >>= MAX_BITS;
			carry += high * _digits[i];
		}
		while (carry) {
			new_num[i ++] = carry & MAX_MASK;
			carry >>= MAX_BITS;
		}
		for (; i < size(); i ++)
			new_num[i] = 0;
		delete[] _digits;
		_digits = new_num;
		normalize();
	}
	friend BigDecimal operator*(const BigDecimal &a, const i64 x) {
		BigDecimal res = a;
		res.mul_num(x);
		return res;
	}
	friend BigDecimal operator*(const BigDecimal &a, const int x) {
		BigDecimal res = a;
		res.mul_num(x);
		return res;
	}
	void div_num(i64 x) {
		if (x < 0) x = -x, negate();
		i64 carry = 0;
		for (int i = size() - 1; i >= 0; i --) {
			carry = (carry << MAX_BITS) ^ _digits[i];
			_digits[i] = carry / x;
			carry %= x;
		}
		normalize();
	}
	friend BigDecimal operator/(const BigDecimal &a, const i64 x) {
		BigDecimal res = a;
		res.div_num(x);
		return res;
	}
	friend BigDecimal operator/(const BigDecimal &a, const int x) {
		BigDecimal res = a;
		res.div_num(x);
		return res;
	}
	friend BigDecimal &operator<<=(BigDecimal &a, const int x) {
		a.align(a.size() + x);
		return a;
	}
	friend BigDecimal &operator>>=(BigDecimal &a, const int x) {
		a.align(a.size() - x);
		return a;
	}

	friend BigDecimal num_add(const BigDecimal &a, const BigDecimal &b) {
		if (a.size() < b.size())
			return num_add(b, a);
		BigDecimal res(0);
		res._size = a.size() + 1;
		res._digits = new int[res._size];
		int i = 0, carry = 0;
		for (; i < b.size(); i ++) {
			carry = carry + a._digits[i] + b._digits[i];
			res._digits[i] = carry & MAX_MASK;
			carry >>= MAX_BITS;
		}
		for (; i < a.size(); i ++) {
			carry = carry + a._digits[i];
			res._digits[i] = carry & MAX_MASK;
			carry >>= MAX_BITS;
		}
		res._digits[i] = carry;
		res.normalize();
		return res;
	}
	friend BigDecimal num_sub_basic(const BigDecimal &a, const BigDecimal &b) {
		BigDecimal res(0);
		res._size = a.size();
		res._digits = new int[res._size];
		u32 borrow = 0;
		int i = 0;
		for (; i < b.size(); i ++) {
			borrow = a._digits[i] - borrow - b._digits[i];
			res._digits[i] = borrow & MAX_MASK;
			borrow >>= MAX_BITS;
			borrow &= 1;
		}
		for (; i < a.size(); i ++) {
			borrow = a._digits[i] - borrow;
			res._digits[i] = borrow & MAX_MASK;
			borrow >>= MAX_BITS;
			borrow &= 1;
		}
		res.normalize();
		return res;
	}
	friend BigDecimal num_sub(const BigDecimal &a, const BigDecimal &b) {
		if (a.size() > b.size())
			return num_sub_basic(a, b);
		if (a.size() < b.size()) {
			BigDecimal res = num_sub_basic(b, a);
			res.negate();
			return res;
		}
		for (int i = a.size() - 1; i >= 0; i --) if (a._digits[i] != b._digits[i]) {
			if (a._digits[i] < b._digits[i]) {
				BigDecimal res = num_sub_basic(b, a);
				res.negate();
				return res;
			}
			else
				return num_sub_basic(a, b);
		}
		return BigDecimal();
	}
	friend BigDecimal operator-(const BigDecimal &a) {
		BigDecimal res = a;
		res.negate();
		return res;
	}
	friend BigDecimal operator+(const BigDecimal &a, const BigDecimal &b) {
		if (a.is_zero())
			return b;
		if (b.is_zero())
			return a;
		if (a.is_nega()) {
			if (b.is_nega()) {
				BigDecimal res = num_add(a, b);
				res.negate();
				return res;
			}
			return num_sub(b, a);
		}
		if (b.is_nega())
			return num_sub(a, b);
		return num_add(a, b);
	}
	friend BigDecimal operator-(const BigDecimal &a, const BigDecimal &b) {
		if (a.is_zero())
			return - b;
		if (b.is_zero())
			return a;
		if (a.is_nega()) {
			BigDecimal res = (b.is_nega()? num_sub(a, b) : num_add(a, b));
			res.negate();
			return res;
		}
		if (b.is_nega())
			return num_add(a, b);
		return num_sub(a, b);
	}
	friend BigDecimal operator*(const BigDecimal &a, const BigDecimal &b) {
		if (a.size() == 0 || b.size() == 0)
			return BigDecimal();
		BigDecimal res(0);
		res._size = std::max(0, a.size() + b.size() - a.DLEN) + 1;
		res._digits = new int[res._size];
		i64 current = 0, carry = 0;
		for (int tot = - a.DLEN; tot < res._size; tot ++) {
			for (int i = std::max(tot + a.DLEN - b.size() + 1, 0); i < a.size() && i <= tot + a.DLEN; i ++) {
				current += (i64)a._digits[i] * b._digits[tot + a.DLEN - i];
				if (current >> 60) {
					carry += current >> MAX_BITS;
					current &= MAX_MASK;
				}
			}
			carry += current >> MAX_BITS;
			current &= MAX_MASK;
			if (tot >= 0)
				res._digits[tot] = current;
			current = carry;
			carry = 0;
		}
		if (a.is_nega() ^ b.is_nega())
			res.negate();
		res.normalize();
		return res;
	}
	void div2() {
		int carry = 0;
		for (int i = size() - 1; i >= 0; i --) {
			carry = (carry << MAX_BITS) ^ _digits[i];
			_digits[i] = carry >> 1;
			carry &= 1;
		}
		normalize();
	}
	friend BigDecimal operator/(const BigDecimal &a, const BigDecimal &b) {
		if (a.is_zero())
			return BigDecimal();
		BigDecimal ta = a, tb = b, res(0);
		int len = ta.size() - tb.size() + a.DLEN + 1;
		if (len <= 0)
			return res;
		res._size = len;
		res._digits = new int[len];

		ta._size = abs(ta._size);
		tb._size = abs(tb._size);
		tb.align(ta.size() + 1);
		for (int i = len - 1; i >= 0; i --) {
			int num = 0;
			for (int j = 0; j < MAX_BITS; j ++) {
				tb.div2(); num <<= 1;
				if (ta >= tb) {
					ta = num_sub(ta, tb);
					num ^= 1;
				}
			}
			res._digits[i] = num;
		}
		if (a.is_nega() ^ b.is_nega())
			res.negate();
		res.normalize();
		return res;
	}

	BigDecimal integer() const {
		BigDecimal res = *this;
		for (int i = 0; i < DLEN && i < size(); i ++)
			res._digits[i] = 0;
		res.normalize();
		return res;
	}

	BigDecimal decimal() const {
		if (is_zero())
			return BigDecimal();
		int nlen = std::min(DLEN, size());
		BigDecimal res(0);
		res._size = nlen;
		res._digits = new int[nlen];
		memcpy(res._digits, _digits, sizeof(int) * nlen);
		if (is_nega())
			res.negate();
		return res;
	}

	friend BigDecimal abs(BigDecimal x) {
		x._size = std::abs(x._size);
		return x;
	}
};
const BigDecimal _ln2("0.693147180559945309417232121458176568075500134360255254120680");
const BigDecimal _pi("3.141592653589793238462643383279502884197169399375105820974944");
const BigDecimal _sqrt2("1.414213562373095048801688724209698078569671875376948073176680");
const BigDecimal _one("1");
const BigDecimal _pi_2 = _pi * 2;
const BigDecimal _pi_half = _pi / 2;
const BigDecimal _eps = BigDecimal::epsilon();

BigDecimal exp(BigDecimal x) {
	BigDecimal ans = 1, cnt = 1;
	for (int i = 1; ; i ++) {
		cnt = cnt * x / i;
		if (cnt.is_zero())
			break;
		ans = ans + cnt;
	}
	return ans;
}

BigDecimal sqrt(BigDecimal x) {
	BigDecimal cur = x, las = 0;
	do {
		las.swap(cur);
		cur = (las + x / las) / 2;
	} while (abs(cur - las) > _eps);
	return cur;
}

BigDecimal ln(BigDecimal x) {
	if (x < _one)
		return -ln(_one / x);
	BigDecimal coef = 0;
	int num = x.int_size();
	if (num > 1)
		x >>= num - 1, coef = _ln2 * ((long long)(num - 1) * x.MAX_BITS);
	while (x > _sqrt2)
		x.div2(), coef = coef + _ln2;
	x = (x - _one) / (x + _one);

	BigDecimal cnt = x * 2, res = cnt;
	x = x * x;
	for (int i = 3; ; i += 2) {
		cnt = cnt * x;
		BigDecimal p = cnt / i;
		if (p.is_zero())
			break;
		res = res + p;
	}
	return res + coef;
}

BigDecimal pow(BigDecimal a, BigDecimal x) {
	return exp(ln(a) * x);
}

BigDecimal sin(BigDecimal x) {
	if (x.is_nega())
		return -sin(-x);
	if (x >= _pi_2)
		x = x - (x / _pi_2).integer() * _pi_2;
	BigDecimal res = x, cur = x;
	x = x * x;
	for (long long i = 3; ; i += 2) {
		cur = cur * x / (i * (i - 1));
		if (cur.is_zero())
			break;
		cur.negate();
		res = res + cur;
	}
	return res;
}

BigDecimal cos(BigDecimal x) {
	if (x.is_nega())
		return cos(-x);
	if (x >= _pi_2)
		x = x - (x / _pi_2).integer() * _pi_2;
	BigDecimal res = 1, cur = 1;
	x = x * x;
	for (long long i = 2; ; i += 2) {
		cur = cur * x / BigDecimal(i * (i - 1));
		cur.negate();
		if (cur.is_zero())
			break;
		res = res + cur;
	}
	return res;
}

BigDecimal tan(BigDecimal x) {
	return sin(x) / cos(x);
}

BigDecimal atan(BigDecimal x) {
	static BigDecimal comp("0.1");
	if (x.is_nega())
		return - atan(-x);
	if (x > _one)
		return _pi_half - atan(_one / x);
	if (x >= comp)
		return atan((sqrt(_one + x * x) - _one) / x) * 2;
	BigDecimal cnt = x, res = x;
	x = x * x; x.negate();
	for (int i = 3; ; i += 2) {
		cnt = cnt * x;
		BigDecimal p = cnt / i;
		if (p.is_zero())
			break;
		res = res + p;
	}
	return res;
}

BigDecimal asin(BigDecimal x) {
	return atan(x / sqrt(_one - x * x));
}

BigDecimal acos(BigDecimal x) {
	return _pi_half - asin(x);
}

BigDecimal atan2(BigDecimal y, BigDecimal x) {
	if (x.is_posi())
		return atan(y / x);
	if (x.is_zero()) {
		if (y.is_nega())
			return - _pi_half;
		return _pi_half;
	}
	if (y.is_nega())
		return atan(y / x) - _pi;
	return atan(y / x) + _pi;
}
}

using namespace big;

#define int long long
#define db BigDecimal
#define pc putchar

struct vc {
	
	db x, y;
	
	vc () { }
	vc (db _x, db _y) : x(_x), y(_y) { }
	
};

const int N = 105;
const db Pi = acos(db(-1));
db Eps = 1;

int n, m, _x, _y, r, t;
db L[N], R[N], sum;
vector<int> tp;

db the(vc p) {
	db res = atan(p.y / p.x);
	if (p.x < 0 && p.y >= 0) {
		res = res + Pi;
	}
	if (p.x < 0 && p.y < 0) {
		res = res + Pi;
	}
	if (p.x >= 0 && p.y < 0) {
		res = res + 2 * Pi;
	}
	return res;
}

db qry(db tm) {
	if (L[*tp.begin()] > tm) {
		return 0;
	}
	db cr = L[*tp.begin()], res = 0;
	for (int i : tp) {
		db l = L[i], r = R[i];
		if (r < cr) {
			continue;
		}
		if (l > tm) {
			return res;
		}
		if (l <= cr) {
			res = res + r - cr, cr = r;
		} else {
			res = res + r - l, cr = r;
		}
		if (cr > tm) {
			res = res - cr + tm;
			return res;
		}
	}
	return res;
}

const double PI = acos(-1);

void solve() {
	cin >> n >> _x >> _y >> r >> t;
	int T = 15;
	while (T--) {
		Eps = Eps / (db)10;
	}
	db mx = -2 * Pi, mn = 4 * Pi, mnn = 4 * Pi, mxx = -2 * Pi;
	vector<pi> pt;
	F (i, 1, n) {
		int x, y;
		cin >> x >> y;
		pt.eb(x, y);
	}
	for (pi _ : pt) {
		int x = _.fi, y = _.se;
		db dis = x * x + y * y; dis = sqrt(dis);
		vc u = vc(x / dis, y / dis);
		db ang = asin(r / dis);
		vc p = vc(u.x * cos(ang) - u.y * sin(ang), u.x * sin(ang) + u.y * cos(ang));
		vc q = vc(u.x * cos(-ang) - u.y * sin(-ang), u.x * sin(-ang) + u.y * cos(-ang));
		db L = the(p), R = the(q);
		if (abs(L - 2 * Pi) <= Eps) {
			L = 0;
		}
		if (abs(R - 2 * Pi) <= Eps) {
			R = 0;
		}
		swap(L, R);
		if (L <= R) {
			mn = min(mn, L);
			mx = max(mx, R);
		} else {
			mxx = max(mxx, R);
			mnn = min(mnn, L);
		}
	}
	if (mn <= mx) {
		m++;
		L[m] = mn, R[m] = mx;
	}
	if (mxx >= 0) {
		m++;
		L[m] = 0, R[m] = mxx;
	}
	if (mnn <= 2 * Pi) {
		m++;
		L[m] = mnn, R[m] = 2 * Pi;
	}
	F (i, 1, m) {
		tp.eb(i);
	}
	sort(tp.begin(), tp.end(), [](int &x, int &y) {
		return L[x] < L[y];
	});
	db _t = the(vc(_x, _y));
	db __t = t + _t;
	int len = floor(t / (2 * PI));
	if (__t - len * 2 * Pi > 2 * Pi) {
		len++;
	}
	(qry(2 * Pi) * len + qry(__t - len * 2 * Pi) - qry(_t)).print(10);
}

bool Med;
signed main() {
	// FIO("");
	// ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cerr << (&Mbe - &Med) / 1048576.0 << " MB\n";
	int T = 1;
	// cin >> T;
	while (T--) solve();
	cerr << (int)(1e3 * clock() / CLOCKS_PER_SEC) << " ms\n";
	return 0;
}