#include <bits/stdc++.h>
using namespace std;
#define LL long long

int main() {
  ios_base::sync_with_stdio(false); cin.tie(NULL);

  int n; LL k; cin >> n >> k;

  LL dp[4][3000005] = {0};

  dp[0][0] = 1;
  
  #if 0
  // A slower way of calculating dp[i][j] is:
  // Will give TLE: https://atcoder.jp/contests/abc200/submissions/22497898

  for (int i = 0; i < 3; i ++) {
    // O(N^2)
    for (int j = 0; j <= 3 * n; j ++) {
      for (int k = 1; k <= n; k ++) {
        dp[i + 1][j + k] += dp[i][j];
      }
    }
  }

  // first of all, we know dp[i][j] > 0 if j <= i * n;
  // next, dp[i][j] will be added to dp[i+1][j+1:j+n+1)
  // so we can basically use dp[i+1][j] as a prefix to dp[i+1][j+1]
  #else

  for (int i = 0; i < 3; i ++) {
    // O(N)
    for (int j = 0; j <= i * n; j ++) {
      dp[i+1][j+1] += dp[i][j];
      dp[i+1][j+n+1] -= dp[i][j]; // remove from accumulation.
    }
    // accumulate / prefix sum
    for (int j = 1; j <= (i + 1) * n; j ++)
      dp[i+1][j] += dp[i+1][j-1];
  }

  #endif
  // we accumulate the counts of sums until we reach k.
  // sum_{i=3}^{x} dp[3][i] <= k. we want to find x.
  int x;
  for (int i = 3; i <= 3 * n; i ++) {
    if (k <= dp[3][i]) { x = i; break; }
    else { k -= dp[3][i]; }
  }

  // finally, we can iterate the beauty of the cake
  for (int i = 1; i <= n; i ++) {
    // i is the beauty.
    // the maximum of the taste we can get is
    // x (the sum) - i (beauty) - n (pop).
    // the minimum is
    // x - i - 1.
    // we should constrain them between [1, n].
    int jmi = max(1, x - i - n), jma = min(n, x - i - 1);

    if (jmi > jma) continue; // in this case i is too small.
    if (k > (jma - jmi + 1)) {
      k -= (jma - jmi + 1); // these are the choices available for taste.
      continue;
    }

    int y = jmi + k - 1;
    int z = x - i - y;
    cout << i << ' ' << y << ' ' << z << '\n';
    return 0;
  }
}
#include <bits/stdc++.h>
#define rep(i,n) for(int i=(0);i<(n);i++)

using namespace std;

typedef long long ll;

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }

ll n, m, k;
vector<ll> a;
set<ll> st;	

int cnt = 1600;

double calcerr(double x){
	vector<double> dp(n + m + 1, 0);

	double tmp = m;
	double mm = (double) m;
	for(int i = n-1; i >= 0; i--){
		if(st.count(i) == 1){
			dp[i] = x;
		}else{
			dp[i] = 1.0 / mm * tmp;
		}

		tmp += dp[i]+1;
		tmp -= dp[i+m]+1;
	}

	return abs(dp[0] - x);
}

double sanbun(){
	double l = 0.0, r = 1e100;
	rep(i, cnt){
		double m1 = (2.0 * l + r) / 3.0, m2 = (l + 2.0 * r) / 3.0;
		double e1 = calcerr(m1), e2 = calcerr(m2);
		if(e1 > e2){
			l = m1;
		}else{
			r = m2;
		}
	}

	assert((r - l) < 1e-3);
	return l;
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);

	cin >> n >> m >> k;

	a.resize(k);
	rep(i, k) cin >> a[i];

	int cont = 0;
	int mx_cont = 0;
	rep(i, k){
		if(i == 0) cont++;
		else if(a[i] > a[i-1] + 1){
			cont = 1;
		}else{
			cont++;
		}
		chmax(mx_cont, cont);
	}
	
	if(mx_cont >= m){
		cout << -1 << endl;
		exit(0);
	}

	rep(i, k) st.insert(a[i]);
	cout << fixed << setprecision(10) << sanbun() << endl;

}
