#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



#define NUM 100

typedef vector<double> V;
typedef vector<V> MATRIX;
int S,N,K,SIZE,pow_SIZE;
double table[105];
double dp[11][105];
double memo[500000];

MATRIX calc(MATRIX left,MATRIX right){

	MATRIX ret(pow_SIZE,V(pow_SIZE));

	for(int i = 0; i < pow_SIZE; i++){
		for(int k = 0; k < pow_SIZE; k++)ret[i][k] = 0;
	}

	for(int row = 0; row < pow_SIZE; row++){
		for(int col = 0; col < pow_SIZE; col++){
			for(int a = 0; a < pow_SIZE; a++){
				ret[row][col] += left[row][a]*right[a][col];
			}
		}
	}

	return ret;

}


MATRIX pow(MATRIX MULT,int count){

	MATRIX ret(pow_SIZE,V(pow_SIZE));

	for(int row = 0; row < N; row++){
		for(int col = 0; col < N; col++){
			if(row == col)ret[row][col] = 1;
			else{
				ret[row][col] = 0;
			}
		}
	}

	while(count > 0){
		if(count%2 == 1)ret = calc(ret,MULT);
		MULT = calc(MULT,MULT);
		count /= 2;
	}

	return ret;
}


MATRIX gauss_jordan(MATRIX A,int S){

	MATRIX C(SIZE,V(SIZE+1));

	for(int row = 0; row < SIZE; row++){
		for(int col = 0; col <= SIZE; col++){
			C[row][col] = A[row][col];
		}
	}

	int base_row;
	double tmp;

	for(int i = 0; i < SIZE; i++){
		base_row = i;
		for(int row = i+1; row < SIZE; row++){
			if(fabs(C[row][i]) > fabs(C[base_row][i])){
				base_row = row;
			}
		}

		if(fabs(C[base_row][i]) < EPS)continue;

		if(base_row != i)swap(C[base_row],C[i]);

		tmp = C[i][i];
		for(int col = 0; col <= SIZE; col++){
			C[i][col] /= tmp;
		}

		for(int row = 0; row < SIZE; row++){
			if(row == i || fabs(C[row][i]) < EPS)continue;

			tmp = C[row][i];

			for(int col = i; col <= SIZE; col++){
				C[row][col] -= C[i][col]*tmp;
			}
		}
	}

	return C;
}


int main(){

	scanf("%d %d %d",&S,&N,&K);

	if(S < 0)S *= -1;

	if(N == 1){

		if(S%K == 0){

			printf("%.10lf\n",(double)(abs(S)/K));
		}else{
			printf("-1\n");
		}
		return 0;
	}

	for(int a = 0; a <= N*K; a++){
		if(a >= 1 && a <= N){
			dp[1][a] = 1;
		}else{
			dp[1][a] = 0;
		}
	}
	for(int i = 2; i <= K; i++){
		for(int a = i; a <= N*K; a++){
			dp[i][a] = 0;
		}
	}

	for(int loop = 2; loop <= K; loop++){
		for(int add = 1; add <= N; add++){
			for(int sum = 0; sum+add <= N*K; sum++){
				dp[loop][sum+add] += dp[loop-1][sum];
			}
		}
	}

	for(int i = 0; i <= K; i++){
		for(int a = 0; a <= N*K; a++){
			dp[i][a] = 0;
		}
	}

	dp[0][0] = 1.0;

	for(int count = 0; count < K; count++){
		for(int add = 1; add <= N; add++){
			for(int sum = count; sum+add <= N*K; sum++){
				dp[count+1][sum+add] += dp[count][sum]/N;
			}
		}
	}

	for(int i = K; i <= N*K; i++){
		table[i] = dp[K][i];
	}

	SIZE = N*K+1;

	MATRIX A(SIZE,V(SIZE+1));

	for(int row = 0; row < SIZE; row++){
		for(int col = 0; col <= SIZE; col++){
			A[row][col] = 0;
		}
	}

	A[0][0] = 1.0;
	for(int row = 1; row < SIZE; row++){

		A[row][row] = 1.0;
		for(int i = K; i <= N*K; i++){
			A[row][abs(row-i)] -= table[i];
		}
		A[row][SIZE] = 1.0;
	}

	A = gauss_jordan(A,S);

	if(S <= N*K){

		printf("%.10lf\n",A[S][SIZE]);
		return 0;
	}

	pow_SIZE = N*K+1;
	MATRIX MULT(pow_SIZE,V(pow_SIZE));

	for(int row = 0; row < pow_SIZE; row++){
		for(int col = 0; col < pow_SIZE; col++){
			MULT[row][col] = 0;
		}
	}

	for(int col = K; col <= N*K; col++){
		MULT[0][col-1] += table[col];
	}
	MULT[0][N*K] = 1;

	for(int row = 1; row <= N*K-1; row++){
		MULT[row][row-1] = 1.0;
	}
	MULT[N*K][N*K] = 1.0;

	MULT = pow(MULT,S-N*K);

	double ans = 0;
	MATRIX RIGHT(N*K+1,V(1));

	for(int row = 0; row <= N*K-1; row++){
		RIGHT[row][0] = A[N*K-row][SIZE];
	}
	RIGHT[N*K][0] = 1.0;

	for(int col = 0; col < pow_SIZE; col++){

		ans += MULT[0][col]*RIGHT[col][0];
	}

	printf("%.10lf\n",ans);

	return 0;
}



Measured memory_bytes: 3552