#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}

constexpr ll mod=998244353;

ll mod_pow(ll a,ll b){
    a%=mod;
    if(b==0)return 1;
    if(b==1)return a;
    ll res=mod_pow(a,b/2)%mod;
    res*=res; res%=mod;
    if(b%2)res*=a;
    return res%mod;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n; cin >> n;
    vector<ll> a(n);
    ll sum=0;
    ll po=1;
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    sort(a.begin(), a.end());
    for(int i=1;i<n;i++){
        (sum+=po*a[i]%mod)%=mod;
        po*=2; po%=mod;
    }
    ll res=0;
    for(int i=0;i+1<n;i++){
        (res+=a[i]*sum%mod)%=mod;
        // cout << res << " " << sum << endl;
        sum-=a[i+1];
        sum*=mod_pow(2,mod-2);
        sum%=mod;
    }
    for(int i=0;i<n;i++){
        (res+=a[i]*a[i])%=mod;
    }
    if(res<0)res+=mod;
    cout << res << endl;
}

#include<iostream>
#include <vector>
#include <algorithm>
#include <utility>
#define NO_MOD 998244353
using namespace std;
using ll = long long;

using ll = long long;
struct matrix{
    long long a,b,c,d;
    matrix operator*(matrix);
    matrix(ll,ll,ll,ll);
};
template<ll MOD= 1000000007>
struct modint{
    ll value;
    modint();
    modint(ll);
    modint operator+(modint);
    modint operator*(modint);
    modint operator-(modint);
    modint operator/(modint);/*gcd(value,MOD)==1であることは保証されているものとする*/
    modint inv();/*gcd(value,MOD)==1であることは保証されているものとする*/

};
std::pair<ll,ll> Bezout(ll,ll);
ll inv_mod(ll,ll);
template<ll MOD>
modint<MOD> pow(modint<MOD>,ll);



int main(){
    int n;
    cin >> n;
    vector<modint<NO_MOD>> a(n);
   vector<modint<NO_MOD>>  b(n);
    for(int i = 0;i < n;i++){
        cin >> a[i].value;
    }
    sort(a.begin(),a.end(),[](modint<NO_MOD> a,modint<NO_MOD> b){return a.value < b.value;});
    for(int i = 0;i < n;i++){
    b[i] = a[i];
        a[i] = (pow(modint<NO_MOD>(2),i)) * a[i];
    }
    
    vector<modint<NO_MOD>> ruiseki(n+1);
    for(int i = 0;i < n;i++){
        ruiseki[i+1] = ruiseki[i] + a[i];
    }
    modint<NO_MOD> ans(0);
    for(int i = 0;i < n-1;i++){
        ans = ans + (b[i] * (ruiseki[n] - ruiseki[i+1])/pow(modint<NO_MOD>(2),i+1));
    }
    for(int i = 0;i < n;i++){
        ans =ans + b[i] * b[i];
    }
    cout << ans.value << endl;
    
    return 0;
}

template<ll MOD>
modint<MOD> pow(modint<MOD> a,ll b){
    if(b == 0){
        return modint<MOD>(1);
    }
    if(b%2 == 0){
        return pow((a*a),b/2);
    }
    return pow(a,b-1) * a;
}

matrix matrix::operator*(matrix r){
    return matrix(a*r.a+b*r.c,a*r.b+b*r.d,c*r.a+d*r.c,c*r.b+d*r.d);
}
matrix::matrix(ll x,ll y,ll z,ll w):a(x),b(y),c(z),d(w){}

std::pair<ll,ll> Bezout(ll a,ll b){
    struct{
        matrix operator()(ll a,ll b){
            if(b == 0){
                return matrix(1,0,0,1);
            }
            return operator()(b,a%b) * matrix(0,1,1,-1*(a/b));
        }
    } Euclid;
    matrix ans = Euclid(a,b);
    return std::pair<ll,ll>(ans.a,ans.b);
}


template<ll MOD>
modint<MOD>::modint(ll a){
    value = a%MOD;
    if(value < 0){
        value+=MOD;
    }
}
template<ll MOD>
modint<MOD>::modint(){
    value = 0;
}
template<ll MOD>
modint<MOD> modint<MOD>::operator+(modint<MOD> r){
    return modint(value + r.value);
}
template<ll MOD>
modint<MOD> modint<MOD>::operator*(modint<MOD> r){
    return modint(value * r.value);
}
template<ll MOD>
modint<MOD> modint<MOD>::operator-(modint<MOD> r){
    return modint(value - r.value);
}
template<ll MOD>
modint<MOD> modint<MOD>::operator/(modint<MOD> r){
    return modint(value * r.inv().value);
}
template<ll MOD>
modint<MOD> modint<MOD>::inv(){
    return modint(Bezout(value,MOD).first);
}
ll inv_mod(ll a,ll mod){
    return Bezout(a,mod).first;
}

