Problem:
Score : 500 points

Problem Statement

For two sequences S and T of length N consisting of 0 and 1, let us define f(S, T) as follows:

Consider repeating the following operation on S so that S will be equal to T. f(S, T) is the minimum possible total cost of those operations.

Change S_i (from 0 to 1 or vice versa). The cost of this operation is D \times C_i, where D is the number of integers j such that S_j \neq T_j (1 \leq j \leq N) just before this change.

There are 2^N \times (2^N - 1) pairs (S, T) of different sequences of length N consisting of 0 and 1. Compute the sum of f(S, T) over all of those pairs, modulo (10^9+7).

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq C_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
C_1 C_2 \cdots C_N

Output

Print the sum of f(S, T), modulo (10^9+7).

Sample Input 1

1
1000000000

Sample Output 1

999999993

There are two pairs (S, T) of different sequences of length 2 consisting of 0 and 1, as follows:

S = (0), T = (1): by changing S_1 to 1, we can have S = T at the cost of 1000000000, so f(S, T) = 1000000000.

S = (1), T = (0): by changing S_1 to 0, we can have S = T at the cost of 1000000000, so f(S, T) = 1000000000.

The sum of these is 2000000000, and we should print it modulo (10^9+7), that is, 999999993.

Sample Input 2

2
5 8

Sample Output 2

124

There are 12 pairs (S, T) of different sequences of length 3 consisting of 0 and 1, which include:

S = (0, 1), T = (1, 0)

In this case, if we first change S_1 to 1 then change S_2 to 0, the total cost is 5 \times 2 + 8 = 18. We cannot have S = T at a smaller cost, so f(S, T) = 18.

Sample Input 3

5
52 67 72 25 79

Sample Output 3

269312

Solution in C (GCC 5.4.1) (judge verdict: Accepted)

#include<stdio.h>
#include<stdlib.h>
#define MOD 1000000007
#define Reg register

#pragma GCC optimize ("O3")
#pragma GCC target ("avx")

int lc(const void *a,const void *b){
    if(*(long*)a - *(long*)b){
        return  *(long*)a < *(long*)b?-1:1;
    }
    return 0;
}

static inline long mdml(long a,long b){
    Reg long long res = (long long)a * b;
    return res % MOD;
}

static inline long mdpow(long num,long ind){
    Reg unsigned long ibit = (unsigned long)ind;
    Reg long res = 1;
    while(ibit){
        if(1lu & ibit)res = mdml(res,num);
        num = mdml(num,num);
        ibit >>= 1;
    }
    return res;
}

static inline long mdadd(long a,long b){
    return (a + b) % MOD;
}

int main(void){
    int n;
    scanf("%d",&n);
    long c[n];
    for(Reg int i = 0;i < n;i++)scanf("%ld",&c[i]);
    qsort(c,n,sizeof(long),lc);
    Reg long ans = 0;
    long tmppow = mdpow(2l,n);
    Reg long tmp2inv = mdpow(2l,MOD-2l);
    Reg long t2n = mdml(tmppow,tmp2inv);
    Reg long t4n = mdml(tmppow,mdml(tmp2inv,tmp2inv));
    Reg int tmpn = n - 1;
    for(Reg int i= 0;i < n;i++)ans = mdadd(ans,mdml(c[i],mdadd(t2n,mdml(t4n,tmpn-i))));
    ans = mdml(ans,tmppow);
    printf("%ld",ans);
}