#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr ll inf = 1ll << 50;

#define L(i, l, r) for (int i = (l); i < (r); ++i)
#define R(i, l, r) for (int i = (r - 1); i >= (l); --i)
#define ALL(x) (x).begin(), (x).end()
#define sz(x) (int)(x.size())

int n, m;
vector<ll> s;
vector<int> a, b;
vector<ll> val_s;
int p;
vector<vector<int>> edge_map, ver_map;

vector<vector<int>> g;
vector<vector<int>> origin;
vector<vector<ll>> nxt_weight, all_sum;

struct UnionFind {
    int n;
    vector<int> data;
    vector<set<pair<ll, int>>> rs;
    vector<ll> sum;

    UnionFind(int n_) : n(n_) {
        data.assign(n, -1);
        rs.resize(n);
        L(i, 0, m) {
            rs[a[i]].insert({s[b[i]], b[i]});
            rs[b[i]].insert({s[a[i]], a[i]});
        }
        sum = s;
    }

    int leader(int v) {
        if (data[v] < 0) {
            return v;
        } else {
            return data[v] = leader(data[v]);
        }
    }

    void merge(int a, int b) {
        a = leader(a);
        b = leader(b);
        if (a == b) {
            return;
        }
        if (data[a] > data[b]) {
            swap(a, b);
        }

        data[a] += data[b];
        data[b] = a;
        for (const auto &e : rs[b]) {
            rs[a].insert(e);
        }
        sum[a] += sum[b];
    }
};

constexpr int D = 30;

void chmin(ll &a, const ll b) {
    a = min(a, b);
}

void read() {
    cin >> n >> m;
    s.resize(n);
    for (auto &e : s) {
        cin >> e;
    }
    a.resize(m);
    b.resize(m);
    g.resize(n);
    L(i, 0, m) {
        cin >> a[i] >> b[i];
        --a[i], --b[i];
    }

    val_s = s;
    sort(ALL(val_s));
    val_s.erase(unique(ALL(val_s)), val_s.end());
    p = sz(val_s);

    edge_map.resize(p);
    L(i, 0, m) {
        const int pos = lower_bound(ALL(val_s), max(s[a[i]], s[b[i]])) - val_s.begin();
        edge_map[pos].push_back(i);
    }
    ver_map.resize(p);
    L(i, 0, n) {
        const int pos = lower_bound(ALL(val_s), s[i]) - val_s.begin();
        ver_map[pos].push_back(i);
    }
}

void process() {
    vector<bool> ans(n);

    int v_id = 0;

    nxt_weight.assign(D, vector<ll>(n, inf));
    all_sum.assign(D, vector<ll>(n, inf));
    origin.assign(D, vector<int>(n, -1));
    L(d, 0, D) {
        while (v_id != p and val_s[v_id] <= (1 << d)) {
            for (const int i : edge_map[v_id]) {
                g[a[i]].push_back(b[i]);
                g[b[i]].push_back(a[i]);
            }
            ++v_id;
        }

        auto &ori = origin[d];
        L(i, 0, n) {
            if (ori[i] != -1) {
                continue;
            }
            queue<int> que;
            que.push(i);
            ori[i] = i;
            while (not que.empty()) {
                const int f = que.front();
                que.pop();
                for (const int t : g[f]) {
                    if (ori[t] == -1) {
                        ori[t] = i;
                        que.push(t);
                    }
                }
            }
        }

        vector<vector<int>> vs(n);
        L(i, 0, n) {
            vs[ori[i]].push_back(i);
        }
        L(i, 0, n) {
            sort(ALL(vs[i]));
            for (const int f : vs[i]) {
                all_sum[d][i] += s[f];
                for (const int t : g[f]) {
                    if (binary_search(ALL(vs[i]), t)) {
                        continue;
                    }
                    chmin(nxt_weight[d][i], s[t]);
                }
            }
        }
    }

    UnionFind uft(n);
    L(now_val, 0, p) {
        for (const int i : edge_map[now_val]) {
            uft.merge(a[i], b[i]);
        }
        for (const int i : ver_map[now_val]) {
            // answer query
            int leader = uft.leader(i);
            auto &adj_set = uft.rs[leader];
            while ((not adj_set.empty()) and adj_set.begin()->first <= val_s[now_val]) {
                adj_set.erase(adj_set.begin());
            }
            ll now_sum = uft.sum[leader];

            if (adj_set.empty()) {
                ans[i] = true;
                continue;
            }
            if (adj_set.begin()->first > now_sum) {
                ans[i] = false;
                continue;
            }

            int d = 0;
            while ((1 << d) <= now_sum) {
                ++d;
            }
            if (d >= D) {
                ans[i] = true;
                continue;
            }
            while (d < D) {
                now_sum = all_sum[d][origin[d][i]];
                ll nxt_g = nxt_weight[d][origin[d][i]];
                if (nxt_g == inf) {
                    ans[i] = true;
                    break;
                }
                if (nxt_g > now_sum) {
                    ans[i] = false;
                    break;
                }
                ++d;
            }
            if (d == D) {
                ans[i] = true;
            }
        }
    }

    for (const auto e : ans) {
        cout << (e ? 1 : 0);
    }
    cout << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    read();
    process();
}