Problem: Consider the following game. There are k pairs of n cards with numbers from 1 to n written one by one. Shuffle these kn cards well to make piles of k cards and arrange them in a horizontal row. The i-th (k-card) pile from the left of the n piles created in this way is called "mountain i".

<image>


The game starts at mountain 1. Draw the top card of the pile (the drawn card is not returned to the original pile), and if the number written on that card is i, draw the top card of the pile i Pull. In this way, draw the top card of the pile numbered by the number written on the drawn card repeatedly, and if all the piles have no cards, it is successful. If there are still piles of cards left, but there are no more piles to draw next, it is a failure.

If it fails in the middle, it ends with a failure, or the remaining card pile is left as it is (the pile number is also kept as it is) and the game is restarted. When restarting the game, the first card to draw is from the leftmost pile of the remaining piles (the top card of that pile is the first card to be drawn). After resuming, proceed with the game in the same way as before resuming, and if there are no cards in all the piles, it is a success. It is a failure.

<image>


Such a game shall be restarted up to m times. However, m is 0 or 1. In other words, it either does not restart once or restarts only once. The initial placement of cards differs depending on how you shuffle before the game starts. Of course, depending on the initial placement of the card, it may succeed without resuming, it may resume and succeed, or it may resume and fail. Since it is shuffled enough, we assume that all initial arrangements appear with the same probability, and we want to find the probability p that the restart will succeed within m times. Express this probability p as a decimal number, and create a program that finds and outputs to the decimal place r. However, output so that the following conditions are met.

* If p × 10K becomes an integer when a sufficiently large positive integer K is taken, 0 continues from the middle of the decimal part, but that 0 should also be output. For example, if p = 3/8 = 0.375, then 0.37500 is output if r = 5, and 0.37 is output if r = 2. Similarly, when p = 1.0, for example, if r = 3, output 1.000.
* For example, 0.150000 ... can be expressed as a recurring decimal 0.1499999 ..., but in such a case, the former expression is used.



On the first line of the input file, the integers n, k, m, and r are written in this order with a blank as the delimiter. 1 ≤ n ≤ 10000, 1 ≤ k ≤ 100, m = 0 or m = 1, 1 ≤ r ≤ 10000.

Input example 1 | Input example 2 | Input example 3
--- | --- | ---
|
2 1 0 5 | 3 1 1 3 | 2 2 1 3 |
Output example 1 | Output example 2 | Output example 3
0.50000 | 0.833 | 1.000 |

input

The input consists of multiple datasets. Input ends when n, k, m, and r are all 0. The number of datasets does not exceed 5.

output

For each dataset, p is output on one line as specified.





Example

Input

2 1 0 5
3 1 1 3
2 2 1 3
0 0 0 0


Output

0.50000
0.833
1.000

Solution (in CPP):

Solution:
#include <stdio.h>
#include <stdlib.h>
#include <string.h> 

typedef struct _double {
    unsigned char *digits;
    unsigned int precision;
} Double;
 
void double_construct(Double *e, unsigned int precision) {
    e->precision = precision;
    e->digits = (unsigned char*)malloc(sizeof(unsigned char) * precision);
 
    memset(e->digits, '\0', precision);
    return ;
}
 
void double_add(Double *e1, Double *e2) {
    unsigned int i;
    unsigned int precision = (e1->precision > e2->precision) ? e2->precision : e1->precision;
    unsigned char *tmp;
 
    for (i=precision-1; i != 0; i--) {
        e1->digits[i] += e2->digits[i];
        if (i != 0 && e1->digits[i] > 99) {
            e1->digits[i] %= 100;
            e1->digits[i-1] += 1;
        }
    }
 
    e1->precision = precision;
    tmp = (unsigned char *)realloc(e1->digits, sizeof(unsigned char) * precision);
    if (tmp != NULL) e1->digits = tmp;
 
    return ;
}
         
void double_div(Double *e, unsigned int dividend, unsigned int divisor) {
    unsigned int i;
    int ratio = 0;
 
    while (dividend/10 > divisor) {
        divisor *= 10;
        ratio--;
    }
 
    if (ratio >= 2) {
        puts("Error"); return ;
    }
 
    for (i=ratio+1; i < e->precision*2; i++) {
        unsigned int j;
        unsigned int quotient = dividend / divisor;
 
        if (quotient >= 10) {
            puts("Error::");
            return ;
        }
 
        if (i%2 == 0) e->digits[i/2] += quotient * 10;
        else e->digits[i/2] += quotient;
 
        dividend -= divisor * quotient;
        dividend *= 10;
    }
 
    return ;
}
 
void double_print(Double *e, unsigned int digit_num) {
    unsigned int i;
 
    printf("%u.", e->digits[0]);
 
    for (i=2; i<digit_num; i++) {
        if (i%2 == 0) printf("%u", e->digits[i/2]/10);
        else printf("%u", e->digits[i/2]%10);
    }
 
    puts("");
 
    return ;
}
 
void double_destruct(Double *e) {
    free(e->digits);
 
    return ;
}
 
int main() {
    while (1) {
        unsigned int n, k, m,r;
        Double p;
 
        scanf("%d %d %d %d", &n, &k, &m, &r);
        if (n == 0 && k == 0 && m == 0 && r == 0) return 0;
 
        double_construct(&p, r);
        double_div(&p, 1, n);
 
        if (m == 1) {
            for (unsigned int g=2; g<=n; g++) {
                Double tmp;
 
                double_construct(&tmp, r);
                double_div(&tmp, 1, n * (g-1));
                double_add(&p, &tmp);
                double_destruct(&tmp);
            }
        }
 
        double_print(&p, r+2);
    }
}