#include <bits/stdc++.h>
using namespace std;
int n, q, m;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 300005;
struct node {
  node* l;
  node* r;
  int sum, val;
  int key, prior;
  int size;
  bool rev;
};
node t[maxn];
int cnt = 0;
node* create(int idx, int val) {
  node* x;
  if (cnt < maxn)
    x = &t[cnt++];
  else
    x = new node();
  x->key = idx;
  x->l = NULL;
  x->r = NULL;
  x->prior = uniform_int_distribution<int>(0, 1e9)(rng);
  x->sum = val;
  x->val = val;
  return x;
}
template <typename node>
struct Treap {
  node* tree;
  Treap() { tree = NULL; }
  int32_t size(node* x) { return x ? x->size : 0; }
  void upd_sz(node* x) {
    if (x) x->size = size(x->l) + size(x->r) + 1;
  }
  void reset(node* x) {
    if (x) x->sum = x->val;
  }
  void combine(node*& t, node* l, node* r) {
    if (!l)
      t->sum = r->sum;
    else if (!r)
      t->sum = l->sum;
    else
      t->sum = l->sum + r->sum;
  }
  void combine(node*& t) {
    if (!t) return;
    reset(t);
    combine(t, t->l, t);
    combine(t, t, t->r);
  }
  void pushdown(node* t) {
    if (!t || !t->rev) return;
    if (t->l) {
      t->l->rev = !(t->l->rev);
      swap(t->l->l, t->l->r);
    }
    if (t->r) {
      t->r->rev = !(t->r->rev);
      swap(t->r->l, t->r->r);
    }
    t->rev = 0;
  }
  void split(node* t, node*& left, node*& right, int32_t key, int32_t add = 0) {
    pushdown(t);
    if (!t) {
      left = right = NULL;
      return;
    }
    int32_t curidx = add + size(t->l);
    if (curidx <= key)
      split(t->r, t->r, right, key, curidx + 1), left = t;
    else
      split(t->l, left, t->l, key, add), right = t;
    upd_sz(t);
    combine(t);
  }
  void merge(node*& t, node* l, node* r) {
    pushdown(l);
    pushdown(r);
    if (!l)
      t = r;
    else if (!r)
      t = l;
    else if (l->prior > r->prior)
      merge(l->r, l->r, r), t = l;
    else
      merge(r->l, l, r->l), t = r;
    upd_sz(t);
    combine(t);
  }
  void reverse(node*& t) {
    swap(t->l, t->r);
    t->rev = !t->rev;
  }
  void query(node*& t, int l, int r) {
    if (!t) return;
    node *le, *ri, *mid;
    split(t, le, mid, l - 1);
    split(mid, mid, ri, r - l);
    reverse(mid);
    merge(mid, mid, ri);
    merge(t, le, mid);
  }
  void query(int l, int r) { query(tree, l, r); }
  void cycshift(node* t, int l, int r) {
    if (!t) return;
    node *a, *b, *c, *d, *e, *f;
    split(t, a, b, r);
    split(a, c, d, l - 1);
    split(d, e, f, r - l - 1);
    merge(b, e, b);
    merge(a, c, f);
    merge(t, a, b);
  }
  void cycshift(int l, int r) { cycshift(tree, l, r); }
  void insert(node*& t, int32_t idx, int32_t val) {
    node* tmp = create(idx, val);
    node* templ;
    node* tempr;
    node* mid;
    split(t, templ, tempr, idx - 1);
    merge(mid, templ, tmp);
    merge(t, mid, tempr);
  }
  void insert(int idx, int val) { insert(tree, idx, val); }
  int get(node* t, int idx) {
    node* left;
    node* right;
    node* mid;
    split(t, left, right, idx - 1);
    split(right, mid, right, 0);
    int ans = mid->val;
    merge(right, mid, right);
    merge(t, left, right);
    return ans;
  }
  int get(int idx) { return get(tree, idx); }
};
Treap<node> tp;
signed main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cin >> n >> q >> m;
  for (int i = 0; i < n; ++i) {
    int x;
    cin >> x;
    tp.insert(i, x);
  }
  for (int i = 0; i < q; ++i) {
    int ty;
    cin >> ty;
    if (ty == 2) {
      int a, b;
      cin >> a >> b;
      a--;
      b--;
      tp.query(a, b);
    } else {
      int a, b;
      cin >> a >> b;
      a--;
      b--;
      tp.cycshift(a, b);
    }
  }
  for (int i = 0; i < m; ++i) {
    int x;
    cin >> x;
    cout << tp.get(x - 1) << " ";
  }
  return 0;
}
