#include <bits/stdc++.h>
#define FOR(i,k,n) for(int i=(k);i<int(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(x) begin(x),end(x)

using namespace std;
using Data = long double;
using Array = vector<Data>;
using Matrix = vector<Array>;
constexpr Data eps = 1e-20;
pair<Matrix, vector<int>> LUPDecomposition(Matrix A) {
  int n=A.size();
  vector<int> perm(n);
  iota(begin(perm),end(perm),0);
  REP(i,n){
    int pivot = i;
    for(int j = i+1; j < n; ++j)
      if(abs(A[j][i]) > abs(A[pivot][i])) pivot = j;
    swap(A[pivot], A[i]);
    swap(perm[pivot], perm[i]);
    for(int j=i+1; j < n; ++j) {
      A[j][i] /= A[i][i];
      for (int k = i+1; k < n; ++k)
        A[j][k] -= A[i][k] * A[j][i];
    }
  }
  return make_pair(A, perm);
}

Array LUPBackSubstitution(Matrix& LU, vector<int>& perm, Array a) {
  int n=LU.size();
  Array tmp(n);
  REP(i,n) tmp[i] = a[perm[i]];
  swap(tmp, a);
  REP(i,n) {
    REP(j,i) a[i] -= a[j] * LU[i][j];
  }
  for(int i=n-1; i >= 0; --i) {
    for(int j=i+1; j < n; ++j)
      a[i] -= a[j] * LU[i][j];
    a[i] /= LU[i][i];
  }
  return a;
}

Matrix operator*(const Matrix &lhs, const Matrix &rhs) {
  Matrix res(lhs.size(), Array(rhs[0].size(), 0));
  REP(i,lhs.size()) REP(k,rhs.size()) REP(j,rhs[0].size())
    if (abs(lhs[i][k]) > eps && abs(rhs[k][j]) > eps)
      res[i][j] += lhs[i][k] * rhs[k][j];
  return res;
}

Matrix scalar(int size, Data k) {
  Matrix mat(size, Array(size, 0));
  REP(i,size) mat[i][i] = k;
  return mat;
}

Matrix operator^(const Matrix &lhs, const int n) {
  if (n == 0) return scalar(lhs.size(), 1);
  if (n == 1) return lhs;
  Matrix res = (lhs * lhs) ^ (n / 2);
  if (n % 2) res = res * lhs;
  return res;
}

Array operator*(const Matrix &lhs, const Array &rhs) {
  Array res(lhs.size());
  REP(i,lhs.size()) REP(j,lhs[0].size()) {
    if (abs(lhs[i][j]) > eps && abs(rhs[j]) > eps) {
      res[i] += lhs[i][j] * rhs[j];
    }
  }
  return res;
}

Data frac[101];

void frac_init(int64_t n) {
  frac[0] = 1;
  FOR(i,1,n+1) frac[i] = i * frac[i-1];
}

int64_t cmb(int64_t n, int64_t k) {
  return frac[n]/(frac[k]*frac[n-k]);
}

Array kitamasa(int64_t n, const Array& inc, const Array& twice) {
  if (n == 0) return inc;
  if (n % 2) {
    Array even = kitamasa(n-1, inc, twice);
    Data top = inner_product(ALL(inc), begin(even), 0);
    even.insert(begin(even), top);
    even.pop_back();
    return even;
  } else {
    Array half = kitamasa(n/2, inc, twice);
  }
}

int main() {
  cout << fixed << setprecision(10);
  frac_init(100);
  int64_t s,n,k;
  cin>>s>>n>>k;
  s = abs(s);
  if (s == 0) {
    cout << 0 << endl;
  }
  int64_t mx = n*k;
  Array prob(mx+1, 0.0);
  prob[0] = 1;
  REP(i,k) {
    Array tmp(mx+1, 0.0);
    REP(i,mx) {
      FOR(j,1,n+1) {
        if (i+j <= n*k) {
          tmp[i+j]+=1.0/n*prob[i];
        }
      }
    }
    swap(prob, tmp);
  }
  Matrix mat(mx, Array(mx));
  mat[0][0] = 1;
  FOR(i,1,mx) {
    Array p(mx);
    FOR(j,k,mx+1) {
      int nx = abs(i-j);
      p[nx] += prob[j];
    }
    REP(j,mx) {
      if (i == j) {
        mat[i][j] = 1-p[j];
      } else {
        mat[i][j] = -p[j];
      }
    }
  }
  Matrix LU;
  vector<int> P;
  tie(LU, P) = LUPDecomposition(mat);
  Array a(mx, 1.0);
  a[0] = 0;
  Array res = LUPBackSubstitution(LU, P, a);
  if (s < mx) {
    if (isfinite(res[s])) {
      cout << res[s] << endl;
    } else {
      cout << -1 << endl;
    }
    return 0;
  }
  Matrix rec(mx+1, Array(mx+1));
  REP(i,mx) rec[0][i] = prob[i+1];
  FOR(i,1,mx) rec[i][i-1] = 1;
  rec[0][mx] = rec[mx][mx] = 1;
  Matrix pow = rec ^ (s-mx+1);
  Array vec(mx+1);
  reverse_copy(ALL(res), begin(vec));
  vec[mx] = 1;
  Data ans = (pow * vec)[0];
  if (isfinite(ans)) {
    cout << ans << endl;
  } else {
    cout << -1 << endl;
  }
  return 0;
}

Measured memory_bytes: 8300