// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



const int mod = 1e9 + 7;



int main()

{

  int N, A[100000] = {};



  cin >> N;

  for(int i = 0; i < N; i++) {

    int S;

    cin >> S;

    A[S]++;

  }



  long long ret = 1;

  if(N % 2 == 0) {

    int pe = 0;

    for(int i = 1; pe < N; pe += 2, i += 2) {

      if(A[i] != 2) {

        cout << 0 << endl;

        return (0);

      }

      (ret *= 2) %= mod;

    }

  } else {

    int pe = 1;

    if(A[0] != 1) {

      cout << 0 << endl;

      return (0);

    }

    for(int i = 2; pe < N; pe += 2, i += 2) {

      if(A[i] != 2) {

        cout << 0 << endl;

        return (0);

      }

      (ret *= 2) %= mod;

    }

  }



  cout << ret << endl;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>



using namespace std;



using int64 = long long;

const int mod = 1e9 + 7;

const int inf = (1 << 30) - 1;

const int64 infll = (1LL << 61) - 1;



struct IoSetup {

  IoSetup() {

    cin.tie(nullptr);

    ios::sync_with_stdio(false);

    cout << fixed << setprecision(10);

    cerr << fixed << setprecision(10);

  }

} iosetup;



template< typename T >

ostream &operator<<(ostream &os, const vector< T > &v) {

  for(int i = 0; i < (int) v.size(); i++) {

    os << v[i] << (i + 1 != v.size() ? " " : "");

  }

  return os;

}



template< typename T >

istream &operator>>(istream &is, vector< T > &v) {

  for(T &in : v) is >> in;

  return is;

}



template< typename T1, typename T2 >

inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }



template< typename T1, typename T2 >

inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }



template< typename T = int64 >

vector< T > make_v(size_t a) {

  return vector< T >(a);

}



template< typename T, typename... Ts >

auto make_v(size_t a, Ts... ts) {

  return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));

}



template< typename T, typename V >

typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {

  t = v;

}



template< typename T, typename V >

typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {

  for(auto &e : t) fill_v(e, v);

}





template< int mod >

struct ModInt {

  int x;



  ModInt() : x(0) {}



  ModInt(long long y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}



  ModInt &operator+=(const ModInt &p) {

    if((x += p.x) >= mod) x -= mod;

    return *this;

  }



  ModInt &operator-=(const ModInt &p) {

    if((x += mod - p.x) >= mod) x -= mod;

    return *this;

  }



  ModInt &operator*=(const ModInt &p) {

    x = (int) (1LL * x * p.x % mod);

    return *this;

  }



  ModInt &operator/=(const ModInt &p) {

    *this *= p.inverse();

    return *this;

  }



  ModInt operator-() const { return ModInt(-x); }



  ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }



  ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }



  ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }



  ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }



  bool operator==(const ModInt &p) const { return x == p.x; }



  bool operator!=(const ModInt &p) const { return x != p.x; }



  ModInt inverse() const {

    int a = x, b = mod, u = 1, v = 0, t;

    while(b > 0) {

      t = a / b;

      a -= t * b;

      swap(a, b);

      u -= t * v;

      swap(u, v);

    }

    return ModInt(u);

  }



  friend ostream &operator<<(ostream &os, const ModInt< mod > &p) {

    return os << p.x;

  }



  friend istream &operator>>(istream &is, ModInt< mod > &a) {

    long long x;

    is >> x;

    a = ModInt< mod >(x);

    return (is);

  }



};



using modint = ModInt< mod >;



int main() {

  int N;

  cin >> N;

  vector< int > A(N);

  cin >> A;

  sort(begin(A), end(A));



  modint ret = 1;

  if(N & 1) {

    if(A[0]) ret = 0;

    int v = 2;

    for(int i = 1; i < N; i += 2) {

      if(A[i] != A[i + 1]) ret = 0;

      if(v != A[i]) ret = 0;

      ret *= 2;

      v += 2;

    }

  } else {

    int v = 1;

    for(int i = 0; i + 1 < N; i += 2) {

      if(A[i] != A[i + 1]) ret = 0;

      if(v != A[i]) ret = 0;

      ret *= 2;

      v += 2;

    }

  }

  cout << ret << endl;

}








// Fastest known solution for this problem: