Nature photographing may be fun for tourists, but it is one of the most complicated things for photographers. To capture all the facets of a bird, you might need more than one cameras. You recently encountered such a situation.
There are $n$ photographers, so there are $n$ cameras in a line on the x-axis. All the cameras are at distinct coordinates. 
You want to pair up these cameras ($n$ is even) in such a way that the sum of angles subtended on the bird by the pair of cameras is maximized. Formally, let A, B be two cameras, and let P be the bird to be captured by these two cameras. The angle will APB. 
Note: All angles are in radians.

-----Input-----
- The first line of the input contains an integer $T$ denoting the number of test cases. The description of the test cases follows.
- The first line of each test case contains an integer $n$.
- The second line of each test case contains $n$ space-separated integers denoting the $x_i$ coordinates of the cameras.
- The third line of each test case contains two space-separated integers $P, Q$ denoting the x and y coordinates of the bird respectively.

-----Output-----
For each test case, output your answer in a single line. Your answer would be considered correct if its absolute error is less than or equal to 1e-6 of the actual answer. 

-----Constraints-----
- $1 \le T \le 10$
- $2 \le n \leq  100$
- $1 \le x_i \leq 300$
- $0 \le P \leq 300$
- $1 \le Q \leq 300$

-----Example Input-----
2
2
0 1
0 1
2
0 1
100 1

-----Example Output-----
0.785398163397
0.000100999899

-----Explanation-----
Note: $1 \leq x_i$ is not being satisfied by the sample input, but will be satisfied in the actual test data.
Testcase 1: There are only 2 cameras, so they have to paired up with each other. And the angle subtended by then is 45 degrees. Converting this to radians gives the output.

Difficulty: interview

Starter code:

Solutions:
from math import *
from collections import *
import sys
input=sys.stdin.readline
t=int(input())
while(t):
    t-=1
    n=int(input())
    a=list(map(int,input().split()))
    p,q=map(int,input().split())
    s=0
    a.sort()
    for i in range(n//2):
        x=a[i]
        x1=a[n-i-1]
        if(x==p or x1==p):
            s1=abs(x-x1)
            s2=q
            s+=abs(atan2(s1,s2))
        elif(x<p and x1>p):
            s1=abs(p-x)
            ex=atan2(s1,q)
            s1=abs(p-x1)
            ex1=atan2(s1,q)
            ex+=ex1
            s+=abs(ex)
        else:
            if(p<x):
                s1=abs(p-x)
                ex=atan2(s1,q)
                s1=abs(p-x1)
                ex1=atan2(s1,q)
                ex=ex1-ex
                s+=abs(ex)
            else:
                s1=abs(p-x)
                ex=atan2(s1,q)
                s1=abs(p-x1)
                ex1=atan2(s1,q)
                ex=ex-ex1
                s+=abs(ex)    
    print(s)


from math import *
from collections import *
import sys
input=sys.stdin.readline
t=int(input())
while(t):
    t-=1
    n=int(input())
    a=list(map(int,input().split()))
    p,q=map(int,input().split())
    s=0
    a.sort()
    for i in range(n//2):
        x=a[i]
        x1=a[n-i-1]
        if(x==p or x1==p):
            s1=abs(x-x1)
            s2=q
            s+=abs(atan2(s1,s2))
        elif(x<p and x1>p):
            s1=abs(p-x)
            ex=atan2(s1,q)
            s1=abs(p-x1)
            ex1=atan2(s1,q)
            ex+=ex1
            s+=abs(ex)
        else:
            if(p<x):
                s1=abs(p-x)
                ex=atan2(s1,q)
                s1=abs(p-x1)
                ex1=atan2(s1,q)
                ex=ex1-ex
                s+=abs(ex)
            else:
                s1=abs(p-x)
                ex=atan2(s1,q)
                s1=abs(p-x1)
                ex1=atan2(s1,q)
                ex=ex-ex1
                s+=abs(ex)    
    print(s)


# f = open("file.txt", 'r+')
# inp = f.readline
inp = input
import math


for _ in range( int(input()) ):
    
    n = int(input())
    arr = list(map(int , input().split()))
    p,q = map(int , input().split())
    
    ans = 0
    arr.sort()
    
    for i in range(n//2):
        
    
        mn , mx = arr[i] , arr[n-i-1]
    
        if(mx == p) or (mn == p):
    #         print("Case 1")
            adj = q
            opp = mx-mn
            val = math.atan2(opp, adj)
        elif(mn < p) and (mx > p):
    #         print("Case 2")
            adj = q
            opp = p - mn
            valA = math.atan2(opp, adj)
    
            opp = mx - p
            valB = math.atan2(opp, adj)
    
            val = valA + valB
        else:
    #         print("Case 3")
            if(p < mn):    
                adj = abs(mx - p)
                opp = q
                valA = math.atan2(opp, adj)
                
                adj = abs(mn - p)
                valB = math.atan2(opp, adj)
                
                val = valA - valB
            else:
                adj = abs(p - mn)
                opp = q
                valA = math.atan2(opp, adj)
                
                adj = abs(p-mx)
                valB = math.atan2(opp, adj)
                
                val = valA - valB
        val = abs(val)
        
        ans += val
#     val = print('%.2f'%val)
    print('%.12f'%ans)
    

import math
def ar(a,b,c):
    s=(a+b+c)/2
    return math.sqrt((s*(s-a)*(s-b)*(s-c)))
def dist(x1,y1,x2,y2):
	return math.sqrt((y2-y1)**2 + (x2-x1)**2)
def return_angle(a,b,c):
	return math.acos((a**2+b**2-c**2)/(2*a*b))
from math import asin
t=int(input())
for _ in range(t):
    n=int(input())
    it=list(map(int,input().split()))
    x,y=map(int,input().split())
    it.sort()
    tot=0
    vis=[0]*n
    pp=[]
    for i in range(n):
        for j in range(i+1,n):
            a=it[i]
            b=it[j]
            d=abs(a-b)
            d1=dist(a,0,x,y)
            d2=dist(b,0,x,y)
            ans=return_angle(d1,d2,d)
          #  r=(d1*d2*d)/(4*ar(d1,d2,d))
         #   ans=asin(d/(2*r))
            ans=abs(ans)
            pp.append([ans,i,j])
    pp.sort(reverse=True)
    for i in pp:
        if vis[i[1]] or vis[i[2]]:
            continue
        tot+=i[0]
        vis[i[2]]=1
        vis[i[1]]=1
    print(tot)


import math

def calLen(cam1, cam2, bird):
    a = math.sqrt((cam1[0]-bird[0])**2 + (cam1[1]-bird[1])**2)
    b = math.sqrt((cam2[0]-bird[0])**2 + (cam2[1]-bird[1])**2)
    c = math.sqrt((cam1[0]-cam2[0])**2 + (cam1[1]-cam2[1])**2)

    return a,b,c

for h in range(int(input())):
    n = int(input())
    cams = list(map(lambda x: [int(x), 0], input().strip().split()))
    bird = list(map(int, input().strip().split()))
    cams.sort(key = lambda x:x[0])

    ans = 0
    for i in range(n//2):
        cam1 = cams[i]
        cam2 = cams[n-1-i]

        a, b, c = calLen(cam1, cam2, bird)
        ans += math.acos((a**2 + b**2 - c**2)/(2*a*b))
    print(ans)

import math

def calLen(cam1, cam2, bird):
    a = math.sqrt((cam1[0]-bird[0])**2 + (cam1[1]-bird[1])**2)
    b = math.sqrt((cam2[0]-bird[0])**2 + (cam2[1]-bird[1])**2)
    c = math.sqrt((cam1[0]-cam2[0])**2 + (cam1[1]-cam2[1])**2)

    return a,b,c

def calculateAngle(a,b,c):
    return math.acos((a**2 + b**2 - c**2)/(2*a*b))

# def best_angle()

# def brute(n,cams,bird):
    # angles = []
    # for i in range(n):
    #     temp = [0]*n
    #     angles.append(temp)
    #     for j in range(i+1,n):
    #         a,b,c = calLen(cams[i],cams[j],bird)
    #         angles[i][j] = (calculateAngle(a,b,c))
    # print(angles)        
    # ans = 0
    # for i in range(n):
        
    #     while 

def angle2(cam1, cam2, bird):
    a, b, c = calLen(cam1, cam2, bird)
    return math.acos((a**2 + b**2 - c**2)/(2*a*b))

def backtrack(s, vertices, order):
    global res

    flag9 = 0
    for a in range(0, len(vertices)):
        if vertices[a] != 0:
            flag9 = 1
            break
    if flag9==0:
        # if s > res:

        # print(order)
        res = max(s, res)
        return
    for a in range(0, len(vertices)):
        for b in range(0, len(vertices)):
            if vertices[a] and vertices[b]:
                n1 = vertices[a]
                n2 = vertices[b]
                vertices[a] = 0
                vertices[b] = 0
                backtrack(s + angle2(n1, n2, bird), vertices,order + [vertices[a],vertices[b]] )
                vertices[a] = n1
                vertices[b] = n2

from random import randint

for h in range(int(input())):
    n = int(input())
    cams = list(map(lambda x: (int(x), 0), input().strip().split())) 
    # cams = [(randint(1,33),0) for a in range(0, n)]
    cams1 = [i for i in cams]
    # print(cams,cams1)
    bird = list(map(int, input().strip().split()))
    # bird = [randint(0,33),randint(1,33)]

    # brute(n,cams,bird)

    ans = 0
    i = 0
    i2 = [0,0]
    i4 = [0,0]

    while set(cams1) != {0}:

        # print(set(cams1) )
        i = 0
        # i2 = [0,0]
        for a in range(0, len(cams1)):
            for b in range(a+1, len(cams1)):
                if cams1[a] and cams1[b]:
                    if abs( cams1[a][0] - cams1[b][0]) >= i:
                        i = abs( cams1[a][0] - cams1[b][0])
                        i2 = [cams1[a], cams1[b ]]
                        i4=[a, b]
                        # print(i2)
        ans += angle2(i2[0],i2[1], bird)
        cams1[i4[0]] = 0
        cams1[i4[1 ]] = 0
    print(ans)

    res = 0
    # backtrack(0,cams,[])
    # print(res)




import math
for _ in range(int(input())):
    n = int(input())
    ar = list(map(int, input().split()))
    ar.sort()
    ans = 0
    p, q = map(int, input().split())
    for i in range(n//2):
        a = ar[i]
        b = ar[-(i+1)]
        t1 = math.atan((p-a)/q)
        t2 = math.atan((b-p)/q)
        ans += (t1+t2)
    print(ans)

import math
for _ in range(int(input())):
    n = int(input())
    ar = list(map(int, input().split()))
    ar.sort()
    ans = 0
    p, q = map(int, input().split())
    for i in range(n//2):
        a = ar[i]
        b = ar[-(i+1)]
        t1 = math.atan((p-a)/q)
        t2 = math.atan((b-p)/q)
        ans += (t1+t2)
    print(ans)


t=int(input())
import math
for i in range(t):
    n=int(input())
    l=list(map(int,input().split()))
    l.sort()
    p,q=map(int,input().split())
    i=0
    j=-1
    c=0
    while True:
        if l[i]>l[j]:
            break
        a=math.sqrt((p-l[i])**2+q**2)
        b=abs(l[i]-l[j])
        d=math.sqrt((p-l[j])**2+q**2)
        e=a**2+d**2-b**2
        e/=2*a*d
        e=math.acos(e)
        round(e,6)
        c+=e
        
        i+=1
        j-=1
    round(c,6)
    print(c)
        
    


from math import *
t = int(input())
for _ in range(t):
    n = int(input())
    l = list(map(int,input().split()))
    l.sort()
    x,y = map(int,input().split())
    ans = 0
    for i in range(n//2):
        a = l[i]
        b = l[i+n//2]
        theta1 = (b-x)/y
        theta2 = (a-x)/y
        theta1 = atan(theta1)
        theta2 = atan(theta2)
        ans += (theta1-theta2)
    print(abs(ans))  
            


from math import *
t = int(input())
for _ in range(t):
    n = int(input())
    l = list(map(int,input().split()))
    l.sort()
    x,y = map(int,input().split())
    ans = 0
    for i in range(n//2):
        a = l[i]
        b = l[n-i-1]
        theta1 = (b-x)/y
        theta2 = (a-x)/y
        theta1 = atan(theta1)
        theta2 = atan(theta2)
        ans += (theta1-theta2)
    print(abs(ans))  
            


from math import atan
t = int(input())
def f(a,b,x,y):
    m = (b-x)/y
    n = (a-x)/y
    return atan(m)-atan(n);
for i in range(t):
    n = int(input())
    a = list(map(int,input().split()))
    a.sort()
    p,q = map(int,input().split())
    k = n//2
    s = 0
    for j in range(k):
        s = s+f(a[j],a[n-1-j],p,q)
    if s<0:
        s = -s
    print(s)


from math import *


for t in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	l = list(map(int, input().split()))
	arr.sort()
	x = l[0]
	y = l[1]
	ans = 0
	for i in range(int(n/2)):
		x1 = arr[i]
		x2 = arr[n-i-1]
		if x1 < x and x2 <= x:
			angle = atan((x-x1)/y) - atan((x-x2)/y)
		elif x1 < x and x2 > x:
			angle = atan((x-x1)/y) + atan((x2-x)/y)
		else:
			angle = atan((x2-x)/y) - atan((x1-x)/y)
		ans += angle
	print(ans)


from math import atan
def f(a,b,x,y):
    m=(a-x)/y
    n=(b-x)/y
    return atan(m)-atan(n)
for i in range(int(input())):
    c=int(input())
    b=list(map(int,input().split()))
    b.sort()
    x,y=map(int,input().split())
    s=0
    k=c//2
    for i in range(k):
        s += f(b[i],b[c-1-i],x,y)
    if s < 0:
        s = -s
    print(s)

import math
T=int(input())
for i in range(T):
  n=int(input())
  A=[int(k) for k in input().split()]
  A.sort()
  P,Q=[int(j) for j in input().split()]
  def angle(x1,x2,x,y):
    y=math.atan((x2-x)/y) + math.atan((x-x1)/y)
    return y
  c=0
  for i in range(n//2):
    c=c+angle(A[i],A[n-i-1],P,Q)

  print(c) 




import math
for _ in range(int(input())):
    n=int(input())
    arr=list(map(int,input().split()))
    p,q=map(int,input().split())
    k=[]
    for i in range(n):
        if p==arr[i]:
            k.append(0)
        else:
            k.append(math.atan((p-arr[i])/q))
    k=sorted(k)        
    print(round(abs(sum(k[:n//2])-sum(k[n//2:])),12))


import math
for i in range(int(input())):
	n=int(input())
	tmp=input().split()
	arr=[]
	for j in tmp:
		arr.append(int(j))
	tmp=input().split()
	x=int(tmp[0])
	y=int(tmp[1])
	s=0
	arr.sort()
	for j in range(int(n/2)):
		d1=(arr[j]-x)**2+y**2
		d2=(arr[n-j-1]-x)**2+y**2
		d3=(arr[n-1-j]-arr[j])**2
		s+=math.acos((d1+d2-d3)/(2*math.sqrt(d1)*math.sqrt(d2)))
	print('{0:0.12}'.format(s))

import math
for _ in range(int(input())):
    n = int(input())
    cameras = list(map(int,input().split()))
    p,q = map(int,input().split())
    cameras.sort()
    sumA = 0
    # radians  c**2 = a**2 + b**2 -2ac(Cos(degree))
    for i in range(n//2):
        p1 = cameras[i]
        p2 = cameras[n-1-i]
        p12 = p2-p1
        # print(p1,p2)
        sideA = math.sqrt((p-p1)**2 + q**2)
        sideB = math.sqrt((p-p2)**2 + q**2)
        # print('sideA:',sideA,'sideB:',sideB)
        radians = math.acos(((p12**2)-sideA**2 - sideB**2 )/(-2*sideA*sideB))
        sumA +=radians

    print(sumA)

from math import *

t=int(input())
for i in range(t):
	n=int(input())
	x=[float(y) for y in input().split()]
	x.sort()
	p,q=input().split()
	p=float(p)
	q=float(q)
	ma=0.0
	for ind in range(n//2):
		i=x[ind]
		j=x[n-ind-1]	
		t1=t2=pi/2
		if (i!=p):
			t1=atan(q/abs(i-p))
		if (i>p):
			t1=pi-t1
		if (j!=p):
			t2=atan(q/abs(j-p))
		if (j<p):
			t2=pi-t2
		ma+=(pi-t1-t2)
	print(ma)


import math
for _ in range(int(input())):
	n = int(input())
	xs = list(map(int,input().split()))
	p,q = map(int,input().split())
	angles = sorted(math.atan((x-p)/q) for x in xs)
	print(sum(angles[n//2:])-sum(angles[:n//2]))



import math
t=int(input())
for _ in range(t):
    n=int(input())
    a=list(map(int,input().split()))
    p,q=list(map(int,input().split()))
    a=sorted(a)
    b=[0]*len(a)
    s=0
    for i in range(len(a)):
        b[i]=a[i]-p
    for i in range(len(a)//2):
        s=s-math.atan(b[i]/q)+math.atan(b[n-1-i]/q)
    print(s)

from math import atan
t = int(input())
def f(a,b,x,y):
    m = (b-x)/y
    n = (a-x)/y
    return atan(m)-atan(n);
for i in range(t):
    n = int(input())
    a = list(map(int,input().split()))
    a.sort()
    p,q = map(int,input().split())
    k = n//2
    s = 0
    for j in range(k):
        s = s+f(a[j],a[n-1-j],p,q)
    if s<0:
        s = -s
    print(s)


import math

def angle(x1, B, x2):
    xb, yb = B
    a = math.sqrt((xb-x1)**2+yb**2)
    b = math.sqrt((xb-x2)**2+yb**2)
    c = abs(x2-x1)
    return math.acos((a**2+b**2-c**2)/(2*a*b))


for _ in range(int(input())):
    n = int(input())
    X = [int(x) for x in input().split()]
    B = [int(x) for x in input().split()]
    X.sort()
    l, r = 0, len(X)-1
    ang = 0
    while l<r:
        ang += angle(X[l], B, X[r])
        l += 1
        r -= 1
    print(ang)

from math import acos,sqrt
t=int(input())


def distance(x,y,p,q):
    a=abs(x-y)
    b=sqrt((p-x)**2+q**2)
    c=sqrt((p-y)**2+q**2)
    angle = acos((c ** 2 + b ** 2 - a ** 2) / (2 * b * c))
    return angle


def main():
    for _ in range(t):
        n=int(input())
        c=[int(x) for x in input().split()]
        p,q=map(int,input().split())
        c.sort()
        l=0
        h=n-1
        sum1=0
        while l<h:
            angle=distance(c[l],c[h],p,q)
            sum1+=angle
            l+=1
            h-=1
        print(sum1)


def __starting_point():
    main()
__starting_point()