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.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
import java.io.BufferedReader;

public class C {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskF solver = new TaskF();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskF {

		private int gcd(int x, int y) {
			int a = Math.max(x, y);
			int b = Math.min(x, y);
			while (b != 0) {
				int t = b;
				b = a % b;
				a = t;
			}
			return a;
		}

		private Set<Integer> primeFactors(int n) {
			Set<Integer> s = new HashSet<>();
			if (n % 2 == 0) {
				s.add(2);
				while (n > 0 && n % 2 == 0) {
					n = n / 2;
				}
			}
			for (int i = 3; i * i <= n; i += 2) {
				if (n % i == 0) {
					s.add(i);
					while (n > 0 && n % i == 0) {
						n = n / i;
					}
				}
			}
			if (n > 1) {
				s.add(n);
			}
			return s;
		}

		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int q = in.nextInt();
			for (int mmm = 0; mmm < q; mmm++) {
				int n = in.nextInt();
				n *= 2;
				double ans = 1 / Math.tan(Math.PI / n);
				out.println(ans);
			}
		}

		private long power(long x, long y) {
			long res = 1;
			long mod = 1000000007;
			while (y > 0) {
				if (y % 2 == 1)
					res = (res * x) % mod;
				y = y >> 1;
				x = (x * x) % mod;
			}
			return res;
		}

	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}
	}
}