#include <stdio.h>
#include <memory.h>
#include <vector>

using namespace std;

class Rule
{                           vector<double> p;
public:
    Rule (int r, int c);
    ~Rule() { p.clear(); }
    double win (int t);
};

// w:승리확률 저장, b:재게임 저장
int s, n;                   Rule *u[100];       double w, b, a[100];

inline double move ()       // 게임을 사각테이블(nxn)로 모형화
{
        // 이전 종료게임을 재시작시키고 초기화
        int k, x = n * n - 1;           a[0] += b;      b = 0.0;

        // n회 먼저 승리한 게임. 재시작을 위해 b에 저장
        // n회 먼저 패배한 게임. 재시작을 위해 b에 저장
        for (k = n; k --;) b += a[x-k] / 3.0;           w += b;
        for (k = x; k > 0; k -= n) b += a[k] / 3.0;

        // 1회 시행후 이기면 아래로, 지면 우로 이동, 비기면 제자리
        while (x >= n) {    k = n - 1;
            while(k --) {
                a[x] = (a[x] + a[x-n] + a[x-1]) / 3.0;  x --;
            }   a[x] = (a[x] + a[x-n]) / 3.0;           x --;
        }   while(x) {
                a[x] = (a[x] + a[x-1]) / 3.0;           x --;
            }
        a[0] /= 3.0;        return w;
}

Rule::Rule (int r, int c)
{
    // 사각테이블 초기화 및 시작위치 설정
    memset(a, 0, 8*n*n);    a[r*n+c] = 1.0;     w = b = 0.0;

    // 1000회의 시행이면 증가폭이 오차범위 내에서 움직인다고 봄.
    // 이후 일정하게 증가함.
    int e = (s < 1000) ? s : 1000;              p.assign(e, 0.0);

    // 최대 1000회 시행 승리확률을 벡터 p에 저장.
    for (int t = 1; t < e; t ++) p[t] = move();
}

double Rule::win (int t)
{
    // 계속시행or재시행시 잔여시행의 승리확률 가져옴(비교용).
    int x = s - t;          return x < 1000 ? p[x] : p[999];
}

inline void eval (int& t, int e)
{                                               int r, c, k;
    while (t <= e) {        move ();

        // 패배가 많은 경우 포기or계속 결정. u[0]:재시작, u[k]:계속시행
        for (r = 0; r < n-1; r ++)  for (c = n-1; c > r; c --) {
            if (u[0]->win(t) > u[k=r*n+c]->win(t)) {
                b += a[k];      a[k] = 0.0;
            }
        }   t ++;
    }
}

double play ()
{
    // u[0] : 재시작시 승리확률 미리 계산
    // u[k] : 계속시행 승리확률 미리 계산
    int t, r, c;                  u[0] = new Rule(0,0);
    for(r = 0; r < n-1; r ++)
        for(c = n-1; c > r; c --) u[r*n+c] = new Rule(r,c);

    memset(a, 0, 8*n*n);    a[0] = 1.0;     w = b = 0.0;    t = 1;

    // s가 충분히 크면 초기에 변동성이 크다가 중간에서 일정하게 증가후
    // 말기에 다시 변동성 증가함. 일정하게 증가하는 중간부분 건너뜀
    if (s > 1000) {
        eval (t, 749);      double d = w;   eval (t, 750);  d = w - d;
        w += (s-1000) * d;                  t = s - 249;
    }   eval (t, s);

    for(r = 0; r < n-1; r ++)
        for(c = n-1; c > r; c --) delete u[r*n+c];
    delete u[0];            return w;
}

int main ()
{
    int t;                  scanf ("%d", &t);
    while (t --) {          scanf ("%d %d", &s, &n);
        printf ("%.8f\n", (n > 1) ? play() : ((double) s / 3.0));
    }   return 0;
}