#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// error in statement
#define MAX_N 5010

int N, M, Q;
char C[5010];
vector<int> A, B;
vector<int> X, Y;

vector<vector<int>> graph[2];
void ae(int id, int u, int v) {
  graph[id][u].push_back(v);
  graph[id][v].push_back(u);
}

vector<int> dep;
pair<int, int> bac;
void dfs(int dc, int u, int d) {
  dep[u] = d;
  for (const int v : graph[0][u]) if (((C[u] - '0') ^ dc) == (C[v] - '0')) {
    if (~dep[v]) {
      if ((dep[v] - dep[u]) % 2 == 0) {
        bac = make_pair(u, v);
      }
    } else {
      ae(1, u, v);
      dfs(dc, v, d + 1);
    }
  }
}

bitset<5010> vis[2][5010];

int main() {
  for (; ~scanf("%d%d%d", &N, &M, &Q); ) {
    scanf("%s", C);
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    X.resize(Q);
    Y.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d", &X[q], &Y[q]);
      --X[q];
      --Y[q];
    }
    
    graph[0].assign(N, {});
    for (int i = 0; i < M; ++i) {
      ae(0, A[i], B[i]);
    }
    graph[1].assign(N, {});
    for (int dc = 0; dc < 2; ++dc) {
      dep.assign(N, -1);
      for (int u = 0; u < N; ++u) if (!~dep[u]) {
        bac = make_pair(-1, -1);
        dfs(dc, u, 0);
        if (~bac.first) {
          ae(1, bac.first, bac.second);
        }
      }
    }
cerr<<"graph[1] = "<<graph[1]<<endl;
    
    /*
      (0, u, v): palindrome
      -> (1, v', u)
      -> (0, u', v')
    */
    for (int h = 0; h < 2; ++h) for (int u = 0; u < N; ++u) vis[h][u].reset();
    
    queue<int> que;
    auto visit = [&](int h, int u, int v) -> void {
// cerr<<"visit "<<h<<" "<<u<<" "<<v<<endl;
      if (!vis[h][u][v]) {
        vis[h][u].set(v);
        que.push((h * N + u) * N + v);
      }
    };
    for (int u = 0; u < N; ++u) {
      visit(0, u, u);
    }
    for (int u = 0; u < N; ++u) for (const int v : graph[1][u]) if (C[u] == C[v]) {
      visit(0, u, v);
    }
    for (; que.size(); ) {
      const int h = que.front() / N / N;
      const int u = que.front() / N % N;
      const int v = que.front() % N;
      que.pop();
      for (const int w : graph[1][v]) if (h == 0 || C[u] == C[w]) {
        visit(h ^ 1, w, u);
      }
    }
    
    for (int q = 0; q < Q; ++q) {
      puts(vis[0][X[q]][Y[q]] ? "YES" : "NO");
    }
#ifdef LOCAL
cerr<<string(80,'=')<<endl;
#endif
  }
  return 0;
}