#include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>

using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;

using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000>>;

typedef uintmax_t    ull;
typedef intmax_t     ll;
typedef uint64_t     ul;
typedef uint32_t     ui;
typedef uint8_t      uc;

constexpr char CRLF  = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }

template<class T = int64_t>
struct Pow
{
public:
  /** Tは符号付き整数を指定すること */
  using p_int = T;

  /** mMemo[i] == UNCALCの時、未計算を意味する */
  const p_int UNCALC = p_int(-1);

  /** ダンピングするためのメモ帳 */
  vector<p_int> mMemo;

  /** 基数 */
  int mBase;

  /** modをとるので。 */
  int mMod;

  /**
   * @param base 基数
   * @param mod modを取る場合は明示する
   * @param inf 最大base^infまで計算可能
   */
  Pow(int base = 2, int mod = MOD, int inf = 1024)
  : mMemo(inf, Pow::UNCALC)
  , mBase(base)
  , mMod(mod)
  {}

  /**
   * N^xを計算する
   * @param x 乗数
   * @return N^x (% mod) の値
   */
  p_int operator()(int x) {
    if (x < 0) {
      throw std::runtime_error("負数はサポート外");
    }
    if (x >= (int)mMemo.size()) {
      throw std::runtime_error("乗数が大きすぎる");
    }
    return pRec(x);
  }

  /** 内部で使用する再帰関数 */
  p_int pRec(int x) {
    if (mMemo[x] != UNCALC) {
      return mMemo[x];
    }
    if (x == 0) {
      return mMemo[x] = 1;
    }
    else if (x == 1) {
      return mMemo[x] = mBase;
    }
    auto n = x >> 1;
    auto m = x & 0x01;

    p_int r{1};
    r *= pRec(n) * pRec(n);
    r %= mMod;
    r *= pRec(m);
    r %= mMod;

    return mMemo[x] = r;
  }
};

void solve(void)
{
  int N; cin >> N;
  vector<int> C(N);
  for (auto& c : C) {
    cin >> c;
  }
  boost::sort(C, std::greater<int>());

  ll res{};
  for (int i = 1; i <= N; ++i) {
    ll r = C[i-1];
    r *= (i + 1);
    r %= MOD;
    res += r;
    res %= MOD;
  }

  Pow<> p(4, MOD, N);
  auto ans = p(N-1);
  ans %= MOD;
  ans *= res;
  ans %= MOD;

  cout << ans << CRLF;
  return;
}

int main(void)
{
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);

  solve();

  return 0;
}


Measured memory_bytes: 2560