#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int val[N];
int rev[N];
int NNN = 0;
struct node {
  node *l, *r;
  int prior, size;
  int val;
  bool rev;
  node() {}
  node(int v) {
    l = r = NULL;
    prior = rand();
    size = 1;
    val = v;
    rev = false;
  }
};
int NN = 0;
node pool[N];
inline node* new_treap(int val) {
  pool[NN] = node(val);
  return &pool[NN++];
}
inline int size(node* t) { return (t ? t->size : 0); }
void push(node* t) {
  if (t->rev) {
    swap(t->l, t->r);
    if (t->l) {
      t->l->rev ^= 1;
    }
    if (t->r) {
      t->r->rev ^= 1;
    }
    t->rev = false;
  }
}
void pull(node* t) { t->size = 1 + size(t->l) + size(t->r); }
node* merge(node* a, node* b) {
  if (!a || !b) {
    return a ? a : b;
  }
  if (a->prior > b->prior) {
    push(a);
    a->r = merge(a->r, b);
    pull(a);
    return a;
  } else {
    push(b);
    b->l = merge(a, b->l);
    pull(b);
    return b;
  }
}
void split(node* t, node*& a, node*& b, int v) {
  if (!t) {
    a = NULL;
    b = NULL;
    return;
  }
  push(t);
  if (size(t->l) < v) {
    a = t;
    split(t->r, a->r, b, v - size(t->l) - 1);
    pull(a);
  } else {
    b = t;
    split(t->l, a, b->l, v);
    pull(b);
  }
}
void reverse(node*& t, int l, int r) {
  node *a, *b, *c, *d;
  split(t, a, b, r);
  split(a, c, d, l - 1);
  d->rev ^= 1;
  t = merge(merge(c, d), b);
}
void revolve(node*& t, int l, int r, int v) {
  int len = r - l + 1;
  node *a, *b, *c, *d;
  split(t, a, b, r);
  split(a, c, d, l - 1);
  v = v % len;
  node *e, *f;
  split(d, e, f, len - v);
  t = merge(merge(c, merge(f, e)), b);
}
void recalc(node*& t) {
  push(t);
  if (t->l) recalc(t->l);
  rev[NNN++] = t->val;
  if (t->r) recalc(t->r);
  pull(t);
}
int main() {
  int n, q, m;
  node* root = NULL;
  scanf("%d%d%d", &n, &q, &m);
  for (int i = 0; i < n; i++) {
    scanf("%d", &val[i]);
    root = merge(root, new_treap(val[i]));
  }
  for (int i = 0; i < q; i++) {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    if (a == 1) {
      revolve(root, b, c, 1);
    } else {
      reverse(root, b, c);
    }
  }
  NNN = 0;
  recalc(root);
  for (int i = 0; i < m; i++) {
    int a;
    scanf("%d", &a);
    a--;
    printf("%d ", rev[a]);
  }
}
