#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
inline int Rand() { return (0x7FFF & rand()) << 16 | (0xFFFF & rand()); }
struct TNode {
  int V, P, C;
  bool rev;
  TNode *L, *R;
  TNode() {}
  TNode(int v) {
    V = v;
    P = Rand();
    C = 1;
    rev = false;
    L = R = nullptr;
  }
};
typedef TNode *TNodePtr;
class Treap {
 private:
  TNodePtr root;
  static int size(TNodePtr node) { return node ? node->C : 0; }
  static void updateAttrs(TNodePtr node) {
    if (node) {
      node->C = 1 + Treap::size(node->L) + Treap::size(node->R);
    }
  }
  static void push(TNodePtr node) {
    if (node && node->rev) {
      node->rev = false;
      swap(node->L, node->R);
      if (node->L) node->L->rev ^= true;
      if (node->R) node->R->rev ^= true;
    }
  }
  TNodePtr erase(TNodePtr cur, int key) {
    if (!cur) return nullptr;
    if (!key) return cur;
    Treap::push(cur);
    int sz = Treap::size(cur->L) + 1;
    if (sz == key) {
      return Treap::merge(cur->L, cur->R);
    } else if (sz < key) {
      cur->R = erase(cur->R, key - sz);
    } else {
      cur->L = erase(cur->L, key);
    }
    Treap::updateAttrs(cur);
    return cur;
  }
  static pair<TNodePtr, TNodePtr> split(TNodePtr cur, int key) {
    if (!cur) return {nullptr, nullptr};
    if (!key) return {nullptr, cur};
    Treap::push(cur);
    int sz = Treap::size(cur->L) + 1;
    TNodePtr L, R;
    if (sz <= key) {
      tie(L, R) = split(cur->R, key - sz);
      cur->R = L;
      L = cur;
    } else {
      tie(L, R) = split(cur->L, key);
      cur->L = R;
      R = cur;
    }
    Treap::updateAttrs(L);
    Treap::updateAttrs(R);
    return {L, R};
  }
  static TNodePtr merge(TNodePtr left, TNodePtr right) {
    if (!left || !right) return left ? left : right;
    Treap::push(left);
    Treap::push(right);
    if (left->P > right->P) {
      left->R = merge(left->R, right);
      Treap::updateAttrs(left);
      return left;
    } else {
      right->L = merge(left, right->L);
      Treap::updateAttrs(right);
      return right;
    }
  }
  int get(TNodePtr cur, int key) {
    if (!cur) return -1;
    Treap::push(cur);
    int sz = Treap::size(cur->L) + 1;
    if (sz == key) {
      return cur->V;
    } else if (sz < key) {
      return get(cur->R, key - sz);
    } else {
      return get(cur->L, key);
    }
  }
  void set(TNodePtr cur, int key, int val) {
    if (cur) {
      Treap::push(cur);
      Treap::updateAttrs(cur);
      int sz = Treap::size(cur->L) + 1;
      if (sz == key) {
        cur->V = val;
      } else if (sz < key) {
        set(cur->R, key - sz, val);
      } else {
        set(cur->L, key, val);
      }
    }
  }
  void toVector(TNodePtr cur, vector<int> &V) {
    if (cur) {
      Treap::push(cur);
      Treap::updateAttrs(cur);
      toVector(cur->L, V);
      V.push_back(cur->V);
      toVector(cur->R, V);
    }
  }

 public:
  Treap() { root = nullptr; }
  inline int size() { return Treap::size(root); }
  inline void insert(int X, int at) {
    if (!root) {
      root = new TNode(X);
    } else {
      TNodePtr L, R;
      tie(L, R) = Treap::split(root, at - 1);
      L = Treap::merge(L, new TNode(X));
      root = Treap::merge(L, R);
    }
  }
  inline int get(int at) {
    if (!at || at > Treap::size(root)) return -1;
    return get(root, at);
  }
  inline void set(int at, int val) {
    if (at && at <= Treap::size(root)) set(root, at, val);
  }
  inline void erase(int at) {
    if (at && at <= Treap::size(root)) {
      root = erase(root, at);
    }
  }
  inline void reverse(int from, int to) {
    if (from && to <= Treap::size(root) && from <= to) {
      TNodePtr L, M, R;
      tie(L, R) = Treap::split(root, from - 1);
      tie(M, R) = Treap::split(R, to - from + 1);
      M->rev ^= true;
      Treap::push(M);
      root = Treap::merge(L, M);
      root = Treap::merge(root, R);
    }
  }
  inline void shift(int from, int to, int shift) {
    if (from && shift && to <= Treap::size(root) && from <= to) {
      TNodePtr L, M, R, midL, midR;
      shift %= (to - from + 1);
      tie(L, R) = Treap::split(root, from - 1);
      tie(M, R) = Treap::split(R, to - from + 1);
      tie(midL, midR) = Treap::split(M, (to - from + 1) - shift);
      M = Treap::merge(midR, midL);
      root = Treap::merge(L, M);
      root = Treap::merge(root, R);
    }
  }
  inline vector<int> toVector() {
    vector<int> V;
    toVector(root, V);
    return V;
  }
};
int n, m, q, b;
Treap T;
int main() {
  scanf("%d%d%d", &n, &q, &m);
  for (int i = 1, ai; i <= n; ++i) {
    scanf("%d", &ai);
    T.insert(ai, i);
  }
  for (int i = 1, type, L, R; i <= q; ++i) {
    scanf("%d%d%d", &type, &L, &R);
    if (type == 1)
      T.shift(L, R, 1);
    else
      T.reverse(L, R);
  }
  while (m--) {
    scanf("%d", &b);
    printf("%d ", T.get(b));
  }
  return 0;
}
