#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1<<29;
const double PI = acos(-1);
const double EPS = 1e-8;

typedef long double Double;

typedef vector<Double> vec;
typedef vector<vec> mat;

ostream &operator<<(ostream &os, const vec &a) {
  FOR(it, a) os << setw(6) << *it << " ";
  return os;
}
ostream &operator<<(ostream &os, const mat &a) {
  FOR(it, a) os << *it << endl;
  return os;
}

mat mul(mat A, mat B) {
  mat C(A.size(), vec(B[0].size()));
  REP(i,A.size()) REP(j,B[0].size()) REP(k,B.size())
    C[i][j] += A[i][k]*B[k][j];
  return C;
}

mat pow(mat A, ll n) {
  mat B(A.size(), vec(A.size()));
  REP(i,A.size())
    B[i][i] = 1;
  while(n) {
    if (n&1) B = mul(B, A);
    A = mul(A,A);
    n >>= 1;
  }
  return B;
}

bool GaussElimination(const mat &A, const vec &b, vec &res) {
  int n = A.size();
  mat B(n, vec(n+1));
  REP(i,n) REP(j,n)
    B[i][j] = A[i][j];
  REP(i, n) B[i][n] = b[i];
  
  int nowy = 0;
  REP(x, n) {
    int pivot = nowy;
    for (int j=nowy; j<n; ++j)
      if (abs(B[j][x]) > abs(B[pivot][x])) pivot = j;
    if (pivot == -1) continue;
    swap(B[nowy], B[pivot]);

    for (int j=nowy+1; j<n; ++j) {
      Double t = B[j][x] / B[nowy][x];
      B[j][x] = 0;
      for (int k=x+1; k<=n; ++k)
        B[j][k] = B[j][k] - B[nowy][k] * t;
    }
    nowy++;
  }
  res.clear();
  for (int y=nowy; y<n; ++y)
    if (B[y][n] > EPS)                // rank(A) != rank(A|b)
      return 0;
  if (nowy != n) {              // rank(A) == rank(A|b) != n
    return 0;
  }
  // ðªêÓÉÜéBÊÉãÞãü
  res.resize(n);
  for (int x=n-1; x>=0; --x) {
    Double sum = B[x][n];
    for (int i=n-1; i>x; --i) {
      sum -= res[i] * B[x][i]; 
    }
    res[x] = sum / B[x][x];
  }
  return 1;
}

Double DP[11][101];                 // DP[i][j] = iñUÁ½Æ«jÉÈéêÌ
Double P[101];                  // P[i] = iiÞm¦

int main() {
  int s,n,k;
  while(cin >> s >> n >> k) {
    s = abs(s);

    if (n == 1) {
      ll ans = -1;
      if (s%k == 0) ans = s / k;
      cout << ans << endl;
      continue;
    }
    
    memset(DP,0,sizeof(DP));
    DP[0][0] = 1;
    REP(i,k) {
      for (int j=n*k; j>=0; --j) {
        for (int l=n; l>=1; --l) {
          if (j+l > n*k) continue;
          DP[i+1][j+l] += DP[i][j] / n;
        }
      }
    }
    Double pp = 1;
    REP(i, k) pp/=n;
    REP(i,n*k+1) {
      //cout << DP[k][i] << " ";
      P[i] = DP[k][i];
      //REP(j, k) P[i] /= n;
      //cout << P[i] << " ";
      //printf("%.8Lf ", P[i]);
    }//cout << endl;
    mat A(n*k,vec(n*k));
    A[0][0] = 1;
    for (int i=1; i<n*k; ++i) {
      A[i][i] = 1;
      for (int j=1; j<=n*k; ++j) {
        A[i][abs(i-j)] -= P[j];
      }
    }
    vec b(n*k);
    REP(i, n*k-1) b[i+1] = 1;
    //cout << A << endl;
    vec T(n*k);
    GaussElimination(A, b, T);
    // FOR(it, T) printf("%.8Lf ", *it);
    // cout << endl;

    if (s<n*k) {
      printf("%.8Lf\n", T[s]);
    } else {
  
      mat B(n*k+1, vec(n*k+1));
      REP(i, n*k) B[0][i] = P[i+1];
      B[0][n*k] = 1;
      REP(i,n*k-1) B[i+1][i] = 1;
      B[n*k][n*k] = 1;
      //cout << B << endl;
      B = pow(B, s-n*k+1);
      //cout << B << endl;
      Double ans = 0;
      REP(i, n*k) {
        ans += B[0][i] * T[n*k-1-i];
      }
      ans += B[0][n*k];
      printf("%.8Lf\n", ans);
    }
  }
}

Measured memory_bytes: 1744