// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;

#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
 
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
 
typedef pair<int, int> pii;
typedef long long ll;
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;

// 行列ライブラリ
// Verified: TopCoder SRM 704 Div.2 (ModEquationEasy)
// 行列の積 と 累乗(繰り返し二乗法)

// Matrix Library Begin (C++11)

template <typename T>
using Matrix = vector< vector<T> >;

template <typename T>
void init_mat(Matrix<T> &A, int h, int w) {
    A.resize(h, vector<T>(w, 0));
}

template <typename T>
Matrix<T> calc_mat(Matrix<T> A, Matrix<T> B) {
    Matrix<T> C(A.size(), vector<T>(B[0].size()));
    for(int i=0; i<A.size(); i++) {
        for(int k=0; k<B.size(); k++) {
            for(int j=0; j<B[0].size(); j++) {
                C[i][j] += A[i][k] * B[k][j]; // modなし
                // C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD; // modあり
            }
        }
    }
    return C;
}

template <typename T>
Matrix<T> mat_pow(Matrix<T> A, ll n) {
    Matrix<T> B(A.size(), vector<T>(A.size()));
    for(int i=0; i<A.size(); i++) B[i][i] = 1;
    while(n > 0) {
        if(n & 1) B = calc_mat(B, A);
        A = calc_mat(A, A);
        n >>= 1;
    }
    return B;
}

// calculate vector x which satisfies Ax = b
// (A is N*N Matrix, b, x is N-dim vector)

template <typename T>
using Matrix = vector< vector<T> >;
constexpr long double EPS = 1e-8;

template <typename T>
vector<long double> gauss_jordan(const Matrix<T> &A, const vector<T> &b) {
    int N = A.size();
    // B = [A b]
    Matrix<long double> B(N, vector<long double>(N+1));
    for(int i=0; i<N; i++) {
        for(int j=0; j<=N; j++) {
            if(j < N) B[i][j] = A[i][j];
            else B[i][j] = b[i];
        }
    }

    for(int i=0; i<N; i++) {
        int pivot = i;
        for(int j=i+1; j<N; j++) {
            if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
        }
        if(abs(B[pivot][i]) < EPS) continue;
        swap(B[i], B[pivot]);

        // pivot is zero -> No solution or Not unique
        // assert(abs(B[i][i]) >= EPS);
        for(int j=i+1; j<=N; j++) B[i][j] /= B[i][i];
        for(int j=0; j<N; j++) {
            if(i != j) {
                for(int k=i+1; k<=N; k++) B[j][k] -= B[j][i] * B[i][k];
            }
        }
    }
    vector<long double> x(N);
    for(int i=0; i<N; i++) x[i] = B[i][N];
    return x;
}

long double d[11][110], dice[110], dp[110];
signed main() {
    int S, N, K; cin >> S >> N >> K;
    S = abs(S);

    if(N == 1 and S % K != 0) {
        cout << -1 << endl;
        return 0;
    }

    d[0][0] = 1.0;
    for(int i=0; i<K; i++) {
        for(int j=i*N; j>=0; j--) {
            for(int k=N; k>=1; k--) {
                d[i+1][j+k] += d[i][j] / N;
            }
        }
    }

    int M = N*K;
    long double sum = 0.0;
    for(int i=0; i<=M; i++) {
        dice[i] = d[K][i];
        sum += d[K][i];
    }
    
    Matrix<long double> mat;
    vector<long double> b(M+1);
    init_mat(mat, M+1, M+1);
    for(int i=0; i<=M; i++) {
        mat[i][i] = 1.0;
        if(i > 0) {
            for(int j=0; j<=M; j++) {
                long double p = dice[j];
                int idx = abs(i - j);
                mat[i][idx] -= p;
            }
            b[i] = 1.0;
        }
    }
    auto res = gauss_jordan(mat, b);

    if(S <= M) {
        printf("%.12Lf\n", (long double)res[S]);
    }
    else {
        long double ten = 1.0;
        
        int rem = S - M;
        Matrix<long double> tab;
        init_mat(tab, M+1, M+1);
        for(int i=0; i<M; i++) {
            tab[0][i] = dice[i+1];
            if(i+1 < M) tab[i+1][i] = 1.0;
        }
        tab[0][M] = 1.0;
        tab[M][M] = 1.0;

        Matrix<long double> vec;
        init_mat(vec, M+1, 1);
        for(int i=0; i<M; i++) {
            vec[i][0] = res[M-i] * ten;
        }
        vec[M][0] = ten;

        tab = mat_pow(tab, rem);
        vec = calc_mat(tab, vec);
        printf("%.12Lf\n", (long double)vec[0][0]);
    }
    return 0;
}



Measured memory_bytes: 4104