#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;

struct Data {
  constexpr Data() : data(0.0) {}
  constexpr Data(const long double val) : data(val) {}
  Data& operator=(const Data &) = default;
  operator long double() const { return data; }
  Data& operator+=(const Data &that) {
    *this = *this + that;
    return *this;
  }
  Data& operator-=(const Data &that) {
    *this = *this - that;
    return *this;
  }
  Data& operator/=(const Data &that) {
    *this = *this / that;
    return *this;
  }
  long double data;
};
constexpr Data eps = 1e-20;

Data operator+(const Data &lhs, const Data &rhs) {
  return lhs.data + rhs.data;
}

Data operator-(const Data &lhs, const Data &rhs) {
  return lhs.data - rhs.data;
}

Data operator*(const Data &lhs, const Data &rhs) {
  if (abs(lhs.data) > eps && abs(rhs.data) > eps) {
    return lhs.data * rhs.data;
  } else {
    return 0.0;
  }
}

Data operator/(const Data &lhs, const Data &rhs) {
  return lhs.data / rhs.data;
}

using Array = vector<Data>;
using Matrix = vector<Array>;
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())
      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())
    res[i] = inner_product(begin(lhs[i]),end(lhs[i]),begin(rhs),Data(0));
  return res;
}

int main() {
  cout << fixed << setprecision(10);
  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]+=Data(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] = Data(1.0)-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: 8200