#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+5;
const int mod=998244353;
ll a[maxn];

void solve(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    sort(a+1,a+n+1);
    ll sum=0,ans=0;
    for(int i=1;i<=n;i++)
    {
        ans=(ans+sum*a[i]+a[i]*a[i])%mod;
        sum=(sum*2+a[i])%mod;
        // cout<<sum<<'\n';
    }
    cout<<ans<<'\n';
}

int main()
{
    ios::sync_with_stdio(false);
    int t=1;
    // cin>>t;
    for(int i=1;i<=t;i++)
    {
        solve();
    }
    return 0;
}
// #include<iostream>
#include<bits/stdc++.h>
using namespace std;
long _mergeSort(long arr[], long temp[],  
                 long left, long right); 
long merge(long arr[], long temp[], long left,  
                   long mid, long right); 
  
/* This function sorts the  
   input array and returns the  
number of inversions in the array */
long mergeSort(long arr[], long array_size) 
{ 
    long temp[array_size]; 
    return _mergeSort(arr, temp, 0, array_size - 1); 
} 
  
/* An auxiliary recursive function  
  that sorts the input array and  
returns the number of inversions in the array. */
long _mergeSort(long arr[], long temp[],  
                 long left, long right) 
{ 
    long mid, inv_count = 0; 
    if (right > left) { 
        /* Divide the array longo two parts and  
        call _mergeSortAndCountInv()  
        for each of the parts */
        mid = (right + left) / 2; 
  
        /* Inversion count will be sum of  
        inversions in left-part, right-part  
        and number of inversions in merging */
        inv_count += _mergeSort(arr, temp,  
                                left, mid); 
        inv_count += _mergeSort(arr, temp,  
                             mid + 1, right); 
  
        /*Merge the two parts*/
        inv_count += merge(arr, temp, left,  
                           mid + 1, right); 
    } 
    return inv_count; 
} 
  
/* This funt merges two sorted arrays  
and returns inversion count in the arrays.*/
long merge(long arr[], long temp[], long left, 
          long mid, long right) 
{ 
    long i, j, k; 
    long inv_count = 0; 
  
    i = left; /* i is index for left subarray*/
    j = mid; /* j is index for right subarray*/
    k = left; /* k is index for resultant merged subarray*/
    while ((i <= mid - 1) && (j <= right)) { 
        if (arr[i] <= arr[j]) { 
            temp[k++] = arr[i++]; 
        } 
        else { 
            temp[k++] = arr[j++]; 
  
            /* this is tricky -- see above  
            explanation/diagram for merge()*/
            inv_count = inv_count + (mid - i); 
        } 
    } 
  
    /* Copy the remaining elements of left subarray  
(if there are any) to temp*/
    while (i <= mid - 1) 
        temp[k++] = arr[i++]; 
  
    /* Copy the remaining elements of right subarray  
(if there are any) to temp*/
    while (j <= right) 
        temp[k++] = arr[j++]; 
  
    /*Copy back the merged elements to original array*/
    for (i = left; i <= right; i++) 
        arr[i] = temp[i]; 
  
    return inv_count; 
} 
  
int main(){
    long n;
    cin>>n;
    long v[n];
    long a[n];
    long temp;
    for(long i=0;i<n;i++){
        cin>>temp;
        v[i]=temp;
        a[i]=temp;
    }
    long count=0;
    // for(long i=0;i<n;i++){
    count=mergeSort(v,n);
    cout<<count<<endl;
    for(long i=0;i<n-1;i++){
        count+=(n-a[i]-1);
        count-=(a[i]);
        cout<<count<<endl;
    }
    return 0;
}