#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>	// require sort next_permutation count __gcd reverse etc.
#include <cstdlib>	// require abs exit atof atoi 
#include <cstdio>		// require scanf printf
#include <functional>
#include <numeric>	// require accumulate
#include <cmath>		// require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip>	// require setw
#include <sstream>	// require stringstream 
#include <cstring>	// require memset
#include <cctype>		// require tolower, toupper
#include <fstream>	// require freopen
#include <ctime>		// require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()

using namespace std;

typedef long long ll;

/*
	No.76 回数の期待値で練習

	条件付期待値

	定理 E[N] = E[E[N|Y]]

	E[N|Y] = Σ E[N|Y=i]P(Y=i)

	E[N]: N 以上になるまでに振る回数の期待値

	Y: 直前に振ったサイコロの目(=1,2,3,4,5,6)
	E[N|Y]: 直前に振ったサイコロの目が Y の場合の N 以上になるまでに振る回数の期待値

	E[N] = E[N|Y=1]*P1 + E[N|Y=2]*P2 + E[N|Y=3]*P3 + E[N|Y=4]*P4 + E[N|Y=5]*P5 + E[N|Y=6]*P6

	（ただし P(Y=i) = Pi と置いた)

	N = 1 のとき
	E[1] 	= E[1|Y=1]*P1 + E[1|Y=2]*P2 + E[1|Y=3]*P3 + E[1|Y=4]*P4 + E[1|Y=5]*P5 + E[1|Y=6]*P6
		= 1*P1 + 1*P2 + 1*P3 + 1*P4 + 1*P5 + 1*P6
		= 1

	N = 2 のとき
	E[2]	= E[2|Y=1]*P1 + E[2|Y=2]*P2 + E[2|Y=3]*P3 + E[2|Y=4]*P4 + E[2|Y=5]*P5 + E[2|Y=6]*P6
 		= (1 + E[1])*P1 + 1*P2 + 1*P3 + 1*P4 + 1*P5 + 1*P6
		= E[1]*P1 + 1

	N = 3 のとき
	E[3]	= E[3|Y=1]*P1 + E[3|Y=2]*P2 + E[3|Y=3]*P3 + E[3|Y=4]*P4 + E[3|Y=5]*P5 + E[3|Y=6]*P6
		= (1 + E[2])*P1 + (1 + E[1])*P2 + 1*P3 + 1*P4 + 1*P5 + 1*P6
		= E[2]*P1 + E[1]*P2 + 1

	N = 4 のとき
	E[4]	= E[4|Y=1]*P1 + E[4|Y=2]*P2 + E[4|Y=3]*P3 + E[4|Y=4]*P4 + E[4|Y=5]*P5 + E[4|Y=6]*P6
		= (1 + E[3])*P1 + (1 + E[2])*P2 + (1 + E[1])*P3 + 1*P4 + 1*P5 + 1*P6
		= E[3]*P1 + E[2]*P2 + E[1]*P3 + 1

	N = 5 のとき
	E[5]	= E[5|Y=1]*P1 + E[5|Y=2]*P2 + E[5|Y=3]*P3 + E[5|Y=4]*P4 + E[5|Y=5]*P5 + E[5|Y=6]*P6
		= (1 + E[4])*P1 + (1 + E[3])*P2 + (1 + E[2])*P3 + (1 + E[1])*P4 + 1*P5 + 1*P6
		= E[4]*P1 + E[3]*P2 + E[2]*P3 + E[1]*P4 + 1

	N = 6 のとき
	E[6]	= E[6|Y=1]*P1 + E[6|Y=2]*P2 + E[6|Y=3]*P3 + E[6|Y=4]*P4 + E[6|Y=5]*P5 + E[6|Y=6]*P6
		= (1 + E[5])*P1 + (1 + E[4])*P2 + (1 + E[3])*P3 + (1 + E[2])*P4 + (1 + E[1])*P5 + 1*P6
		= E[5]*P1 + E[4]*P2 + E[3]*P3 + E[2]*P4 + E[1]*P5 + 1

	N = 7 のとき
	E[7]	= E[7|Y=1]*P1 + E[7|Y=2]*P2 + E[7|Y=3]*P3 + E[7|Y=4]*P4 + E[7|Y=5]*P5 + E[7|Y=6]*P6
		= (1 + E[6])*P1 + (1 + E[5])*P2 + (1 + E[4])*P3 + (1 + E[3])*P4 + (1 + E[2])*P5 + (1 + E[1])*P6
		= E[6]*P1 + E[5]*P2 + E[4]*P3 + E[3]*P4 + E[2]*P5 + E[1]*P6 + 1

	N > 7 のとき
	E[i+7] = E[i+7|Y=1]*P1 + E[i+7|Y=2]*P2 + E[i+7|Y=3]*P3 + E[i+7|Y=4]*P4 + E[i+7|Y=5]*P5 + E[i+7|Y=6]*P6
		= (1 + E[i+6])*P1 + (1 + E[i+5])*P2 + (1 + E[i+4])*P3 + (1 + E[i+3])*P4 + (1 + E[i+2])*P5 + (1 + E[i+1])*P6
		= E[i+6]*P1 + E[i+5]*P2 + E[i+4]*P3 + E[i+3]*P4 + E[i+2]*P5 + E[i+1]*P6 + 1 

*/

const int MAX_N = (int)1e6 + 6;

const double E[7] = { 0, 1.0000000000000000, 1.0833333333333333, 1.2569444444444444
				,1.5353009259259260, 1.6915991512345676, 2.0513639724794235 };

double P[7];
double dp[MAX_N];
int main()
{
	memset (P, 0., sizeof (P ) );
	memset (dp, 0., sizeof (dp ) );
	ios_base::sync_with_stdio(0);
	P[1] = (E[2] - 1. )/E[1];
	P[2] = (E[3] - E[2]*P[1] - 1. )/E[1];
	P[3] = (E[4] - E[3]*P[1] - E[2]*P[2] - 1. )/E[1];
	P[4] = (E[5] - E[4]*P[1] - E[3]*P[2] - E[2]*P[3] - 1. )/E[1];
	P[5] = (E[6] - E[5]*P[1] - E[4]*P[2] - E[3]*P[3] - E[2]*P[4] - 1. )/E[1];
	P[6] = 1. - P[1] - P[2] - P[3] - P[4] - P[5] - P[6];

	for (int i = 1; i <= 6; i++ ) dp[i] = E[i];
	for (int i = 7; i < MAX_N; i++ ){
		for (int j = 1; j <= 6; j++ ){		
			dp[i] += dp[i-j]*P[j];
		} // end for
		dp[i] += 1.;
	} // end for
	
	int T; cin >> T;
	while (T-- ){
		int Nk; cin >> Nk;
		printf ("%.8lf\n", dp[Nk] );
	} // end while

	return 0;
}