#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n) - 1; i >= 0; i--)

using namespace std;
using ll = long long;

constexpr int MOD = 1000000007;

class mint {
  int n;
public:
  mint(int n_ = 0) : n(n_) {}
  explicit operator int() { return n; }
  friend mint operator-(mint a) { return -a.n + MOD * (a.n != 0); }
  friend mint operator+(mint a, mint b) { int x = a.n + b.n; return x - (x >= MOD) * MOD; }
  friend mint operator-(mint a, mint b) { int x = a.n - b.n; return x + (x < 0) * MOD; }
  friend mint operator*(mint a, mint b) { return (long long)a.n * b.n % MOD; }
  friend mint &operator+=(mint &a, mint b) { return a = a + b; }
  friend mint &operator-=(mint &a, mint b) { return a = a - b; }
  friend mint &operator*=(mint &a, mint b) { return a = a * b; }
  friend bool operator==(mint a, mint b) { return a.n == b.n; }
  friend bool operator!=(mint a, mint b) { return a.n != b.n; }
  friend istream &operator>>(istream &i, mint &a) { return i >> a.n; }
  friend ostream &operator<<(ostream &o, mint a) { return o << a.n; }
};

template<int N>
class FFT {
  using C = complex<double>;
  C rots[N];

public:
  FFT() {
    const double pi = acos(-1);
    for (int i = 0; i < N / 2; i++) {
      rots[i + N / 2].real(cos(2 * pi / N * i));
      rots[i + N / 2].imag(sin(2 * pi / N * i));
    }
    for (int i = N / 2 - 1; i >= 1; i--) {
      rots[i] = rots[i * 2];
    }
  }

private:
  inline static C mul(C x, C y) {
    return C(x.real() * y.real() - x.imag() * y.imag(), x.real() * y.imag() + x.imag() * y.real());
  }

  void fft(vector<C> &a, bool rev) {
    const int n = a.size();
    int i = 0;
    for (int j = 1; j < n - 1; j++) {
      for (int k = n >> 1; k > (i ^= k); k >>= 1);
      if (j < i) swap(a[i], a[j]);
    }
    for (int i = 1; i < n; i *= 2) {
      for (int j = 0; j < n; j += i * 2) {
        for (int k = 0; k < i; k++) {
          C s = a[j + k + 0];
          C t = mul(a[j + k + i], rots[i + k]);
          a[j + k + 0] = s + t;
          a[j + k + i] = s - t;
        }
      }
    }
    if (rev) {
      reverse(a.begin() + 1, a.end());
      for (int i = 0; i < n; i++) {
        a[i] *= 1.0 / n;
      }
    }
  }

public:
  vector<long long> convolution(vector<long long> a, vector<long long> b) {
    int t = 1;
    while (t < a.size() + b.size() - 1) t *= 2;
    vector<C> z(t);
    for (int i = 0; i < a.size(); i++) z[i].real(a[i]);
    for (int i = 0; i < b.size(); i++) z[i].imag(b[i]);
    fft(z, false);
    vector<C> w(t);
    for (int i = 0; i < t; i++) {
      C p = (z[i] + conj(z[(t - i) % t])) * C(0.5, 0);
      C q = (z[i] - conj(z[(t - i) % t])) * C(0, -0.5);
      w[i] = p * q;
    }
    fft(w, true);
    vector<long long> ans(a.size() + b.size() - 1);
    for (int i = 0; i < ans.size(); i++) {
      ans[i] = round(w[i].real());
    }
    return ans;
  }

  vector<mint> convolution(vector<mint> a, vector<mint> b) {
    int t = 1;
    while (t < a.size() + b.size() - 1) t *= 2;
    vector<C> A(t), B(t);
    for (int i = 0; i < a.size(); i++) A[i] = C((int)a[i] & 0x7fff, (int)a[i] >> 15);
    for (int i = 0; i < b.size(); i++) B[i] = C((int)b[i] & 0x7fff, (int)b[i] >> 15);
    fft(A, false);
    fft(B, false);
    vector<C> X(t), Y(t);
    for (int i = 0; i < t; i++) {
      int j = (t - i) % t;
      C AL = (A[i] + conj(A[j])) * C(0.5, 0);
      C AH = (A[i] - conj(A[j])) * C(0, -0.5);
      C BL = (B[i] + conj(B[j])) * C(0.5, 0);
      C BH = (B[i] - conj(B[j])) * C(0, -0.5);
      X[i] = AL * BL + AH * BL * C(0, 1);
      Y[i] = AL * BH + AH * BH * C(0, 1);
    }
    fft(X, true);
    fft(Y, true);
    vector<mint> ans(a.size() + b.size() - 1);
    for (int i = 0; i < ans.size(); i++) {
      long long l = (long long)round(X[i].real()) % MOD;
      long long m = ((long long)round(X[i].imag()) + (long long)round(Y[i].real())) % MOD;
      long long h = (long long)round(Y[i].imag()) % MOD;
      ans[i] = (l + (m << 15) + (h << 30)) % MOD;
    }
    return ans;
  }
};

mint modinv(mint n) {
  int a = (int)n;
  int b = MOD;
  int s = 1;
  int t = 0;
  while (b != 0) {
    int q = a / b;
    a -= q * b;
    s -= q * t;
    swap(a, b);
    swap(s, t);
  }
  if (s < 0) s += MOD;
  return s;
}

mint modpow(mint a, long long b) {
  mint res = 1;
  while (b > 0) {
    if (b & 1) res *= a;
    a *= a;
    b >>= 1;
  }
  return res;
}


FFT<1 << 21> fft;

int main() {
  int n;
  cin >> n;
  vector<ll> f(1<<18);
  vector<int> a(n);
  rep(i, n) cin >> a[i], f[a[i]]++;
  f = fft.convolution(f, f);
  rep(i, n) f[2*a[i]]--;
  mint ans = 1;
  rep(i, 1 << 18) ans *= modpow(i, f[i] / 2);
  ll s = 0;
  rep(i, n) s += a[i];
  rep(i, n) {
    s -= a[i];
    ans *= modpow(a[i], s);
  }
  sort(a.begin(), a.end());
  if (a[1] * log(a[0]) < a[0] * log(a[1])) {
    ans *= modinv((a[0] + a[1]) * modpow(a[0], a[1]));
  } else {
    ans *= modinv((a[0] + a[1]) * modpow(a[1], a[0]));
  }
  cout << ans << endl;
}