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 ) * } } ; }

// ref: https://github.com/kenkoooo/competitive-programming-rs/blob/master/src/math/mod_int.rs
// ref: https://cympfh.cc/procon/algebra.modint.html
#[allow(dead_code)]
#[derive (Debug, PartialEq, Eq, Clone, Copy)]
struct ModInt {
    value: i64,
    modulo: i64,
}

#[allow(dead_code)]
impl ModInt {
    fn new(mut value: i64, modulo: i64) -> Self {
        if value >= modulo {
            value %= modulo;
        } else if value <= 0 {
            value = (value % modulo + modulo) % modulo;
        }
        ModInt {
            value: value,
            modulo: modulo,
        }
    }

    fn inv(self) -> Self {
        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)
            }
        }
        let modulo = self.modulo;
        let (_, inv, _) = ext_gcd(self.value, modulo);
        ModInt{
            value: (inv + modulo) % modulo,
            modulo: modulo,
        }
    }

    fn pow(self, n: i64) -> Self {
        if n < 0 {
            self.pow(-n).inv()
        } else if n == 0 {
            ModInt{
                value: 1,
                modulo: self.modulo,
            }
        } else if n == 1 {
            self
        } else {
            let mut x = (self * self).pow(n / 2);
            if n % 2 == 1 {
                x *= self;
            }
            x
        }
    }

    fn factor(n: i64, modulo: i64) -> Self {
        let mut fact = ModInt::new(1_i64, modulo);
        for i in 1..=n {
            fact = fact * i;
        }
        fact
    }

    fn combination(n: i64, r: i64, modulo: i64) -> Self {
        if n < r {
            return ModInt::new(0, modulo);
        }
        let a1 = ModInt::factor(n, modulo);
        let a2 = ModInt::factor(r, modulo);
        let a3 = ModInt::factor(n - r, modulo);
        a1 / a2 / a3
    }
}

impl std::ops::Neg for ModInt {
    type Output = Self;
    fn neg(self) -> Self {
        if self.value == 0 {
            return self;
        } else {
            ModInt {
                value: self.modulo - self.value,
                modulo: self.modulo,
            }
        }
    }
}

impl std::ops::Add<i64> for ModInt {
    type Output = Self;
    fn add(self, rhs: i64) -> Self {
        ModInt::new(self.value + rhs, self.modulo)
    }
}

impl std::ops::Add<ModInt> for i64 {
    type Output = ModInt;
    fn add(self, rhs: ModInt) -> ModInt {
        rhs + self
    }
}

impl std::ops::Add for ModInt {
    type Output = Self;
    fn add(self, rhs: ModInt) -> Self {
        self + rhs.value
    }
}

impl std::ops::AddAssign<i64> for ModInt {
    fn add_assign(&mut self, rhs: i64) {
        self.value = ModInt::new(self.value + rhs, self.modulo).value;
    }
}

impl std::ops::AddAssign for ModInt {
    fn add_assign(&mut self, rhs: ModInt) {
        *self += rhs.value;
    }
}

impl std::ops::Sub<i64> for ModInt {
    type Output = Self;
    fn sub(self, rhs: i64) -> Self {
        ModInt::new(self.value - rhs, self.modulo)
    }
}

impl std::ops::Sub for ModInt {
    type Output = Self;
    fn sub(self, rhs: ModInt) -> Self {
        self - rhs.value
    }
}

impl std::ops::Sub<ModInt> for i64 {
    type Output = ModInt;
    fn sub(self, rhs: ModInt) -> ModInt {
        ModInt::new(self - rhs.value, rhs.modulo)
    }
}

impl std::ops::SubAssign<i64> for ModInt {
    fn sub_assign(&mut self, rhs: i64) {
        self.value = ModInt::new(self.value - rhs, self.modulo).value;
    }
}

impl std::ops::SubAssign for ModInt {
    fn sub_assign(&mut self, rhs: ModInt) {
        *self -= rhs.value;
    }
}

impl std::ops::Mul<i64> for ModInt {
    type Output = Self;
    fn mul(self, rhs: i64) -> Self {
        ModInt::new(self.value * rhs, self.modulo)
    }
}

impl std::ops::Mul for ModInt {
    type Output = Self;
    fn mul(self, rhs: ModInt) -> Self {
        self * rhs.value
    }
}

impl std::ops::Mul<ModInt> for i64 {
    type Output = ModInt;
    fn mul(self, rhs: ModInt) -> ModInt {
        rhs * self
    }
}

impl std::ops::MulAssign<i64> for ModInt {
    fn mul_assign(&mut self, rhs: i64) {
        self.value = ModInt::new(self.value * rhs, self.modulo).value;
    }
}

impl std::ops::MulAssign for ModInt {
    fn mul_assign(&mut self, rhs: ModInt) {
        *self *= rhs.value;
    }
}

impl std::ops::Div for ModInt {
    type Output = Self;
    fn div(self, rhs: ModInt) -> Self {
        self * rhs.inv()
    }
}

impl std::ops::Div<i64> for ModInt {
    type Output = Self;
    fn div(self, rhs: i64) -> Self {
        self / ModInt::new(rhs, self.modulo)
    }
}

impl std::ops::Div<ModInt> for i64 {
    type Output = ModInt;
    fn div(self, rhs: ModInt) -> ModInt {
        rhs.inv() * self
    }
}

impl std::ops::DivAssign for ModInt {
    fn div_assign(&mut self, rhs: ModInt) {
        self.value = (self.clone() / rhs).value;
    }
}

impl std::ops::DivAssign<i64> for ModInt {
    fn div_assign(&mut self, rhs: i64) {
        *self /= ModInt::new(rhs, self.modulo);
    }
}



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

    let modulo = 1_000_000_007;

    let mut ret = ModInt::new(0, modulo);
    for i in 0..n {
        ret += c[i] * (ModInt::new(i as i64, modulo) + 2);
    }
    ret *= ModInt::new(4, modulo).pow(n as i64 - 1);

    println!("{}", ret.value);
}