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 cp {

	static int gcd(int a, int b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
     
    // method to return LCM of two numbers
    static int lcm(int a, int b)
    {
        return (a / gcd(a, b)) * b;
    }
	public static void main(String[] args) {
		FastReader sc = new FastReader();
		int t = sc.nextInt();
		while(t-- != 0) {
			int n = 2 * sc.nextInt();
			System.out.println(Math.cos(Math.PI / n) / Math.sin(Math.PI / n));
		}
	}
	public static boolean check(int[] arr) {
		for(int e : arr)if(e == 0)return false;
		return true;
	}
	static long solve(boolean[] visited, int k, int s, int e, HashMap<Integer, Set<Integer>> mapL, HashMap<Integer, Set<Integer>> mapIl) {
		
		if(visited[s])return -1;
		visited[s] = true;
		if(mapL.containsKey(s) && mapL.get(s).contains(e))return 0;
		if(mapIl.containsKey(s) && mapIl.get(s).contains(e))return k;
		long min = Long.MAX_VALUE;
		if(mapL.containsKey(s)) {
			Set<Integer> set = mapL.get(s);
			for(int d : set) {
				long dis = solve(visited, k, d, e, mapL, mapIl);
				if(dis != -1)return dis;
			}
		}
		if(mapIl.containsKey(s)) {
			Set<Integer> set = mapIl.get(s);
			for(int d : set) {
				long dis = solve(visited, k, d, e, mapL, mapIl);
				if(dis != -1)return dis + k;
			}
		}
		
		return -1;
	}
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }


static class SegmentTree {
	long[] arr;
	int size;
	public SegmentTree(int[] input) { // l and r are the index of array 'input' (zero based indexing)
		arr = new long[(input.length) * 4];
		size = input.length;
		formTree(0, input.length - 1, 1, input);
	}
	public void formTree(int l, int r, int i, int[] input) {
		if(r == l) {
			arr[i] = input[r];
			return;
		}
		int mid = (l + r) / 2;
		formTree(l, mid, 2 * i, input);
		formTree(mid + 1, r, 2 * i + 1, input);
		arr[i] = arr[2 * i] + arr[2 * i + 1]; 
	}
	
	public void print() {
		System.out.print(" ");
		for(long e : arr) {
			
			if(e == 0)System.out.print("_");
			while(e != 0) {
				System.out.print("_");
				e /= 10;
			}
			System.out.print(" ");
			
		}
		System.out.println();
		System.out.print("|");
		for(long e : arr)System.out.print(e + "|");
		System.out.println();
	}
	
	public long get(int l, int r) { // inclusively
		return get(l, r, 0, size - 1, 1);
	}
	public long get(int l, int r, int start, int end, int treeIn) {
//		System.out.println(start + " " + l + " " + r + " " + end +" " + treeIn);
		if(start < 0 || end >= size || (start > r) || end < l)return 0;
		if(start >= l && end <= r) return arr[treeIn];
		int mid = (start + end) / 2;
		return (long)get(l, r, start, mid, 2 * treeIn) + (long)get(l, r, mid + 1, end, 2 * treeIn + 1);
		
	}
	public void update(int i, long val) {
		update( i, 0, size - 1, 1, val);
	}
	
	public long update(int i, int start, int end, int treeIn, long val) {

		if(start < 0 || end >= size)return 0;
		
		if(start == end && end == i) {
			long sum = arr[treeIn];
			arr[treeIn] = val;
			return sum - val;
		}
		int mid = (start + end) / 2;
		
		if(mid >= i) {
			long sum = update(i, start, mid, 2 * treeIn, val);
			arr[treeIn] -= sum;
			return sum;
		}
		if(mid < i) {
			long sum = update(i, mid + 1, end, 2 * treeIn + 1, val);
			arr[treeIn] -= sum;
			return sum;
		}
		return 0;
	}
}
}