#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
const double PI = acos(-1);
const ll MOD = 1000000007;
// const ll MOD = 998244353;
template<class T>
inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return true;
    }
    return false;
}
 
template<class T>
inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return true;
    }
    return false;
}
///////////////////////////////////////////////////////////////

template <std::uint_fast64_t Modulus> class modint {
  using u64 = std::uint_fast64_t;

public:
  u64 a;

  constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
  constexpr u64 &value() noexcept { return a; }
  constexpr const u64 &value() const noexcept { return a; }
  constexpr modint operator+(const modint rhs) const noexcept {
    return modint(*this) += rhs;
  }
  constexpr modint operator-(const modint rhs) const noexcept {
    return modint(*this) -= rhs;
  }
  constexpr modint operator*(const modint rhs) const noexcept {
    return modint(*this) *= rhs;
  }
  constexpr modint operator/(const modint rhs) const noexcept {
    return modint(*this) /= rhs;
  }
  constexpr modint &operator+=(const modint rhs) noexcept {
    a += rhs.a;
    if (a >= Modulus) {
      a -= Modulus;
    }
    return *this;
  }
  constexpr modint &operator-=(const modint rhs) noexcept {
    if (a < rhs.a) {
      a += Modulus;
    }
    a -= rhs.a;
    return *this;
  }
  constexpr modint &operator*=(const modint rhs) noexcept {
    a = a * rhs.a % Modulus;
    return *this;
  }
  constexpr modint &operator/=(modint rhs) noexcept {
    u64 exp = Modulus - 2;
    while (exp) {
      if (exp % 2) {
        *this *= rhs;
      }
      rhs *= rhs;
      exp /= 2;
    }
    return *this;
  }
};

using mint = modint<MOD>;

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int N; cin >> N;
    vector<ll> x(N);
    rep(i,N) cin >> x[i];

    vector<mint> modfac(N,1);
    rep(i,N-1) modfac[i+1] = modfac[i]*(i+1);
    /*
    vector<vector<mint>> dp(N, vector<mint>(N+1,0));

    dp[1][2] = 1;
    for (ll i = 2; i < N; i++) {
        for (ll j = 2; j <= i+1; j++) {
            if (j == i+1) dp[i][j] = dp[i-1][j-1]*(j-1LL) + modfac[i-1];
            else dp[i][j] = dp[i-1][j-1]*(j-1LL) + dp[i-1][j]*(i-j) + modfac[i-1];
        }
    }
    mint ans = 0;
    for (int i = 1; i <= N; i++) ans += dp[N-1][i]*x[i-1];
    rep(i,N-1) ans -= modfac[N-1]*x[i];

    for (int i = 2;i <= N; i++) cout << dp[N-1][i].a << endl;
    //cout << ans.a << endl; 
    */
   vector<mint> dp(N+1,0);
   dp[2] = 1;
   for(int i = 3; i <= N; i++) {
       dp[i] = dp[i-1]*(i-1LL) + modfac[i-2];
       dp[i-1] = dp[i-2]*(i-1LL) + modfac[i-3];
   }
   for (int i = 2; i <= N-2; i++) {
       dp[i] = dp[i]*modfac[N-1]/modfac[i];
   }

   mint ans = 0;
    for (int i = 1; i <= N; i++) ans += dp[i]*x[i-1];
    rep(i,N-1) ans -= modfac[N-1]*x[i];

    //for (int i = 2;i <= N; i++) cout << dp[N-1][i].a << endl;
    cout << ans.a << endl;

   //for (int i = 2;i <= N; i++) cout << dp[i].a << endl;
}

Measured memory_bytes: 2560