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 Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules ! read_value {($ next : expr , ($ ($ t : tt ) ,* ) ) => {($ (read_value ! ($ next , $ t ) ) ,* ) } ; ($ next : expr , [$ t : tt ; $ len : expr ] ) => {(0 ..$ len ) . map (| _ | read_value ! ($ next , $ t ) ) . collect ::< Vec < _ >> () } ; ($ next : expr , chars ) => {read_value ! ($ next , String ) . chars () . collect ::< Vec < char >> () } ; ($ next : expr , usize1 ) => {read_value ! ($ next , usize ) - 1 } ; ($ next : expr , $ t : ty ) => {$ next () . parse ::<$ t > () . expect ("Parse error" ) } ; }
#[allow(unused_macros)]
macro_rules ! input_inner {($ next : expr ) => {} ; ($ next : expr , ) => {} ; ($ next : expr , $ var : ident : $ t : tt $ ($ r : tt ) * ) => {let $ var = read_value ! ($ next , $ t ) ; input_inner ! {$ next $ ($ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! input {(source = $ s : expr , $ ($ r : tt ) * ) => {let mut iter = $ s . split_whitespace () ; let mut next = || {iter . next () . unwrap () } ; input_inner ! {next , $ ($ r ) * } } ; ($ ($ r : tt ) * ) => {let stdin = std :: io :: stdin () ; let mut bytes = std :: io :: Read :: bytes (std :: io :: BufReader :: new (stdin . lock () ) ) ; let mut next = move || -> String {bytes . by_ref () . map (| r | r . unwrap () as char ) . skip_while (| c | c . is_whitespace () ) . take_while (| c |! c . is_whitespace () ) . collect () } ; input_inner ! {next , $ ($ r ) * } } ; }

#[allow(dead_code)]
fn ext_gcd(a: i64, b: i64) -> (i64, i64, i64) {
    if b == 0 {
        (a, 1, 0)
    } else {
        let (g, x, y) = ext_gcd(b, a % b);
        (g, y, x - (a / b) * y)
    }
}
#[allow(dead_code)]
fn mod_inverse(n: u64, modulo: u64) -> u64 {
    let (_, inv, _) = ext_gcd(n as i64, modulo as i64);
    ((inv + modulo as i64) as u64 % modulo) % modulo
}
#[allow(dead_code)]
fn mod_factor(n: u64, modulo: u64) -> u64 {
    let mut fact = 1;
    for i in 1..=n {
        fact = fact * i % modulo;
    }
    fact
}
#[allow(dead_code)]
fn mod_combination(n: u64, r: u64, modulo: u64) -> u64 {
    if n < r {
        return 0;
    }
    let a1 = mod_factor(n, modulo);
    dbg!(a1);
    let a2 = mod_factor(r, modulo);
    let a3 = mod_factor(n - r, modulo);
    a1 * mod_inverse(a2 * a3 % modulo, modulo) % modulo
}

fn main() {
    input! {
        n: usize,
        c_: [u64; n],
    }
    let mut c = c_.clone();
    c.sort();
    c.reverse();

    let modulo = 1_000_000_007;

    let mut pow4 = vec![1u64; n];
    for i in 1..n {
        pow4[i] = pow4[i - 1] * 4 % modulo;
    }

    let mut dp = vec![0u64; n + 1];
    for i in 0..n {
       dp[i + 1] = 4 * dp[i] % modulo + ((i as u64 + 2) * pow4[i] % modulo) * c[i] % modulo;
       dp[i + 1] %= modulo;
    }
    println!("{}", dp[n]);

    // let mut ret = 0;
    // for i in 0..n {
    //     ret = (ret + c[i] * (i as u64 + 2) % modulo) % modulo;
    // }
    // for _ in 0..n-1 {
    //     ret = ret * 4 % modulo;
    // }
    // println!("{}", ret)
}