#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#define REP(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)

#define ll long long
#define ull unsigned ll

#define ULL_HASH_SIZE 15000
ull ull_hash_n[ULL_HASH_SIZE]; int ull_hash_d[ULL_HASH_SIZE];

void ullHashClear(void){ memset(ull_hash_d,0,ULL_HASH_SIZE*sizeof(int)); }
int ullHashFunction(ull a){ return (a*1007)%ULL_HASH_SIZE; }

int ullHashGet(ull a){
  int i=ullHashFunction(a);
  for(;;){
    if(ull_hash_n[i]==a && ull_hash_d[i]) break;
    if(!ull_hash_d[i]) break;
    i++; if(i==ULL_HASH_SIZE) i=0;
  }
  if(ull_hash_n[i]!=a) return 0; return ull_hash_d[i];
}

void ullHashSet(ull a,int n){
  int i=ullHashFunction(a);
  for(;;){
    if(ull_hash_n[i]==a && ull_hash_d[i]) break;
    if(!ull_hash_d[i]) break;
    i++; if(i==ULL_HASH_SIZE) i=0;
  }
  ull_hash_n[i]=a; ull_hash_d[i]=n;
}

int ullHashIncrease(ull a){
  int i=ullHashFunction(a);
  for(;;){
    if(ull_hash_n[i]==a && ull_hash_d[i]) break;
    if(!ull_hash_d[i]) break;
    i++; if(i==ULL_HASH_SIZE) i=0;
  }
  ull_hash_n[i]=a; return ++ull_hash_d[i];
}



#define MAX_STATE 6500
#define MAX_WIDTH 12
#define MAX_HEIGHT 35

int num_state;
int state[MAX_STATE][MAX_WIDTH], state_reach[MAX_STATE], is_reachable[MAX_STATE]; ull state_hs[MAX_STATE];
int edge1[MAX_STATE][4], edge2[MAX_STATE][2];

ull hash_calc(int state[], int state_reach, int width){
  int i;
  ull res = 0;

  rep(i,width) res = res * 1007 + state[i];
  res = res * 10007 + state_reach;
  return res;
}

int get_state_number(int next_state[], int next_reach, int width){
  int i, k;
  ull hs = hash_calc(next_state, next_reach, width);

  k = ullHashGet(hs) - 1;
  if(k == -1){
    rep(i,width) state[num_state][i] = next_state[i];
    state_reach[num_state] = next_reach;
    state_hs[num_state] = hs;
    ullHashSet(state_hs[num_state], num_state + 1);
    k = num_state++;
  }

/*  rep(i,width) if(state[k][i] != next_state[i] || state_reach[k] != next_reach){ puts("WRONG!!"); exit(0); } */

  return k;
}

int permutation[30], permutation_size;
void order_state(int state[], int *state_reach, int width){
  int i;
  permutation_size = 0;
  rep(i,width+1) permutation[i] = -1;
  rep(i,width) if(permutation[state[i]] < 0) permutation[state[i]] = permutation_size++;
  rep(i,width) state[i] = permutation[state[i]];
  rep(i,width) if(state[i] == state[*state_reach]){*state_reach = i; break;}
}

void gen_state(int width){
  int i,j,k;
  int from, to;
  int next_state[20], next_reach;
  ull hs;

  ullHashClear();

  num_state = 1;

  rep(i,MAX_WIDTH) state[0][i] = i;
  state_reach[0] = width-1;
  state_hs[0] = hash_calc(state[0], state_reach[0], width);
  ullHashSet(state_hs[0], 1);

  rep(k,num_state){

    /* 1-0 prob = (1-p)^2 */
    do{
      rep(i,width) next_state[i] = state[k][(i+1)%width];
      from = next_state[width-2];
      to   = next_state[width-1];
      if(from != to) rep(i,width) if(next_state[i]==from) next_state[i] = to;
      next_reach = (state_reach[k]+width-1)%width;
      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge1[k][0] = i;
    }while(0);
    
    /* 1-1 prob = p (1-p) */
    do{
      rep(i,width) next_state[i] = state[k][(i+1)%width];
      next_reach = (state_reach[k]+width-1)%width;
      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge1[k][1] = i;
    }while(0);

    /* 1-2 prob = p (1-p) */
    do{
      REP(i,1,width) if(state[k][state_reach[k]] == state[k][i]) break;
      if(i==width){ edge1[k][2] = -1; break; }
      next_reach = i - 1;

      rep(i,width-1) next_state[i] = state[k][i+1];
      next_state[width-1] = next_state[width-2];

      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge1[k][2] = i;
    }while(0);
    
    /* 1-3 prob = p^2     */
    do{
      REP(i,1,width) if(state[k][state_reach[k]] == state[k][i]) break;
      if(i==width){ edge1[k][3] = -1; break; }
      next_reach = i - 1;

      rep(i,width-1) next_state[i] = state[k][i+1];
      next_state[width-1] = width;

      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge1[k][3] = i;
    }while(0);
    
    
    /* 2-0 prob = 1-p     */
    do{
      rep(i,width) next_state[i] = state[k][(i+1)%width];
      next_reach = (state_reach[k]+width-1)%width;
      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge2[k][0] = i;
    }while(0);
    
    /* 2-1 prob = p       */
    do{
      REP(i,1,width) if(state[k][state_reach[k]] == state[k][i]) break;
      if(i==width){ edge2[k][1] = -1; break; }
      next_reach = i - 1;
      
      rep(i,width-1) next_state[i] = state[k][i+1];
      next_state[width-1] = width;

      order_state(next_state, &next_reach, width);
      i = get_state_number(next_state, next_reach, width);
      edge2[k][1] = i;
    }while(0);
    
  }

  rep(k, num_state){
    is_reachable[k] = 0;
    if(state[k][state_reach[k]] == state[k][width-1]) is_reachable[k] = 1;
  }

}



double res[MAX_HEIGHT];
double mem1[MAX_STATE], mem2[MAX_STATE];

double ab(double x){ if(x<0) return -x; return x; }

int do_dp(int width, double p, ll limit){
  int i,j,k,loop,height;
  int last, rest = MAX_HEIGHT - 3;
  double p1[4], p2[2], sum;
  double *dp = mem1, *next = mem2, *swap;

  dp[0] = 1;
  REP(i, 1, num_state) dp[i] = 0;

  p1[0] = (1-p)*(1-p);
  p1[1] = p1[2] = p*(1-p);
  p1[3] = p*p;
  p2[0] = 1-p;
  p2[1] = p;

  for(height=1;height<=limit;height++){

    REP(loop, 1, width){
      rep(i, num_state) next[i] = 0;
      rep(i, num_state) if(dp[i] > 1e-200) rep(j, 4) if(edge1[i][j] >= 0) next[edge1[i][j]] += dp[i] * p1[j];
      swap = dp, dp = next, next = swap;
    }

    res[height] = 0;
    rep(i, num_state) if(is_reachable[i]) res[height] += dp[i];

    rest--;
    if(rest <= 0) return height;
    if(rest > 10 && height > 10){
      sum = 0;
      sum += ab(res[height  ] / res[height-1] - res[height-1] / res[height-2]);
      sum += ab(res[height-1] / res[height-2] - res[height-2] / res[height-3]);
      sum += ab(res[height-2] / res[height-3] - res[height-3] / res[height-4]);
      if(sum < 1e-12) rest = 10;
    }
    if(rest > 3 && res[height] < 1e-6) rest = 3;

    rep(i, num_state) next[i] = 0;
    rep(i, num_state) if(dp[i] > 1e-200) rep(j, 2) if(edge2[i][j] >= 0) next[edge2[i][j]] += dp[i] * p2[j];
    swap = dp, dp = next, next = swap;

  }
}


#define EPS 1e-10

int main(){
  int i,j,k,height;
  int R; ll C; double p, per;
  int T;

  int R_in[10000]; ll C_in[10000]; double p_in[10000];
  double output[10000];

  scanf("%d",&T);
  rep(i,T) scanf("%d%lld%lf",R_in+i, C_in+i, p_in+i);

  rep(i, T) if(R_in[i] == 1){
    output[i] = pow(1-p_in[i], C_in[i]-1);
  }

  REP(R,2,9){
    gen_state(R);
    rep(i, T) if(R_in[i] == R){
      if(p_in[i] >= 0.999999){ output[i] = 0; continue; }
      height = do_dp(R, p_in[i],C_in[i]+1);
      if(C_in[i] <= height){
        output[i] = res[C_in[i]];
      } else {
        per = res[height] / res[height-1];
        if(per > 1) per = 1;
        output[i] = res[height-1] * pow(per, C_in[i] - (height-1));
      }
    }
  }

  rep(i,T) printf("%.15f\n", output[i]);

  return 0;
}