#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))

struct emdeboas
{
  int a, n, s;		/* Parametry struktury; s je velikost podstruktur. */
  int min, max;		/* Minimum a maximum z fronty.  Pro n <= 2 určuje prvky. */
  struct emdeboas **A;	/* Podstromy dle vzdálenosti. */
  struct emdeboas *B;	/* Fronta neprázdných podstromů. */
};

static void pridej (struct emdeboas *kam, int co);
static void odeber (struct emdeboas *odkud, int co);

/* Celočíselná druhá odmocnina z X. */
static int
int_sqrt (int x)
{
  int f = 1, t = x + 1, m;

  while (t - f > 1)
    {
      m = (f + t) / 2;
      if (m * m > x)
	t = m;
      else
	f = m;
    }

  return f;
}

/* Vytvoří prázdnou frontu pro rozsah A .. A + N - 1. */
static struct emdeboas *
nova_fronta (int a, int n)
{
  struct emdeboas *f = malloc (sizeof (struct emdeboas));
  int t, i;

  f->a = a;
  f->n = n;
  f->min = INT_MAX;
  f->max = INT_MIN;

  if (n <= 2)
    {
      f->s = 0;
      f->B = NULL;
      f->A = NULL;
    }
  else
    {
      f->s = int_sqrt (n + 1);
      t = (n - 1) / f->s + 1;
      f->B = nova_fronta (0, t);
      f->A = malloc (t * sizeof (struct emdeboas *));
      for (i = 0; i < t - 1; i++)
	f->A[i] = nova_fronta (a + i * f->s, f->s);
      f->A[t - 1] = nova_fronta (a + (t - 1) * f->s, n - (t - 1) * f->s);
    }

  return f;
}

/* Přidá prvek CO do podfront fronty KAM. */
static void
pridej_do_podfront (struct emdeboas *kam, int co)
{
  int i = (co - kam->a) / kam->s;

  if (kam->A[i]->min == INT_MAX)
    pridej (kam->B, i);
  pridej (kam->A[i], co);
}

/* Přidá prvek CO do fronty KAM. */
static void
pridej (struct emdeboas *kam, int co)
{
  int jednoprvkova = (kam->min == kam->max);
  int prvek = kam->min;

  kam->min = MIN (kam->min, co);
  kam->max = MAX (kam->max, co);

  if (kam->n <= 2 || kam->min == kam->max)
    return;

  if (jednoprvkova)
    pridej_do_podfront (kam, prvek);
  pridej_do_podfront (kam, co);
}

/* Odebere prvek CO z podfront fronty ODKUD. */
static void
odeber_z_podfront (struct emdeboas *odkud, int co)
{
  int i = (co - odkud->a) / odkud->s;

  odeber (odkud->A[i], co);
  if (odkud->A[i]->min == INT_MAX)
    odeber (odkud->B, i);
}

/* Odebere prvek CO z fronty ODKUD. */
static void
odeber (struct emdeboas *odkud, int co)
{
  if (co < odkud->min || co > odkud->max)
    return;

  if (odkud->min == odkud->max)
    {
      odkud->min = INT_MAX;
      odkud->max = INT_MIN;
      return;
    }

  if (odkud->n <= 2)
    {
      if (odkud->min == co)
	odkud->min = odkud->max;
      else if (odkud->max == co)
	odkud->max = odkud->min;

      return;
    }

  odeber_z_podfront (odkud, co);
  odkud->min = odkud->A[odkud->B->min]->min;
  odkud->max = odkud->A[odkud->B->max]->max;

  if (odkud->min == odkud->max)
    odeber_z_podfront (odkud, odkud->min);
}

/* Nalezne nejmenší prvek větší než CEHO ve frontě ODKUD.
 * Jestliže neexistuje, vrátí INT_MAX. */
static int
najdi_naslednika (struct emdeboas *kde, int ceho)
{
  int i;

  if (ceho >= kde->max)
    return INT_MAX;

  if (ceho < kde->min)
    return kde->min;

  if (kde->n <= 2)
    return kde->max;

  i = (ceho - kde->a) / kde->s;
  if (kde->A[i]->max > ceho)
    return najdi_naslednika (kde->A[i], ceho);
  else
    return kde->A[najdi_naslednika (kde->B, i)]->min;
}

int main (void)
{
  int n, p, m, i, x;
  char udalost[2];
  struct emdeboas *fronta;

  /* Načtení vstupů. */
  scanf ("%d%d%d", &n, &p, &m);
  fronta = nova_fronta (1, n);

  for (i = 0; i < p; i++)
    {
      scanf ("%d", &x);
      pridej (fronta, x);
    }

  /* Provádění operací. */
  for (i = 0; i < m; i++)
    {
      scanf ("%s %d", udalost, &x);
      switch (udalost[0])
	{
	case 'U':
	  odeber (fronta, x);
	  break;
	case 'K':
	  pridej (fronta, x);
	  break;
	case 'V':
	  x = najdi_naslednika (fronta, x);
	  printf ("%d\n", x == INT_MAX ? 0 : x);
	  break;
	}
    }
  return 0;
}