#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <limits.h>
#include <utility>

#define YesNo(b) ((b) ? "Yes" : "No")
#define YESNO(b) ((b) ? "YES" : "NO")

using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;


constexpr uint_fast64_t MOD = 1e9 + 7;

template<class StoreT, class AddT, class MulT, StoreT MOD>
class ModInt
{
    using self_type = ModInt<StoreT, AddT, MulT, MOD>;
    StoreT i;

public:
    ModInt()
        : i(0)
    {}
    ModInt(StoreT i)
    {
        while (i < 0) i += MOD;
        this->i = i;
    }

    ModInt(const self_type& i)
        : i(i.i)
    {}

    constexpr uint_fast32_t getI() const noexcept
    {
        return i;
    }

    ModInt& operator +=(self_type rhs)
    {
        AddT i64 = static_cast<AddT>(i);
        StoreT a32 = static_cast<StoreT>((i64 + rhs.i) % MOD);
        i = a32;
        return *this;
    }

    constexpr ModInt operator +(self_type rhs) const noexcept
    {
        self_type newInt(*this);
        newInt += rhs;
        return newInt;
    }

    ModInt& operator -=(self_type rhs)
    {
        AddT i64 = static_cast<AddT>(i);
        StoreT a32 = static_cast<StoreT>((i64 + MOD - rhs.i) % MOD);
        i = a32;
        return *this;
    }

    constexpr ModInt operator -(self_type rhs) const noexcept
    {
        self_type newInt(*this);
        newInt -= rhs;
        return newInt;
    }

    ModInt& operator *=(self_type rhs)
    {
        MulT i64 = static_cast<MulT>(i);
        StoreT a32 = static_cast<StoreT>((i64 * rhs.i) % MOD);
        i = a32;
        return *this;
    }

    constexpr ModInt operator *(self_type rhs) const noexcept
    {
        self_type newInt(*this);
        newInt *= rhs;
        return newInt;
    }

    constexpr ModInt operator /(self_type rhs) const noexcept
    {
        self_type newInt(*this);
        self_type rhsInv = rhs.inv();
        newInt *= rhsInv;
        return newInt;
    }

    constexpr bool operator ==(self_type rhs) const noexcept
    {
        return i == rhs.i;
    }

    constexpr bool operator <(self_type rhs) const noexcept
    {
        return i < rhs.i;
    }

    constexpr bool operator >(self_type rhs) const noexcept
    {
        return rhs < *this;
    }

    constexpr ModInt pow(int n) const noexcept
    {
        ModInt a = *this;
        ModInt res = 1;

        while (n > 0)
        {
            if (n & 1)
            {
                res *= a;
            }
            a *= a;
            n >>= 1;
        }
        return res;
    }

    constexpr self_type inv() const noexcept
    {
        return pow(MOD - 2);
    }
};

template<class StoreT, class AddT, class MulT, StoreT MOD>
std::ostream& operator <<(std::ostream& ost, ModInt<StoreT, AddT, MulT, MOD> i)
{
    ost << i.getI();
    return ost;
}

using UModInt = ModInt<uint_fast32_t, uint_fast32_t, uint_fast64_t, MOD>;
using SModInt = ModInt<int_fast32_t, int_fast32_t, int_fast64_t, MOD>;


template<class ModIntT>
class BinomialFactory
{
    std::vector<ModIntT> stock;
    std::vector<ModIntT> inv;

public:
    explicit BinomialFactory(int N)
    {
        stock.resize(N + 1);
        inv.resize(N + 1);
        stock[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= N; i++)
        {
            stock[i] = stock[i - 1] * i;
            inv[i] = stock[i].inv();
        }
    }

    ModIntT bi(int n, int r) const
    {
        if (r == 0 || r == n) return 1;

        return stock[n] * inv[n - r] * inv[r];
    }
};

UModInt f(const vi &C)
{
    UModInt ans = 0;
    UModInt pn = 2;
    pn = pn.pow(2 * C.size() - 2);
    for (size_t i = 0; i < C.size(); i++)
    {
        ans += UModInt(C[i]) * (i + 2);
    }
    ans *= pn;
    return ans;
}

int main()
{
	int N;
	cin >> N;
	vi C(N);
	for (int i = 0; i < N; i++)
		cin >> C[i];

    sort(begin(C), end(C), std::greater<int>());

	auto ans = f(C);
	cout << ans << endl;
}

Measured memory_bytes: 1024