Problem: To defeat Lord Voldemort, Harry needs to destroy all horcruxes first. The last horcrux is an array a of n integers, which also needs to be destroyed. The array is considered destroyed if all its elements are zeroes. To destroy the array, Harry can perform two types of operations:

  1. choose an index i (1 ≤ i ≤ n), an integer x, and subtract x from a_i.
  2. choose two indices i and j (1 ≤ i, j ≤ n; i ≠ j), an integer x, and subtract x from a_i and x + 1 from a_j. 



Note that x does not have to be positive.

<image>

Harry is in a hurry, please help him to find the minimum number of operations required to destroy the array and exterminate Lord Voldemort.

Input

The first line contains a single integer n — the size of the array a (1 ≤ n ≤ 20). 

The following line contains n integers a_1, a_2, …, a_n — array elements (-10^{15} ≤ a_i ≤ 10^{15}).

Output

Output a single integer — the minimum number of operations required to destroy the array a.

Examples

Input


3
1 10 100


Output


3


Input


3
5 3 -2


Output


2


Input


1
0


Output


0

Note

In the first example one can just apply the operation of the first kind three times.

In the second example, one can apply the operation of the second kind two times: first, choose i = 2, j = 1, x = 4, it transforms the array into (0, -1, -2), and then choose i = 3, j = 2, x = -2 to destroy the array.

In the third example, there is nothing to be done, since the array is already destroyed.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
pair<long long, long long> partition_numbers(const vector<long long> &v,
                                             bool nonempty = true,
                                             int parity = -1) {
  int n = ((int)(v).size()), na = n / 2, nb = n - na;
  vector<pair<long long, long long>> a(1, make_pair(0LL, 0LL));
  for (int i = (0); i < (na); ++i) {
    vector<pair<long long, long long>> aa(2 * ((int)(a).size()));
    int x = 0, y = 0;
    while (x < ((int)(a).size()) || y < ((int)(a).size()))
      if (x < ((int)(a).size()) &&
          (y >= ((int)(a).size()) || a[x].first - v[i] <= a[y].first + v[i]))
        aa[x + y] = make_pair(a[x].first - v[i], a[x].second), ++x;
      else
        aa[x + y] = make_pair(a[y].first + v[i], a[y].second | (1LL << i)), ++y;
    swap(a, aa);
  }
  vector<pair<long long, long long>> b(1, make_pair(0LL, 0LL));
  for (int i = (0); i < (nb); ++i) {
    vector<pair<long long, long long>> bb(2 * ((int)(b).size()));
    int j = na + i;
    int x = 0, y = 0;
    while (x < ((int)(b).size()) || y < ((int)(b).size()))
      if (x < ((int)(b).size()) &&
          (y >= ((int)(b).size()) || b[x].first - v[j] <= b[y].first + v[j]))
        bb[x + y] = make_pair(b[x].first - v[j], b[x].second), ++x;
      else
        bb[x + y] = make_pair(b[y].first + v[j], b[y].second | (1LL << j)), ++y;
    swap(b, bb);
  }
  reverse(b.begin(), b.end());
  pair<long long, long long> ret = make_pair(LLONG_MAX, 0);
  auto upd = [&](int ai, int bi) {
    pair<long long, long long> cur =
        make_pair(abs(a[ai].first + b[bi].first), a[ai].second | b[bi].second);
    ret = min(ret, cur);
  };
  for (int apar = (0); apar < (2); ++apar)
    for (int bpar = (0); bpar < (2); ++bpar) {
      if (parity != -1 && (apar + bpar) % 2 != parity) continue;
      int ai = 0, bi = 0;
      while (ai < ((int)(a).size()) && bi < ((int)(b).size())) {
        if ((a[ai].first % 2 == 0) != (apar == 0)) {
          ++ai;
          continue;
        }
        if ((b[bi].first % 2 == 0) != (bpar == 0)) {
          ++bi;
          continue;
        }
        if (nonempty &&
            (a[ai].second == 0 || a[ai].second == (1LL << na) - 1)) {
          ++ai;
          continue;
        }
        if (nonempty &&
            (b[bi].second == 0 || b[bi].second == (1LL << n) - (1LL << na))) {
          ++bi;
          continue;
        }
        upd(ai, bi);
        if (a[ai].first + b[bi].first <= 0)
          ++ai;
        else
          ++bi;
      }
    }
  if (nonempty && na >= 1 && nb >= 1) {
    for (int ai = (0); ai < (((int)(a).size())); ++ai) {
      if (a[ai].second == 0) {
        for (int k = (0); k < (((int)(b).size())); ++k)
          if (b[k].second != 0 &&
              (parity == -1 ||
               ((a[ai].first + b[k].first) % 2 == 0) == (parity == 0)))
            upd(ai, k);
      }
      if (a[ai].second == (1LL << na) - 1) {
        for (int k = (0); k < (((int)(b).size())); ++k)
          if (b[k].second != (1LL << n) - (1LL << na) &&
              (parity == -1 ||
               ((a[ai].first + b[k].first) % 2 == 0) == (parity == 0)))
            upd(ai, k);
      }
    }
    for (int bi = (0); bi < (((int)(b).size())); ++bi) {
      if (b[bi].second == 0) {
        for (int k = (0); k < (((int)(a).size())); ++k)
          if (a[k].second != 0 &&
              (parity == -1 ||
               ((a[k].first + b[bi].first) % 2 == 0) == (parity == 0)))
            upd(k, bi);
      }
      if (b[bi].second == (1LL << n) - (1LL << na)) {
        for (int k = (0); k < (((int)(a).size())); ++k)
          if (a[k].second != (1LL << na) - 1 &&
              (parity == -1 ||
               ((a[k].first + b[bi].first) % 2 == 0) == (parity == 0)))
            upd(k, bi);
      }
    }
  }
  return ret;
}
struct SubsetConvolution1 {
  int n;
  vector<int> cnt;
  SubsetConvolution1(int _n) {
    n = _n;
    cnt = vector<int>(1 << n);
    cnt[0] = 0;
    for (int mask = (1); mask < (1 << n); ++mask)
      cnt[mask] = cnt[mask >> 1] + (mask & 1);
  }
  struct Function {
    vector<int> func;
    vector<vector<int>> rankedtrans;
  };
  void transform(vector<int> &v) {
    for (int step = 1 << (n - 1); step >= 1; step >>= 1)
      for (int base = 0; base < (1 << n); base += step << 1)
        for (int offset = (0); offset < (step); ++offset)
          v[base + step + offset] += v[base + offset];
  }
  void invtransform(vector<int> &v) {
    for (int step = 1 << (n - 1); step >= 1; step >>= 1)
      for (int base = 0; base < (1 << n); base += step << 1)
        for (int offset = (0); offset < (step); ++offset)
          v[base + step + offset] -= v[base + offset];
  }
  void ensureranked(Function &f) {
    if (((int)(f.rankedtrans).size()) > 0)
      return;
    else
      assert(((int)(f.func).size()) > 0);
    f.rankedtrans = vector<vector<int>>(n + 1, vector<int>(1 << n, 0));
    for (int mask = (0); mask < (1 << n); ++mask)
      f.rankedtrans[cnt[mask]][mask] += f.func[mask];
    for (int k = (0); k <= (n); ++k) transform(f.rankedtrans[k]);
  }
  Function convert(const vector<bool> &can) {
    Function ret;
    ret.func = vector<int>(1 << n);
    for (int mask = (0); mask < (1 << n); ++mask)
      ret.func[mask] = can[mask] ? 1 : 0;
    return ret;
  }
  Function mult(Function &f, Function &g) {
    ensureranked(f);
    ensureranked(g);
    Function ret;
    ret.rankedtrans = vector<vector<int>>(n + 1, vector<int>(1 << n, 0));
    for (int k = (0); k <= (n); ++k)
      for (int j = (0); j <= (k); ++j)
        for (int mask = (0); mask < (1 << n); ++mask)
          ret.rankedtrans[k][mask] +=
              f.rankedtrans[j][mask] * g.rankedtrans[k - j][mask];
    return ret;
  }
  bool any(const Function &f) {
    if (((int)(f.func).size()) > 0) {
      for (int mask = (0); mask < (1 << n); ++mask)
        if (f.func[mask] != 0) return true;
      return false;
    }
    if (((int)(f.rankedtrans).size()) > 0) {
      for (int k = (0); k <= (n); ++k) {
        vector<int> rankedfunc = f.rankedtrans[k];
        invtransform(rankedfunc);
        for (int mask = (0); mask < (1 << n); ++mask)
          if (cnt[mask] == k && rankedfunc[mask] != 0) return true;
      }
      return false;
    }
    assert(false);
    return false;
  }
  int maxDisjointSets(vector<bool> can) {
    vector<Function> p(1, convert(can));
    while (true) {
      int idx = ((int)(p).size()) - 1;
      if (!any(p[idx])) break;
      Function tmp = p[idx];
      p.emplace_back(mult(tmp, tmp));
    }
    p.pop_back();
    if (((int)(p).size()) == 0) return 0;
    int myidx = ((int)(p).size()) - 1, ret = 1 << myidx;
    for (int i = ((int)(p).size()) - 2; i >= 0; --i) {
      Function cur = mult(p[myidx], p[i]);
      if (!any(cur)) continue;
      swap(p[myidx], cur);
      ret += 1 << i;
    }
    return ret;
  }
};
struct SubsetConvolution {
  int n;
  vector<int> cnt;
  SubsetConvolution(int _n) {
    n = _n;
    cnt = vector<int>(1 << n);
    cnt[0] = 0;
    for (int mask = (1); mask < (1 << n); ++mask)
      cnt[mask] = cnt[mask >> 1] + (mask & 1);
  }
  void transform(vector<int> &v) {
    for (int step = 1 << (n - 1); step >= 1; step >>= 1)
      for (int base = 0; base < (1 << n); base += step << 1)
        for (int offset = (0); offset < (step); ++offset)
          v[base + step + offset] += v[base + offset];
  }
  void invtransform(vector<int> &v) {
    for (int step = 1 << (n - 1); step >= 1; step >>= 1)
      for (int base = 0; base < (1 << n); base += step << 1)
        for (int offset = (0); offset < (step); ++offset)
          v[base + step + offset] -= v[base + offset];
  }
  int maxDisjointSets(vector<bool> can) {
    assert(!can[0]);
    vector<vector<int>> one(n + 1, vector<int>(1 << n, 0));
    for (int mask = (0); mask < (1 << n); ++mask)
      if (can[mask]) ++one[cnt[mask]][mask];
    for (int k = (1); k <= (n); ++k) transform(one[k]);
    vector<vector<int>> cur = one;
    int ret = 0;
    vector<vector<int>> nxt(n + 1, vector<int>(1 << n, 0));
    while (true) {
      bool any = false;
      for (int k = (ret + 1); k <= (n); ++k) {
        vector<int> z = cur[k];
        invtransform(z);
        for (int mask = (0); mask < (1 << n); ++mask)
          if (cnt[mask] == k && z[mask] != 0) {
            any = true;
            break;
          }
        if (any) break;
      }
      if (!any)
        return ret;
      else
        ++ret;
      for (int k = (ret + 1); k <= (n); ++k)
        for (int mask = (0); mask < (1 << n); ++mask) nxt[k][mask] = 0;
      for (int k = (ret + 1); k <= (n); ++k)
        for (int j = (ret); j <= (k - 1); ++j)
          for (int mask = (0); mask < (1 << n); ++mask)
            nxt[k][mask] += cur[j][mask] * one[k - j][mask];
      swap(cur, nxt);
    }
  }
};
const int MAXN = 20;
int n;
long long a[MAXN];
long long b[MAXN];
int nb;
int solve() {
  nb = 0;
  for (int i = (0); i < (n); ++i)
    if (a[i] != 0) b[nb++] = a[i];
  vector<bool> one(1 << nb);
  for (int mask = (0); mask < (1 << nb); ++mask) {
    vector<long long> v;
    for (int i = (0); i < (nb); ++i)
      if (mask & (1 << i)) v.push_back(b[i]);
    long long mindiff =
        partition_numbers(v, true, ((int)(v).size()) % 2 == 0 ? 1 : 0).first;
    one[mask] = ((int)(v).size()) == 1 && v[0] == 0 ||
                ((int)(v).size()) >= 2 && mindiff <= ((int)(v).size()) - 1;
  }
  SubsetConvolution sc(nb);
  int save = sc.maxDisjointSets(one);
  return nb - save;
}
void run() {
  scanf("%d", &n);
  for (int i = (0); i < (n); ++i) scanf("%lld", &a[i]);
  printf("%d\n", solve());
}
int main() {
  run();
  return 0;
}