#include <bits/stdc++.h>
using namespace std;

template<typename T, T...>
struct myinteger_sequence { };

template<typename T, typename S1 = void, typename S2 = void>
struct helper{
    std::string operator()(const T& s){
        return std::string(s);
    }
}; 

template<typename T>
struct helper<T, decltype((void)std::to_string(std::declval<T>())), typename std::enable_if<!std::is_same<typename std::decay<T>::type, char>::value, void>::type>{
    std::string operator()(const T& s){
        return std::to_string(s);
    }
};

template<typename T>
struct helper<T, void, typename std::enable_if<std::is_same<typename std::decay<T>::type, char>::value, void>::type>{
    std::string operator()(const T& s){
        return std::string(1, s);
    }
};

template<typename T, typename S1 =void, typename S2 =void>
struct seqhelper{
    const static bool seq = false;
};

template<typename T>
struct seqhelper<T, decltype((void)(std::declval<T>().begin())), decltype((void)(std::declval<T>().end()))>{
    const static bool seq = !(std::is_same<typename std::decay<T>::type, std::string>::value);
};

template<std::size_t N, std::size_t... I>
struct gen_indices : gen_indices<(N - 1), (N - 1), I...> { };
template<std::size_t... I>
struct gen_indices<0, I...> : myinteger_sequence<std::size_t, I...> { };

template<typename T, typename REDUNDANT = void>
struct converter{
    template<typename H>
    std::string& to_string_impl(std::string& s, H&& h)
    {
        using std::to_string;
        s += converter<H>().convert(std::forward<H>(h));
        return s;    
    }

    template<typename H, typename... T1>
    std::string& to_string_impl(std::string& s, H&& h, T1&&... t)
    {
        using std::to_string;
        s += converter<H>().convert(std::forward<H>(h)) + ", ";
        return to_string_impl(s, std::forward<T1>(t)...);
    }

    template<typename... T1, std::size_t... I>
    std::string mystring(const std::tuple<T1...>& tup, myinteger_sequence<std::size_t, I...>)
    {
        std::string result;
        int ctx[] = { (to_string_impl(result, std::get<I>(tup)...), 0), 0 };
        (void)ctx;
        return result;
    }

    template<typename... S>
    std::string mystring(const std::tuple<S...>& tup)
    {
        return mystring(tup, gen_indices<sizeof...(S)>{});
    }

    template<typename S=T>
    std::string convert(const S& x){
        return helper<S>()(x);
    }

    template<typename... S>
    std::string convert(const std::tuple<S...>& tup){
        std::string res = std::move(mystring(tup));
        res = "{" + res + "}";
        return res;
    }

    template<typename S1, typename S2>
    std::string convert(const std::pair<S1, S2>& x){
        return "{" + converter<S1>().convert(x.first) + ", " + converter<S2>().convert(x.second) + "}";
    }
};

template<typename T>
struct converter<T, typename std::enable_if<seqhelper<T>::seq, void>::type>{
    template<typename S=T>
    std::string convert(const S& x){
        int len = 0;
        std::string ans = "{";
        for(auto it = x.begin(); it != x.end(); ++it){
            ans += std::move(converter<typename S::value_type>().convert(*it)) + ", ";
            ++len;
        }
        if(len == 0) return "{[EMPTY]}";
        ans.pop_back(), ans.pop_back();
        return ans + "}";
    }
};

template<typename T>
std::string luangao(const T& x){
    return converter<T>().convert(x);
}
#define cstr(x) (luangao(x).c_str())
template <class T>
struct range_set {
   private:
   const T TINF = std::numeric_limits<T>::max() / 2;
   T sum;
   std::set<std::pair<T, T>> st;
 
   public:
   range_set() : sum(0) {
      st.emplace(-TINF, -TINF);
      st.emplace(TINF, TINF);
   }
 
   //[l, r) is covered?
   bool covered(const T l, const T r) {
      assert(l <= r);
      if(l == r) return true;
      auto itr = prev(st.upper_bound({l, TINF}));
      return itr->first <= l and r <= itr->second;
   }
 
   //[x, x + 1) is covered?
   bool covered(const T x) { return covered(x, x + 1); }
 
   // return section which covers[l, r)
   // if not exists, return[-TINF, -TINF)
   std::pair<T, T> covered_by(const T l, const T r) {
      assert(l <= r);
      if(l == r) return {-TINF, -TINF};
      auto itr = prev(st.upper_bound({l, TINF}));
      if(itr->first <= l and r <= itr->second) return *itr;
      return {-TINF, -TINF};
   }
 
   // return section which covers[x, x + 1)
   // if not exists, return[-TINF, -TINF)
   std::pair<T, T> covered_by(const T x) { return covered_by(x, x + 1); }
 
   // insert[l, r), and return increment
   std::vector<T> insert(T l, T r) {
      assert(l <= r);
      std::vector<T> res;
      if(l == r) return res;
      auto itr = prev(st.upper_bound({l, TINF}));
      if(itr->first <= l and r <= itr->second) return res;
      T sum_erased = T(0);
      int curl = l;
      if(itr->first <= l and l <= itr->second) {
         l = itr->first;
         sum_erased += itr->second - itr->first;
         auto nxtitr = next(itr);
         int nxtop = (nxtitr == st.end()) ? TINF : nxtitr->first;
         //printf("itr->second==%d, nxtop==%d, r==%d\n", itr->second, nxtop, r);
         for(int i = itr->second; i < min(nxtop, r); ++i){
            res.push_back(i);
         }
         itr = st.erase(itr);
         curl = itr->second;
      } else
         itr = next(itr);
      while(r > itr->second) {
         sum_erased += itr->second - itr->first;
         for(int i = curl; i < itr->first; ++i){
            res.push_back(i);
         }
         curl = itr->second;
         itr = st.erase(itr);
      }
      if(itr->first <= r) {
         sum_erased += itr->second - itr->first;
         for(int i = curl; i < itr->first; ++i){
            res.push_back(i);
         }
         r = itr->second;
         st.erase(itr);
      }else{
         for(int i = curl; i < r; ++i){
            res.push_back(i);
         }
      }
      st.emplace(l, r);
      sum += r - l - sum_erased;
      return res;
   }
 
   // erase [l, r), and return decrement
   T erase(const T l, const T r) {
      assert(l <= r);
      if(l == r) return T(0);
      auto itr = prev(st.upper_bound({l, TINF}));
      if(itr->first <= l and r <= itr->second) {
         if(itr->first < l) st.emplace(itr->first, l);
         if(r < itr->second) st.emplace(r, itr->second);
         st.erase(itr);
         sum -= r - l;
         return r - l;
      }
      T ret = T(0);
      if(itr->first <= l and l < itr->second) {
         ret += itr->second - l;
         if(itr->first < l) st.emplace(itr->first, l);
         itr = st.erase(itr);
      } else
         itr = next(itr);
      while(itr->second <= r) {
         ret += itr->second - itr->first;
         itr = st.erase(itr);
      }
      if(itr->first < r) {
         ret += r - itr->first;
         st.emplace(r, itr->second);
         st.erase(itr);
      }
      sum -= ret;
      return ret;
   }
 
   // erase [x, x + 1), and return decrement
   T erase(const T x) { return erase(x, x + 1); }
 
   int size() const { return (int)st.size() - 2; }
 
   T mex(const T x = 0) const {
      auto itr = prev(st.upper_bound({x, TINF}));
      if(itr->first <= x and x < itr->second)
         return itr->second;
      else
         return x;
   }
 
   T sum_all() const { return sum; }
 
   std::set<std::pair<T, T>> get() const {
      std::set<std::pair<T, T>> res;
      for(auto &p : st) {
         if(std::abs(p.first) == TINF) continue;
         res.emplace(p.first, p.second);
      }
      return res;
   }
 
   void dump() const {
      std::cout << "range_set:";
      for(auto &p : st) {
         if(std::abs(p.first) == TINF) continue;
         std::cout << "[" << p.first << "," << p.second << "),";
      }
      std::cout << '\n';
   }
};

template<typename T=int, typename S=T>
struct BIT{
    bool usep;
    int n, digits;
    vector<T> p; //元素类型
    S* q; //数组类型
    template<typename SIGNED>
    SIGNED lowbit(SIGNED x){
        return x & (-x);    
    }
    
    BIT(int n, vector<T>& p):n(n), digits(0), p(p){
        q = new S[n+1];
        memset(q, 0, (n+1)*sizeof(S));
        getdigits();
        init();
    }
    
    void init(){
        //O(n)时间内建树
        for(int i = 1; i <= n; ++i){
            q[i] += (S)p[i];
            int j = i + lowbit(i);
            if(j <= n) {
                q[j] += q[i];
            }
        }       
    }
    
    void add(int x, int k){
        while(x <= n && x >= 1){
            q[x] = q[x] + (S)k;
            x += lowbit(x);         
        }
    }
    
    S getsum(int x){
        S ans = 0;
        while(x >= 1){
           ans += q[x];
           x -= lowbit(x);
        }           
        return ans;
    }
    
    void getdigits(){
        if(digits) return;
        int tmp = n;
        while(tmp){
            tmp >>= 1;
            digits++;
        } 
    }
    
    int search(S target){
        //最长前缀和
        int t = 0;
        S s = 0;
        for(int i = digits-1; i >= 0; --i){
            if((t + (1 << i) <= n) && (s + q[t + (1<<i)] <= target)){
                s += q[t + (1<<i)]; 
                t += (1 << i);
            }
        }
        return t;
    }
    
    int binsearch(S target){
        int l = 1, r = n, ans = 0;
        while(l <= r){
            int mid = (l + r)/2;
            if(getsum(mid) == target){
                ans = mid;
                l = mid + 1;
            }else if(getsum(mid) < target){
                l = mid + 1;
            }else{
                r = mid - 1;    
            }
        }
        return ans;     
    }
    
    ~BIT(){
        delete[] q;
    }
};

#define DEBUG 0
#define SINGLE 0
#define fastio cin.tie(0) -> sync_with_stdio(0) 

void debug(const char* p){
   #if DEBUG
   freopen(p, "r", stdin); 
   #else
   fastio;
   #endif      
} 

#define cstr(x) (luangao(x).c_str())
int main(void){
   debug("test1.txt");
   range_set<int> rs;
   int n, m, q;
   cin >> n >> m >> q;
   string s;
   cin >> s;
   s = '!' + s;
   set<int> dedup;
   vector<int> id(n+1);
   vector<int> tmp = {1};
   for(int i = 1, li, ri; i <= m; ++i){
      cin >> li >> ri;
      if(li == ri){
         if(!id[ri]){
            id[ri] = (int)tmp.size();
            tmp.push_back(s[ri]-'0');
         }
         continue;
      }
      vector<int> v = rs.insert(li, ri);
      for(int j = 0; j < (int)v.size(); ++j){
         if(!id[v[j]]){
            id[v[j]] = (int)tmp.size();
            tmp.push_back(s[v[j]]-'0');
         }
      }
      if(!v.empty()){
         if(!id[v.back()+1]){
            id[v.back()+1] = (int)tmp.size();
            tmp.push_back(s[v.back()+1]-'0');
         }
      }
      //printf("v==%s\n", cstr(v));
   }
   BIT<int> bit((int)tmp.size()-1, tmp);
   int one = 0;
   for(int x: s){
      one += (x == '1');
   }
   //printf("init: tmp==%s, one==%d\n", cstr(tmp), one);
   for(int qr = 1, x; qr <= q; ++qr){
      cin >> x;
      int diff = 1-2*(s[x] - '0');
      if(id[x]){
         bit.add(id[x], diff);
         if(tmp[id[x]] == 0){
            tmp[id[x]] = 1;
         }else{
            tmp[id[x]] = 0;
         }
      }
      if(s[x] == '0') s[x] = '1', ++one;
      else s[x] = '0', --one;
      //printf("qr==%d, one==%d, (int)tmp.size()-1==%d, id[%d]==%d, tmp==%s\n", qr, one, (int)tmp.size()-1, x, id[x], cstr(tmp));
      //query
      //printf("bit.getsum(min(one, (int)tmp.size()-1)==%d\n", bit.getsum(min(one, (int)tmp.size()-1)));
      int ans = min(one, (int)tmp.size()-1) - bit.getsum(min(one, (int)tmp.size()-1));
      cout << ans << "\n";
   }

}