#include <bits/stdc++.h>
using ll = long long;
using namespace std;

const int inf = 1e9;
const ll linf = 1e18;

template <ll _Mod> class modint;
template <ll _Mod> modint<_Mod> inv(const modint<_Mod> &);
template <ll _Mod> modint<_Mod> pow(const modint<_Mod> &, const ll);

template <ll _Mod>
class modint
{
public:
    constexpr modint(ll _v = 0LL) noexcept : _val(_v >= 0 ? _v % _Mod : (_v % _Mod) + _Mod) {}
    constexpr ll value() const noexcept { return _val; }

    modint &operator+=(const modint &rhs) {
        if ((_val += rhs._val) >= _Mod) _val -= _Mod;
        return *this;
    }
    modint &operator-=(const modint &rhs) {
        if ((_val += _Mod - rhs._val) >= _Mod) _val -= _Mod;
        return *this;
    }
    modint &operator*=(const modint &rhs) {
        (_val *= rhs._val) %= _Mod;
        return *this;
    }
    modint &operator/=(const modint &rhs) {
        _val = _val * inv(rhs) % _Mod;
        return *this;
    }

    friend ostream &operator<<(ostream &os, const modint &m) {
        os << m._val;
        return os;
    }

    friend istream &operator>>(istream &is, modint &m) {
        ll in;
        is >> in;
        m = modint(in);
        return is;
    }

private:
    ll _val;
};

template <ll _Mod>
inline modint<_Mod> operator+(const modint<_Mod> &m1, const modint<_Mod> &m2) { return modint<_Mod>(m1) += m2; }
template <ll _Mod>
inline modint<_Mod> operator-(const modint<_Mod> &m1, const modint<_Mod> &m2) { return modint<_Mod>(m1) -= m2; }
template <ll _Mod>
inline modint<_Mod> operator*(const modint<_Mod> &m1, const modint<_Mod> &m2) { return modint<_Mod>(m1) *= m2; }
template <ll _Mod>
inline modint<_Mod> operator/(const modint<_Mod> &m1, const modint<_Mod> &m2) { return modint<_Mod>(m1) /= m2; }

template <ll _Mod>
inline modint<_Mod> operator+(const modint<_Mod> &m) { return m; }
template <ll _Mod>
inline modint<_Mod> operator-(const modint<_Mod> &m) { return modint<_Mod>(-m.value()); }

template <ll _Mod>
inline constexpr bool operator==(const modint<_Mod> &m1, const modint<_Mod> &m2) { return m1.value() == m2.value(); }
template <ll _Mod>
inline constexpr bool operator!=(const modint<_Mod> &m1, const modint<_Mod> &m2) { return m1.value() != m2.value(); }

template <ll _Mod>
modint<_Mod> inv(const modint<_Mod> &_m) {
    ll _a = _m.value(), _b = _Mod, _x = 1LL, _y = 0LL;
    while (_b > 0) {
        ll _tmp = _a / _b;
        _a -= _tmp * _b; swap(_a, _b);
        _x -= _tmp * _y; swap(_x, _y);
    }
    return modint<_Mod>(_x);
}

template <ll _Mod>
modint<_Mod> pow(const modint<_Mod> &m, ll n) {
    modint<_Mod> e = m, res = modint<_Mod>(1LL);
    while (n) {
        if (n & 1) res *= e;
        e *= e, n >>= 1;
    }
    return res;
}

using mint = modint<1000000007>;

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

    int n; cin >> n;
    vector<ll> x(n);
    for (int i = 0; i < n; i++) cin >> x[i];
 
    mint ans = 0;
    
    for (int i = 1; i <= n - 1; i++) {
        static mint prob = 1;
        ans += (mint)(x[i] - x[i-1]) * prob;
        prob += inv(mint(i + 1));
    }
 
    mint fact = 1;
    for (int i = 2; i <= n - 1; i++) fact *= mint(i);
 
    ans *= fact;
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 1024