#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <set>

/* MACROS START */
#define input std::cin
#define for2(i,n) for(int i=0; i<n; i++)
#define for3(i,a,n) for(int i=a; i<n; i++)
#define for4(i,a,n,s) for(int i=a; i<n; i+=s)

using lint = long long int;
using namespace std;

template <typename T>
void printvec(T vec) {
  for (auto& a: vec)
	cout << a << " ";
  cout << endl;
}
/* MACROS END */

/* LIBRARY START */
/* LIBRARY END */

struct Expectation {
  double exact = 0, variable = 0;

  Expectation& operator+=(const Expectation& other) {
	this->exact += other.exact;
	this->variable += other.variable;
	return *this;
  }

  Expectation& operator-=(const Expectation& other) {
	this->exact -= other.exact;
	this->variable -= other.variable;
	return *this;
  }
};

Expectation operator/(const Expectation& e, double d) {
  return {e.exact/d, e.variable/d};
}

Expectation operator+(const Expectation& e, int d) {
  return {e.exact+d, e.variable};
}

int main() {
  std::ios_base::sync_with_stdio(0);
  int n, m, k; input >> n >> m >> k;
  set<int> traps;
  for2(i, k) {
	int tr; input >> tr;
	traps.insert(tr);
  }
  queue<Expectation> runsum;
  for2(i, m) {
	runsum.push({0, 0});
  }
  Expectation sum = {0, 0};
  for(int i=n-1; i>0; i--) {
	if (traps.count(i)) {
	  runsum.push({0, 1});
	} else {
	  runsum.push((sum + m) / m);
	}
	sum -= runsum.front(); runsum.pop();
	sum += runsum.back();
  }
  Expectation exp = (sum + m) / m;
  if (exp.variable >= 0.999999)
	std::cout << -1 << std::endl;
  else {
	double ans = exp.exact / (1.0 - exp.variable);
	std::cout << std::fixed << ans << std::endl;
  }
}


#include<bits/stdc++.h> // 76 87
using namespace std;

#define rep(x, k, n)    for(int x = (k); x < (n); ++x)
#define repr(x, k, n)   for(int x = (k); x > (n); --x)
#define tr(it,a)        for(auto it = (a).begin(); it != (a).end(); ++it)
#define ll              long long
#define siz(x)          ((int)(x).size())
#define print(x)        cout << (x) << '\n'
#define prints(x)       cout << (x) << " "
#define eb              emplace_back
#define mp              make_pair
#define F               first
#define S               second
#define o2(x)           ( (x) * (x) )
#define all(x)          (x).begin(), (x).end()
#define allr(x)         (x).rbegin(), (x).rend()
#define clr(x,k)        memset(x, k, sizeof(x))
#define sortall(x)      sort(all(x))
#define sortalld(x)     sort(all(x), greater<int>())
#define printv(v)       rep(x, 0, siz(v)){ prints(v[x]); } cout << '\n'
#define print2dv(V)     rep(y, 0, siz(V)){ printv(V[y]); }
#define out(x)          cout << ((x) ? "Yes" : "No") << '\n';
#define PI              3.1415926535897932384626
#define inf             INT_MAX
#define ninf            INT_MIN
#define int             long long // take care of it when too much computation required

typedef pair<int,int>   pii;
typedef pair<ll,ll>     pll;
typedef vector<int>     vi;
typedef vector<ll>      vl;
typedef vector<char>    vc;
typedef vector<bool>    vb;
typedef vector<pii>     vpii;
typedef vector<pll>     vpll;
typedef vector<vi>      vvi;
typedef vector<vl>      vvl;
typedef vector<vc>      vvc;
typedef vector<vb>      vvb;
typedef vector<vpii>    vvpii;

template <typename Arg1>
void debug_out(const char* name, Arg1&& arg1){
    cout << name << " = " << arg1  << " ]" << '\n';
}
template <typename Arg1, typename... Args>
void debug_out(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " = " << arg1 <<",";
    debug_out(comma+1, args...);
}

#ifndef ONLINE_JUDGE
#define deb(...) cout << "[ ", debug_out(#__VA_ARGS__, __VA_ARGS__)
#else
#define deb(...)
#endif

mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());

const int mod = 1e9+7;
const int N = 3e5, M = N;

/* 
->Do not forget to check the edge cases. 
->Make sure you are submitting the right file.
->Do not make "easy->complicated".
*/
/*
    -> 1, 2, 3, 3, 4, 5
    -> 1 + 2 + 3 : (n * (n + 1)) / 2 = 6
    -> 3 + 4 + 5 : (5 * 6)/2 - (2 * 3)/2 = 

*/
//-----------------------------------------------------------------------------

void Solve_main() {
    int n, m, k;

    cin >> n;
    int l, r, res = 0;
    rep(i, 0, n){
        cin >> l >> r;
        res += (r * (r + 1))/2;
        res -= (l * (l - 1))/2;

    }
    cout << res << '\n';
}

//-----------------------------------------------------------------------------

int32_t main() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());

    // cout << setprecision(12) << fixed;
    int tc = 1;
    // cin >> tc;
    for(int i = 0; i < tc; i++) {
        Solve_main();
    }

    cerr << "[time:" << 1.0*clock()/CLOCKS_PER_SEC << "s] ";
    return 0;
}