Problem: The statement of this problem is the same as the statement of problem C2. The only difference is that, in problem C1, n is always even, and in C2, n is always odd.

You are given a regular polygon with 2 ⋅ n vertices (it's convex and has equal sides and equal angles) and all its sides have length 1. Let's name it as 2n-gon.

Your task is to find the square of the minimum size such that you can embed 2n-gon in the square. Embedding 2n-gon in the square means that you need to place 2n-gon in the square in such way that each point which lies inside or on a border of 2n-gon should also lie inside or on a border of the square.

You can rotate 2n-gon and/or the square.

Input

The first line contains a single integer T (1 ≤ T ≤ 200) — the number of test cases.

Next T lines contain descriptions of test cases — one per line. Each line contains single even integer n (2 ≤ n ≤ 200). Don't forget you need to embed 2n-gon, not an n-gon.

Output

Print T real numbers — one per test case. For each test case, print the minimum length of a side of the square 2n-gon can be embedded in. Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.

Example

Input


3
2
4
200


Output


1.000000000
2.414213562
127.321336469

Solution (in JAVA):

Solution:
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
    	Scanner sc=new Scanner(System.in); 
		Writer w=new PrintWriter(System.out);
		int t=sc.nextInt();
		while(t-->0){
		    int n=sc.nextInt();
		  //  double b = Math.toRadians(90/n);
		  //  double ans=1/Math.sin(b);
		  //  double ang = ((90/n) * 3.14159) / 180; 
		  //  double ans=1/StrictMath.sin(ang);
		    double ans=nGon(2*n);
		    System.out.println(ans);
		}
		w.flush();
		w.close();
	}
	
static double pi = Math.acos(-1.0); 
  
// Function to find the minimum 
// side of the square in which 
// a regular polygon with even sides 
// can completely embed 
static double nGon(int N) 
{ 
  
    // Projection angle variation 
    // from axes 
    double proAngleVar; 
  
    // Projection angle variation 
    // when the number of 
    // sides are in multiple of 4 
    if (N % 4 == 0)  
    { 
        proAngleVar = pi * (180.0 / N) / 180; 
    } 
    else 
    { 
        proAngleVar = pi * (180.0 / (2 * N)) / 180; 
    } 
  
    // Distance between the end points 
    double negX = 1.0e+99, 
           posX = -1.0e+99, 
           negY = 1.0e+99, 
           posY = -1.0e+99; 
  
    for (int j = 0; j < N; ++j)  
    { 
  
        // Projection from all N points 
        // on X-axis 
        double px = Math.cos(2 * pi * j / N + 
                                proAngleVar); 
  
        // Projection from all N points 
        // on Y-axis 
        double py = Math.sin(2 * pi * j / N +  
                                proAngleVar); 
  
        negX = Math.min(negX, px); 
        posX = Math.max(posX, px); 
        negY = Math.min(negY, py); 
        posY = Math.max(posY, py); 
    } 
  
    // Maximum side 
    double opt2 = Math.max(posX - negX, 
                           posY - negY); 
  
    // Return the portion of side 
    // forming the square 
    return (double)opt2 /  
            Math.sin(pi / N) / 2; 
} 
  
// Driver code 
}
class Reader 
    { 
        final private int BUFFER_SIZE = 1 << 16; 
        private DataInputStream din; 
        private byte[] buffer; 
        private int bufferPointer, bytesRead; 
  
        public Reader() 
        { 
            din = new DataInputStream(System.in); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
  
        public Reader(String file_name) throws IOException 
        { 
            din = new DataInputStream(new FileInputStream(file_name)); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
  
        public String readLine() throws IOException 
        { 
            byte[] buf = new byte[64]; // line length 
            int cnt = 0, c; 
            while ((c = read()) != -1) 
            { 
                if (c == '\n') 
                    break; 
                buf[cnt++] = (byte) c; 
            } 
            return new String(buf, 0, cnt); 
        } 
  
        public int nextInt() throws IOException 
        { 
            int ret = 0; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
            do
            { 
                ret = ret * 10 + c - '0'; 
            }  while ((c = read()) >= '0' && c <= '9'); 
  
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        public long nextLong() throws IOException 
        { 
            long ret = 0; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
            do { 
                ret = ret * 10 + c - '0'; 
            } 
            while ((c = read()) >= '0' && c <= '9'); 
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        public double nextDouble() throws IOException 
        { 
            double ret = 0, div = 1; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg) 
                c = read(); 
  
            do { 
                ret = ret * 10 + c - '0'; 
            } 
            while ((c = read()) >= '0' && c <= '9'); 
  
            if (c == '.') 
            { 
                while ((c = read()) >= '0' && c <= '9') 
                { 
                    ret += (c - '0') / (div *= 10); 
                } 
            } 
  
            if (neg) 
                return -ret; 
            return ret; 
        } 
  
        private void fillBuffer() throws IOException 
        { 
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
            if (bytesRead == -1) 
                buffer[0] = -1; 
        } 
  
        private byte read() throws IOException 
        { 
            if (bufferPointer == bytesRead) 
                fillBuffer(); 
            return buffer[bufferPointer++]; 
        } 
  
        public void close() throws IOException 
        { 
            if (din == null) 
                return; 
            din.close(); 
        } 
    }