#include <bits/stdc++.h>

typedef long long int lli;

using namespace std;

#define MAX4 10010
#define MAX5 100010
#define MAX6 1000010

#define FOR(n) for (int i = 0; i < n; i++)

using vti = vector<int>;
using vts = vector<string>;

template <typename T> void dbg(T last) { cout << last << "\n"; }

template <typename T, typename... args> void dbg(T current, args... next) {
  cout << current << ' ';
  dbg(next...);
}

template <typename T> void getInput(vector<T> &v, int n, int x = 0) {
  for (int i = x; i < n; i++) {
    cin >> v[i];
  }
}

//-----------------------------------------------------------------------------------------------//
const lli mod = 1000000009;
vector<int> tab[MAX6];
lli dp[MAX6][2];
void solve() {
  int n, m;
  cin >> n >> m;
  vti v(n);
  getInput(v, n);
  for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    if (a > b) {
      swap(a, b);
    }
    tab[b].push_back(a);
  }

  dp[0][v[0]] = 1;

  for (int i = 1; i < n; i++) {
    int x = v[i];
    dp[i][x] = (dp[i - 1][0] + dp[i - 1][1]) % mod;
    int nx = (x + 1) % 2;
    lli sum = 0;
    for (int t : tab[i]) {
      // dbg("* ", i, t, dp[t][x]);
      // if (v[t] == v[i]) {
      //   dp[t][nx]++;
      // }
      sum += dp[t][x];
      // dp[i][x] += dp[t][x];
    }
    dp[i][nx] = sum;
    dp[i][x] += sum;
    dbg(i + 1, dp[i][0], dp[i][1]);
    //  db[i][x] += tab[i].size();
  }

  cout << (dp[n - 1][0] + dp[n - 1][1]) % mod << "\n";
}

void solve2() {
  int n, m;
  cin >> n >> m;
  vti v(n);
  getInput(v, n);
  vector<pair<int, int>> xd;
  for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    xd.push_back({a, b});
  }
  set<vector<int>> s{v};
  vector<int> h(m + 1);
  vector<bool> vis(m + 1, false);

  while (true) {
    int old = s.size();

    set<vector<int>> s2;
    int cnt = 0;
    for (auto [a, b] : xd) {
      cnt++;
      // if (vis[cnt]) {
      //   vis[cnt] = false;
      //   continue;
      // }
      // vis[cnt] = true;
      for (auto it : s) {
        auto vec = it;
        // dbg(a, b, vec[a], vec[b]);
        if (vec[a] == vec[b]) {
          vec[a] += 1;
          vec[a] %= 2;
          vec[b] = vec[a];
          // if (!s.count(vec) && !s2.count(vec))
          //   h[cnt]++;
          s2.insert(vec);
        }
      }
    }

    for (auto vec : s2) {
      s.insert(vec);
    }
    if (s.size() == old) {
      break;
    }
  }

  // for (int i = 0; i <= m; i++) {
  //   dbg(i, h[i]);
  // }
  cout << s.size() << "\n";

  // for (auto vec : s) {
  //   for (int x : vec) {
  //     cout << x << " ";
  //   }
  //   cout << "\n";
  // }
}

void solve3() {
  int n, m;
  cin >> n >> m;
  vector<bool> v(n);
  for (int i = 0; i < n; i++) {
    int a;
    cin >> a;
    v[i] = a;
  }
  vector<pair<int, int>> xd;
  for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    xd.push_back({a, b});
  }
  set<set<int>> s{{}};

  while (true) {
    int old = s.size();

    set<set<int>> s2 = s;
    int cnt = 0;
    for (auto [a, b] : xd) {

      for (auto it = s.begin(); it != s.end(); it++) {
        auto nset = *it;
        bool xa = v[a];
        bool xb = v[b];

        if (nset.count(a)) {
          nset.erase(a);
        } else {
          xa = !xa;
          nset.insert(a);
        }

        if (nset.count(b)) {
          nset.erase(b);
        } else {
          xb = !xb;
          nset.insert(b);
        }
        // dbg(a, b, xa, xb);
        if (xa == xb) {
          s2.insert(nset);
        }
      }
    }

    if (s2.size() == s.size()) {
      break;
    }

    swap(s2, s);
  }

  cout << s.size() << "\n";
}

void solve4() {
  int n, m;
  cin >> n >> m;
  vector<bool> v(n);
  for (int i = 0; i < n; i++) {
    int a;
    cin >> a;
    v[i] = a;
  }
  vector<pair<int, int>> xd;
  for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    xd.push_back({a, b});
  }
  set<vector<bool>> s{v};

  while (true) {
    int old = s.size();

    set<vector<bool>> s2;

    for (auto [a, b] : xd) {
      for (auto &vec : s) {
        if (vec[a] == vec[b]) {
          auto nvec = vec;
          nvec[a] = !vec[a];
          nvec[b] = !vec[b];
          s2.insert(std::move(nvec));
        }
      }
    }

    for (auto vec : s2) {
      s.insert(vec);
    }

    if (s.size() == old) {
      break;
    }
  }

  // for (int i = 0; i <= m; i++) {
  //   dbg(i, h[i]);
  // }
  cout << s.size() << "\n";

  // for (auto vec : s) {
  //   for (int x : vec) {
  //     cout << x << " ";
  //   }
  //   cout << "\n";
  // }
}

int main() {
  std::ios::sync_with_stdio(false);

  solve4();

  return 0;
}