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.io.*;
public class Solution{
  static int llllll=0;
    static long mod=998244353 ;
    static boolean f=true;
    static class pair implements Comparable<pair>{
        int a,b,c;
        pair(int x,int y,int z){
            a=x;b=y;c=z;
        }
        public int compareTo(pair t){
           if(c<t.c)    return 1;
		    else if(c==t.c)
		    {   if(a<t.a)    return -1;
		        else if(a>t.a)   return 1;
		        else    return 0;
		    }
		    else    return -1;
        }
    }
    // public static ArrayList<pair> bfs(String[] a,int r,int c){
    //     ArrayList<pair> ans=new ArrayList<>();
    //     Queue<pair> q=new LinkedList<>();
    //     int[][] dxy={{-1,0,1,0},{0,-1,0,1}};
    //     q.add(new pair(r,c));
    //     HashSet<String> h=new HashSet<>();
    //     while(!q.isEmpty()){
    //         pair f=q.poll();
    //         ans.add(f);h.add(f.a+" "+f.b);
    //         for(int i=0;i<4;i++){
    //             int dx=f.a+dxy[0][i];
    //             int dy=f.b+dxy[1][i];
    //             if(dx<0||dy<0||dx>=a.length||dy>=a.length||h.contains(dx+" "+dy)||
    //             a[dx].charAt(dy)=='1')
    //             continue;
    //             q.add(new pair(dx,dy));
    //             h.add(dx+" "+dy);
    //         }
    //     }
    //     return ans;
    // }    

    /*
    1 1 1 1 1 
3 3 3 
2 3 3 2 1 3 
1 
2 2 2 2 
4 4 4 1 4 
*/
    public static int pow(int a, int n) {
		long ans = 1;
		long base = a;
		while (n != 0) {
			if ((n & 1) == 1) {
				ans *= base;
				ans %= 1000000007;
			}
			base = (base * base) % 1000000007;
			n >>= 1;
		}
		return (int) ans % 1000000007;
	}
	public static int find(int x){
	    int i=1;int f=0;
	    while(x>0){
	        if((x&1)==0)f=i;
	        x>>=1;i++;
	    }
	    return f;
	}
	public static boolean good(int x){
	    
	    if((((x+1)&x))==0)
	    return true;
	    return false;
	}
	public static long f(long n){
	  
	   long val=2;
	   long preval=0;int i=1;
	   while(n>=val){
	       i++;
	       preval=val;
	       val=3*i+val-1;
	       
	   }
	   
	   return preval;
	   
	}
	public static boolean bfs(ArrayList<Integer>[] a,int n,int[] b){
	    Queue<Integer> p=new LinkedList<>();
	    boolean v[]=new boolean[n];
	    v[0]=true;int k=0;
	    if(b[0]!=0)return false;
	    p.add(0);int c=1;
	    HashSet<Integer> h=new HashSet<Integer>();
	    h.add(0);
	    while(!p.isEmpty()){
	        int f=p.poll();k++;
	        if(h.contains(f))h.remove(f);
	        else return false;
	        v[f]=true;
	        c--;
	
	       for(int i:a[f]){
	           if(!v[i]){
	           p.add(i);v[i]=true;}
	       }
	          if(c==0){
	              c=p.size();
	       if(h.size()!=0)return false;
	       for(int j=k;j<k+p.size();j++)
	       h.add(b[j]);
	   }
	    }
	    return true;
	    
	}
	public static int mi(int[] a,int k,int[] dp,int n){
	    int max=0;
	    for(int i=1;i*i<=k;i++){
	      //  System.out.println("fact "+i);
	        if(k%i==0&&(a[i-1]<a[k-1])){
	            
	      //  System.out.println(i+" "+dp[i-1]+" "+a[i-1]+" ");
	        max=Math.max(dp[i-1],max);}
	        if(k%i==0&&(a[k/i-1]<a[k-1])){
	            
	      //  System.out.println(i+" "+dp[i-1]+" "+a[i-1]+" ");
	        max=Math.max(dp[k/i-1],max);}
	        
	    }
	    return max;
	}
	    public static void dfs(ArrayList<Integer> a[],boolean[] v,int n,int llllll){
     v[n]=true;
     llllll=Math.max(n,llllll);
   //   System.out.println(max);
        for(int i=0;i<a[n].size();i++){
            if(!v[a[n].get(i)]){
         dfs(a,v,a[n].get(i),llllll);
            }
           
        }
       
        
    }
    public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
 
			int t = s.nextInt();
	StringBuilder st=new StringBuilder();
		while(t-- > 0) {
		   
		  int n = s.nextInt() * 2;
      st.append((Math.tan(Math.PI * (n - 2) / n / 2))+"\n");
		}
 System.out.println(st);
   
/*

2
1
3
1
6


6 23 21
1 1000 0
2 1 2

0
40
41664916690999888

1 
1 2 
2 1 3 
3 1 2 4 
2 4 1 3 5 
3 4 1 5 2 6 

1 11
5 35
3 6
0 42
0 0
1 2
3 4




6 45 46
2 2 1
3 4 2
4 4 3
*/


  
	
        
    }
}