/*************************************************************************
 *                                                                       *
 *                       Pogromcy Algorytmów 2004                        *
 *                                                                       *
 *   Rozwiązanie zadania: Nawiasy                                        *
 *   Plik:                naw.cpp                                        *
 *   Autor:               Paweł Wolff                                    *
 *************************************************************************/

/* 

   (Poniższy komentarz: PW, 02.10.2003)


   Rozwiązanie wzorcowe zadania NAWIASY
   ------------------------------------
   
   Na początku algorytmu, na podstawie słowa nawiasowego danego na wejściu,
   budujemy drzewo binarne tak, że:
   - korzeniowi drzewa stowarzyszony jest z całym słowem nawiasowym,
   - jeśli węzeł drzewa stowarzyszony jest z podsłowem w całego słowa
     nawiasowego oraz |w| > 1, to jego lewy syn stowarzyszony jest ze slowem v,
     a prawy ze slowem u,
     gdzie w = uv, oraz |u| = |w| div 2, |v| = (|w| + 1) div 2,
   - jeśli węzeł drzewa stowarzyszony jest z podsłowem w całego słowa
     nawiasowego oraz |w| = 1, to węzeł ten jest liściem drzewa.
   Ponadto w węzłach drzewa zapisane są dwie liczby:
   - liczba l, czyli liczba niezamkniętych nawiasów '('
     w podsłowie słowa nawiasowego stowarzyszonego z danym węzłem,
   - liczba p, czyli liczba nieotwartych nawiasów ')'
     w podsłowie słowa nawiasowego stowarzyszonego z danym węzłem.

   Takie drzewo można zbudować w czasie O(n); gdzie n = dlugosc slowa
   nawiasowego (patrz funkcja init).
   
   Jeśli jeden nawias w słowie nawiasowym zmieniamy na przeciwny,
   to uaktualnienia naszego drzewa mozemy dokonać w czasie O(log n)
   (bo log n = wysokość drzewa). (Patrz funkcja change.)
   
   Sprawdzenie, czy aktualne słowo nawiasowe jest poprawnym wyrażeniem
   nawiasowym wykonuje się w czasie stałym - wystarczy sprawdzić, czy
   liczby l i p zapisane w korzeniu są równe 0 (patrz funkcja query).

   Złożoność czasowa powyższego algorytmu wynosi O(n + s + z * log n),
   gdzie z jest liczbą operacji zamiany, a s - liczbą operacji sprawdzenia.
   Złożoność pamięciowa wynosi O(n).

*/


#include <stdio.h>

#define MAXN 30000

char s[MAXN + 1];
int l[4 * MAXN];
int p[4 * MAXN];
int n, q;

void init(int nr, int il, int ip)
{
  int id = (il+ip)/2;

  if (il < ip) {
    init(2*nr+1, il, id);
    init(2*nr+2, id+1, ip);
    if (p[2*nr+2] >= l[2*nr+1]) {
      l[nr] = l[2*nr+2];
      p[nr] = p[2*nr+1]+p[2*nr+2]-l[2*nr+1];
    } else {
      l[nr] = l[2*nr+1]-p[2*nr+2]+l[2*nr+2];
      p[nr] = p[2*nr+1];
    }
  } else {
    if (s[id] == '(') {
      l[nr] = 1;
      p[nr] = 0;
    } else {
      l[nr] = 0;
      p[nr] = 1;
    }
  }
}

void change(int nr, int il, int ip, int pos)
{
  int id = (il+ip)/2;

  if (il < ip)
  {
    if (pos <= id) {
      change(2*nr+1, il, id, pos);
    } else {
      change(2*nr+2, id+1, ip, pos);
    }
    if (p[2*nr+2] >= l[2*nr+1]) {
      l[nr] = l[2*nr+2];
      p[nr] = p[2*nr+1]+p[2*nr+2]-l[2*nr+1];
    } else {
      l[nr] = l[2*nr+1]-p[2*nr+2]+l[2*nr+2];
      p[nr] = p[2*nr+1];
    }
  } else {
    l[nr] = 1-l[nr];
    p[nr] = 1-p[nr];
  }
}

int query()
{
  return l[0] == 0 && p[0] == 0;
}

int main()
{
  int i, pos;

  scanf("%d %s", &n, s);
  init(0, 0, n-1);
  scanf("%d", &q);
  for (i = 0; i < q; i++) {
    scanf("%d", &pos);
    if (pos == 0)
      printf("%s\n", query() ? "TAK" : "NIE");
    else {
      pos--;
      s[pos] = 1-(s[pos]-'(')+'(';
      change(0, 0, n-1, pos);
    }
  }

  return 0;
}
