Problem: There is a game called Sim Forest 2013. In this game, the player can become a forest god and raise forest animals.

Animals hatch from eggs and breed. When certain conditions are met, eggs are mutated with a certain probability to give birth to new races of animals.

There is an animal encyclopedia in this game, and when you get a new kind of animal, it will be recorded in the animal dictionary.

Mori is an enthusiastic player of Sim Forest 2013. His animal dictionary is complete when the remaining one race is filled.

Mori decided to obtain this remaining one race by mutation from the egg.

The game progress is as follows.

* N eggs will appear at the beginning of the stage.
* N eggs hatch s minutes after the start of the stage.
* Each egg has a 1 / p chance of targeting on a specific day of the week and within a specific time zone during the entire period * from appearance to hatching * (including the time of appearance and the moment of hatching). Mutates in animals.
* The stage ends t minutes after the start of the stage, and the same stage starts immediately after that (starts with n eggs. The elapsed time is not reset).
* The stage is repeated m times in a row.



This game meets the following specifications.

* Animals born from eggs do not lay eggs.
* Eggs hatch only once per stage, s minutes after the start of the stage.
* Mr. Sori can set the start day and start time of the first stage as desired. (The start time of the second and subsequent stages will be immediately after the end of the previous stage)
* One of {all days, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday} is given as a mutable day.
* One of {all time zones, morning, night} is given as a mutable time zone.



Inputs are s, n, t, mutable day / time zone, p, m. Find the probability when you set the start day and start time of the first stage so that the probability of mutation occurring by the end of all stages is maximized.

Input

The input consists of multiple datasets. Each dataset is given in the following format:


s n t weekday time p m


Each dataset shows the time it takes for an egg to hatch from the start of the stage s, the number of eggs that appear at the start of the stage n, the time it takes to finish one stage t, the mutable day weekday, the mutable Time zone time, reciprocal of mutation probability p (mutation probability is 1 / p), total number of stages m.

The input satisfies the following constraints.

* 0 <s <= 500
* 0 <n <= 100
* s <t <= 1000
* weekday ∈ {All, Sun, Mon, Tue, Wed, Thu, Fri, Sat}
* All means all days of the week
* time ∈ {All, Day, Night}
* All means [0: 00 ~ 24: 00), Day means [6: 00 ~ 18: 00), and Night means [18: 00 ~ 6: 00).
* 1 <= p <= 99999
* 1 <= m <= 100



The end of the input is given on the following line.


0 0 0 None None 0 0


Output

For each dataset, output the probability when the start day and start time of the first stage is set so that the probability of mutation occurring by the end of all stages is maximized. The error in the answer must not exceed 0.00000001 (10-8). Any number of digits after the decimal point may be output as long as the precision conditions are met.

Sample Input


1 1 3 All All 1 1
2 37 5 All Night 150 1
16 2 20 All Day 5 10
1 14 15 Mon All 20000 100
0 0 0 None None 0 0


Output for Sample Input


1.0000000000
0.2192439716
0.9884707850
0.0649933899






Example

Input

1 1 3 All All 1 1
2 37 5 All Night 150 1
16 2 20 All Day 5 10
1 14 15 Mon All 20000 100
0 0 0 None None 0 0


Output

1.0000000000
0.2192439716
0.9884707850
0.0649933899

Solution (in CPP):

Solution:
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f

#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
  
using namespace std;
  
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
  
static const double EPS = 1e-8;
  
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};

const static char weekdays[][4] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
const static char times[][6] = {"Day","Night"};

const char* compute_weekday(int minutes){
  int tmp = (minutes / (60 * 24)) % 7;
  return weekdays[tmp];
}

const char* compute_time_band(int minutes){
  int idx = 0;
  int tmp = minutes % (60 * 24);
  if(tmp >= 6 * 60
     && tmp < 18 * 60){
    idx = 0;
  }
  else{
    idx = 1;
  }
  return times[idx];
}


int main(){
  int wait_hatch;
  int num_of_egg;
  int stage_life;
  char mutation_weekday[4];
  char mutation_time_band[6];
  int inv_mutation_prob;
  int total_stages;
  double probs[101];
  while(~scanf("%d %d %d %s %s %d %d",
               &wait_hatch,
               &num_of_egg,
               &stage_life,
               mutation_weekday,
               mutation_time_band,
               &inv_mutation_prob,
               &total_stages)){
    
    if(total_stages == 0) break;

    probs[0] = 1.0;
    for(int i=0;i<num_of_egg;i++){
      probs[i+1] = probs[i] * (1.0 - 1.0/inv_mutation_prob);
    }

    double res = 0.0;
    for(int start=0; start < 60 * 24 * 7;start++){
      int init_start = start;
      double prob = 1.0;
      
      for(int round = 0; round < total_stages; round++){
        int time = init_start + wait_hatch;

        if(strcmp(mutation_weekday,"All") != 0
           && strcmp(compute_weekday(time),mutation_weekday) != 0){
          init_start += stage_life;
          continue;
        }

        if(strcmp(mutation_time_band,"All") != 0
           && strcmp(compute_time_band(time),mutation_time_band) != 0){
          init_start += stage_life;
          continue;
        }

        if(strcmp(mutation_weekday,"All") != 0
           && strcmp(compute_weekday(init_start),compute_weekday(time)) != 0){
          init_start += stage_life;
          continue;
        }
        if(strcmp(mutation_time_band,"All") != 0
           && strcmp(compute_time_band(init_start),compute_time_band(time)) != 0){
          init_start += stage_life;
          continue;
        }

        prob *= probs[num_of_egg];
        init_start += stage_life;
      }
      res = max(res,1.0-prob);
    }
    printf("%.10f\n",res);
  }
}