You are working for the Gryzzl company, headquartered in Pawnee, Indiana.

The new national park has been opened near Pawnee recently and you are to implement a geolocation system, so people won't get lost. The concept you developed is innovative and minimalistic. There will be $n$ antennas located somewhere in the park. When someone would like to know their current location, their Gryzzl hologram phone will communicate with antennas and obtain distances from a user's current location to all antennas.

Knowing those distances and antennas locations it should be easy to recover a user's location... Right? Well, almost. The only issue is that there is no way to distinguish antennas, so you don't know, which distance corresponds to each antenna. Your task is to find a user's location given as little as all antennas location and an unordered multiset of distances.


-----Input-----

The first line of input contains a single integer $n$ ($2 \leq n \leq 10^5$) which is the number of antennas.

The following $n$ lines contain coordinates of antennas, $i$-th line contain two integers $x_i$ and $y_i$ ($0 \leq x_i,y_i \leq 10^8$). It is guaranteed that no two antennas coincide.

The next line of input contains integer $m$ ($1 \leq n \cdot m \leq 10^5$), which is the number of queries to determine the location of the user.

Following $m$ lines contain $n$ integers $0 \leq d_1 \leq d_2 \leq \dots \leq d_n \leq 2 \cdot 10^{16}$ each. These integers form a multiset of squared distances from unknown user's location $(x;y)$ to antennas.

For all test cases except the examples it is guaranteed that all user's locations $(x;y)$ were chosen uniformly at random, independently from each other among all possible integer locations having $0 \leq x, y \leq 10^8$.


-----Output-----

For each query output $k$, the number of possible a user's locations matching the given input and then output the list of these locations in lexicographic order.

It is guaranteed that the sum of all $k$ over all points does not exceed $10^6$.


-----Examples-----
Input
3
0 0
0 1
1 0
1
1 1 2

Output
1 1 1 

Input
4
0 0
0 1
1 0
1 1
2
0 1 1 2
2 5 5 8

Output
4 0 0 0 1 1 0 1 1 
4 -1 -1 -1 2 2 -1 2 2 



-----Note-----

As you see in the second example, although initially a user's location is picked to have non-negative coordinates, you have to output all possible integer locations.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import sys\nimport math\n\nn = int(input())\n\nx = [0]*n\ny = [0]*n\n\nfor i in range(n):\n    x[i], y[i] = list(map(int, input().split()))\n\nsx = sum(x)\nsy = sum(y)\n    \nfor i in range(n):\n    x[i] = n * x[i] - sx\n    y[i] = n * y[i] - sy\n\nm = int(input())\n\nd = [0]*n\ne = [0]*n\n\nHD = 0\n\ndef check(a, b):\n    nonlocal HD\n    HE = 0\n    for i in range(n):\n        HE ^= hash((a-x[i])*(a-x[i])+(b-y[i])*(b-y[i]))\n    return HD == HE\n\ndef sqrt(x):\n    nn = int(x)\n    if nn == 0:\n        return 0\n    fa, fb = divmod(nn.bit_length(), 2)\n    x = 2**(fa+fb)\n    while True:\n        y = (x + nn//x)//2\n        if y >= x:\n            return x\n        x = y\n\ndef hash(x):\n    return x * 9991 + 43\n\npans = []\n\ndef solve():\n    nonlocal d\n    d = list(map(int, input().split()))\n    c = 0\n    d = [p * n * n for p in d]\n    for i in range(n):\n        c += d[i] - x[i] * x[i] - y[i] * y[i]\n\n    assert(c % n == 0)\n    c //= n\n    ans = []\n    ax = x[0]\n    ay = y[0]\n    if ax is 0 and ay is 0:\n        ax = x[1]\n        ay = y[1]\n    rev = 0\n    if ay == 0:\n        ay = ax\n        ax = 0\n        rev = 1\n    d.sort()\n    nonlocal HD\n    HD = 0\n    for p in d:\n        HD ^= hash(p)\n    old = -1\n    for p in d:\n        if (p == old):\n            continue\n        old = p\n        a = c + ax * ax + ay * ay - p\n        if (a % 2 != 0):\n            continue\n        a //= 2\n        A = ax * ax + ay * ay\n        B = a * ax\n        C = a * a - ay * ay * c\n        D = B * B - A * C\n        if (D < 0):\n            continue\n        sD = sqrt(D)\n        if D != sD * sD:\n            continue\n        if (B + sD) % A == 0:\n            qx = (B + sD) // A\n            qy = (a - ax * qx) // ay\n            if rev:\n                t = qx\n                qx = qy\n                qy = t\n            if ((qx + sx) % n == 0 and (qy + sy) % n == 0 and check(qx, qy)):\n                qx = (qx + sx) // n\n                qy = (qy + sy) // n\n                ans.append([qx, qy])\n        if sD == 0:\n            continue\n        if (B - sD) % A == 0:\n            qx = (B - sD) // A\n            qy = (a - ax * qx) // ay\n            if rev:\n                t = qx\n                qx = qy\n                qy = t\n            if ((qx + sx) % n == 0 and (qy + sy) % n == 0 and check(qx, qy)):\n                qx = (qx + sx) // n\n                qy = (qy + sy) // n\n                ans.append([qx, qy])\n                \n    ans.sort()\n    buf=[]\n    buf.append(len(ans))\n    for p in ans:\n            buf.append(p[0])\n            buf.append(p[1])\n    nonlocal pans\n    pans.append(" ".join(map(str,buf)))\n\nwhile m > 0:\n    m -= 1\n    solve()\n    \nsys.stdout.write("\\n".join(pans))\n       \n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: