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

using ll = long long;
const ll MOD = 998244353;

inline ll add(ll a, ll b) {
    a += b;
    if (a >= MOD) a -= MOD;
    return a;
}

inline ll mul(ll a, ll b) {
    return (a * b) % MOD;
}

struct Affine {
    ll a, b;
    Affine(ll a = 1, ll b = 0) : a(a), b(b) {}
    Affine combine(const Affine &x) const {
        return Affine(mul(a, x.a), add(mul(a, x.b), b));
    }
};

struct SegTree {
    int n;
    vector<ll> len, tree;
    vector<Affine> lazy;

    SegTree(const vector<ll> &lengths) {
        n = (int)lengths.size();
        len = lengths;
        tree.assign(4 * n, 0);
        lazy.assign(4 * n, Affine());
    }

    void apply(int i, const Affine &f) {
        tree[i] = add(mul(tree[i], f.a), mul(f.b, len[i]));
        lazy[i] = lazy[i].combine(f);
    }

    void push(int i, int l, int r) {
        if (lazy[i].a == 1 && lazy[i].b == 0) return;
        int m = (l + r) / 2;
        apply(i * 2, lazy[i]);
        apply(i * 2 + 1, lazy[i]);
        lazy[i] = Affine();
    }

    void pull(int i) {
        tree[i] = add(tree[i * 2], tree[i * 2 + 1]);
    }

    void build(int i, int l, int r, const vector<ll> &init) {
        if (l == r) {
            tree[i] = mul(init[l], len[l]);
            return;
        }
        int m = (l + r) / 2;
        build(i * 2, l, m, init);
        build(i * 2 + 1, m + 1, r, init);
        pull(i);
    }

    void update(int i, int l, int r, int ql, int qr, const Affine &f) {
        if (qr < l || r < ql) return;
        if (ql <= l && r <= qr) {
            apply(i, f);
            return;
        }
        push(i, l, r);
        int m = (l + r) / 2;
        update(i * 2, l, m, ql, qr, f);
        update(i * 2 + 1, m + 1, r, ql, qr, f);
        pull(i);
    }

    ll query(int i, int l, int r, int ql, int qr) {
        if (qr < l || r < ql) return 0;
        if (ql <= l && r <= qr) return tree[i];
        push(i, l, r);
        int m = (l + r) / 2;
        return add(query(i * 2, l, m, ql, qr), query(i * 2 + 1, m + 1, r, ql, qr));
    }

    void build(const vector<ll> &init) {
        build(1, 0, n - 1, init);
    }

    void update(int l, int r, const Affine &f) {
        update(1, 0, n - 1, l, r, f);
    }

    ll query(int l, int r) {
        return query(1, 0, n - 1, l, r);
    }
};

struct CoordComp {
    vector<ll> v;
    void add(ll x) { v.push_back(x); }
    void build() {
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
    }
    int get(ll x) {
        return (int)(lower_bound(v.begin(), v.end(), x) - v.begin());
    }
    int size() { return (int)v.size(); }
};

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

    int n; cin >> n;
    vector<ll> arr(n);
    for (int i = 0; i < n; i++) cin >> arr[i];

    CoordComp cc;
    for (auto x : arr) cc.add(x);
    cc.build();

    vector<ll> lens(cc.size() - 1);
    for (int i = 0; i + 1 < cc.size(); i++) {
        lens[i] = (cc.v[i + 1] - cc.v[i]) % MOD;
    }

    vector<ll> init(lens.size(), 0);
    SegTree seg(lens);
    seg.build(init);

    // Example usage:
    // apply f(x) = 2*x + 3 on range [0, lens.size()-1]
    seg.update(0, (int)lens.size() - 1, Affine(2, 3));
    cout << seg.query(0, (int)lens.size() - 1) << "\n";

    return 0;
} input 3 1 1 1  what is out they give me