/**
 * @author n685
 * @date 2024-12-26 11:50:21
 */
#include "bits/stdc++.h"

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  int n, m, q;
  std::cin >> n >> m >> q;

  std::vector<bool> lb(n);
  for (int i = 0; i < n; ++i) {
    char c;
    std::cin >> c;
    lb[i] = c == '1';
  }

  std::vector<std::pair<int, int>> diff(n);
  std::vector<std::vector<int>> same(n);
  for (int i = 0; i < m; ++i) {
    int u, v;
    std::cin >> u >> v;
    --u;
    --v;
    if (lb[u] == lb[v]) {
      same[u].push_back(v);
      same[v].push_back(u);
    } else {
      diff.emplace_back(u, v);
    }
  }

  std::vector<std::vector<int>> adj(n);
  std::vector<bool> vis(n);
  std::vector<int> cc(n, -1), clr(n);
  std::vector<bool> bp(n, true);
  auto dfs = [&](auto&& self, int node, int par) -> bool {
    bool g = true;
    for (int i : same[node]) {
      if (i == par) {
        continue;
      }
      if (vis[i]) {
        if (clr[node] == clr[i]) {
          g = false;
        }
        continue;
      }
      adj[node].push_back(i);
      adj[i].push_back(node);
      cc[i] = cc[node];
      vis[i] = true;
      clr[i] = !clr[node];
      if (!self(self, i, node)) {
        g = false;
      }
    }
    return g;
  };
  for (int i = 0, cnt = 0; i < n; ++i) {
    if (vis[i]) {
      continue;
    }
    vis[i] = true;
    cc[i] = cnt++;
    if (!dfs(dfs, i, -1)) {
      adj[i].push_back(i);
      bp[cc[i]] = false;
    }
  }
  vis.assign(n, false);
  std::vector<std::vector<std::pair<int, int>>> dadj(n);
  for (int i = 0; i < std::ssize(diff); ++i) {
    dadj[diff[i].first].emplace_back(i, diff[i].second);
    dadj[diff[i].second].emplace_back(i, diff[i].first);
  }
  auto dfs2 = [&](auto&& self, int node, int par) -> void {
    for (auto [t, i] : dadj[node]) {
      if (i == par) {
        continue;
      }
      if (vis[i]) {
        continue;
      }
      vis[i] = true;
      adj[diff[t].first].push_back(diff[t].second);
      adj[diff[t].second].push_back(diff[t].first);
      self(self, i, node);
    }
  };
  for (int i = 0; i < n; ++i) {
    if (vis[i]) {
      continue;
    }
    vis[i] = true;
    dfs2(dfs2, i, -1);
  }
  for (int i = 0; i < n; ++i) {
    dbg(i, adj[i]);
  }

  std::vector f(n, std::vector<bool>(n));
  std::queue<std::pair<int, int>> qq;
  for (int i = 0; i < n; ++i) {
    f[i][i] = true;
    qq.emplace(i, i);
    for (int j : adj[i]) {
      if (lb[i] == lb[j]) {
        f[i][j] = true;
        qq.emplace(i, j);
      }
    }
  }
  while (!qq.empty()) {
    auto [i, j] = qq.front();
    qq.pop();
    for (int u : adj[i]) {
      for (int v : adj[j]) {
        if (!f[u][v] && lb[u] == lb[v]) {
          f[u][v] = true;
          qq.emplace(u, v);
        }
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    dbg(i, f[i]);
  }

  while (q--) {
    int u, v;
    std::cin >> u >> v;
    --u;
    --v;
    std::cout << (f[u][v] ? "YES" : "NO") << '\n';
  }
}