#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
  return int(c.size());
}
using ll = long long;
constexpr const char nl = '\n', sp = ' ';
template <class _Node, class Container = deque<_Node>>
struct Splay {
  using Node = _Node;
  Container TR;
  deque<Node *> deleted;
  static_assert(Node::HAS_PAR, "Splay Node must have parent pointer");
  template <class T>
  Node *makeNode(const T &v) {
    if (deleted.empty()) {
      TR.emplace_back(v);
      return &TR.back();
    }
    Node *x = deleted.back();
    deleted.pop_back();
    *x = typename Container::value_type(v);
    return x;
  }
  bool isRoot(Node *x) { return !x->p || (x != x->p->l && x != x->p->r); }
  void connect(Node *x, Node *p, bool hasCh, bool isL) {
    if (x) x->p = p;
    if (hasCh) (isL ? p->l : p->r) = x;
  }
  void rotate(Node *x) {
    Node *p = x->p, *g = p->p;
    bool isRootP = isRoot(p), isL = x == p->l;
    connect(isL ? x->r : x->l, p, true, isL);
    connect(p, x, true, !isL);
    connect(x, g, !isRootP, !isRootP && p == g->l);
    p->update();
  }
  void splay(Node *x) {
    while (!isRoot(x)) {
      Node *p = x->p, *g = p->p;
      if (!isRoot(p)) g->propagate();
      p->propagate();
      x->propagate();
      if (!isRoot(p)) rotate((x == p->l) == (p == g->l) ? p : x);
      rotate(x);
    }
    x->propagate();
    x->update();
  }
  template <class F>
  void applyToRange(Node *&root, int i, int j, F f) {
    int sz = root ? root->sz : 0;
    if (i <= 0 && sz - 1 <= j) {
      f(root);
      if (root) {
        root->propagate();
        root->update();
      }
    } else if (i <= 0) {
      Node *l = select(root, j + 1)->l;
      connect(nullptr, root, true, true);
      root->update();
      connect(l, nullptr, false, true);
      f(l);
      if (l) {
        l->propagate();
        l->update();
      }
      connect(l, root, true, true);
      root->update();
    } else if (sz - 1 <= j) {
      Node *r = select(root, i - 1)->r;
      connect(nullptr, root, true, false);
      root->update();
      connect(r, nullptr, false, false);
      f(r);
      if (r) {
        r->propagate();
        r->update();
      }
      connect(r, root, true, false);
      root->update();
    } else {
      Node *r = select(root, i - 1)->r;
      connect(nullptr, root, true, false);
      root->update();
      connect(r, nullptr, false, false);
      Node *l = select(r, j - i + 1)->l;
      connect(nullptr, r, true, true);
      r->update();
      connect(l, nullptr, false, true);
      f(l);
      if (l) {
        l->propagate();
        l->update();
      }
      connect(l, r, true, true);
      r->update();
      connect(r, root, true, false);
      root->update();
    }
  }
  Node *select(Node *&root, int k) {
    Node *last = nullptr;
    while (root) {
      (last = root)->propagate();
      int t = root->l ? root->l->sz : 0;
      if (t > k)
        root = root->l;
      else if (t < k) {
        root = root->r;
        k -= t + 1;
      } else
        break;
    }
    if (root)
      splay(root);
    else if (last)
      splay(root = last);
    return root;
  }
  int index(Node *&root, Node *x) {
    root = x;
    if (!root) return -1;
    splay(root);
    return root->l ? root->l->sz : 0;
  }
  template <class T, class Comp>
  pair<int, Node *> getFirst(Node *&root, const T &v, Comp cmp) {
    pair<int, Node *> ret(0, nullptr);
    Node *last = nullptr;
    for (Node *x = root; x;) {
      (last = x)->propagate();
      if (!cmp(x->val, v)) {
        root = ret.second = x;
        x = x->l;
      } else {
        ret.first += 1 + (x->l ? x->l->sz : 0);
        x = x->r;
      }
    }
    if (root)
      splay(root);
    else if (last)
      splay(root = last);
    return ret;
  }
  template <class F>
  Node *buildRec(int l, int r, F &f) {
    if (l > r) return nullptr;
    int m = l + (r - l) / 2;
    Node *left = buildRec(l, m - 1, f);
    Node *ret = makeNode(f()), *right = buildRec(m + 1, r, f);
    connect(left, ret, ret, true);
    connect(right, ret, ret, false);
    ret->update();
    return ret;
  }
  template <class F>
  Node *build(int N, F f) {
    return buildRec(0, N - 1, f);
  }
  void clear(Node *x) {
    if (!x) return;
    clear(x->l);
    deleted.push_back(x);
    clear(x->r);
  }
};
template <class Tree>
struct DynamicRangeOperations : public Tree {
  using Node = typename Tree::Node;
  using Data = typename Node::Data;
  using Lazy = typename Node::Lazy;
  Node *root;
  using Tree::applyToRange;
  using Tree::build;
  using Tree::clear;
  using Tree::getFirst;
  using Tree::makeNode;
  using Tree::select;
  template <class F>
  DynamicRangeOperations(int N, F f) : root(build(N, f)) {}
  template <class It>
  DynamicRangeOperations(It st, It en)
      : DynamicRangeOperations(en - st, [&] { return *st++; }) {}
  DynamicRangeOperations() : root(nullptr) {}
  template <class T>
  void insert_at(int i, const T &v) {
    applyToRange(root, i, i - 1, [&](Node *&x) { x = makeNode(v); });
  }
  template <class F>
  void insert_at(int i, int n, F f) {
    applyToRange(root, i, i - 1, [&](Node *&x) { x = build(n, f); });
  }
  template <class It>
  void insert_at(int i, It st, It en) {
    insert_at(i, en - st, [&] { return *st++; });
  }
  template <class T, class Comp>
  void insert(const T &v, Comp cmp) {
    insert_at(getFirst(root, v, cmp).first, v);
  }
  void erase_at(int i) {
    applyToRange(root, i, i, [&](Node *&x) {
      clear(x);
      x = nullptr;
    });
  }
  void erase_at(int i, int j) {
    if (i <= j)
      applyToRange(root, i, j, [&](Node *&x) {
        clear(x);
        x = nullptr;
      });
  }
  template <class Comp>
  void erase(const Data &v, Comp cmp) {
    pair<int, Node *> p = getFirst(root, v, cmp);
    if (p.second && !cmp(p.second->val, v) && !cmp(v, p.second->val))
      erase_at(p.first);
  }
  void update(int i, const Lazy &v) {
    applyToRange(root, i, i, [&](Node *&x) { x->apply(v); });
  }
  template <const int _ = Node::RANGE_UPDATES>
  typename enable_if<_>::type update(int i, int j, const Lazy &v) {
    if (i <= j) applyToRange(root, i, j, [&](Node *&x) { x->apply(v); });
  }
  template <const int _ = Node::RANGE_REVERSALS>
  typename enable_if<_>::type reverse(int i, int j) {
    if (i <= j) applyToRange(root, i, j, [&](Node *&x) { x->reverse(); });
  }
  int size() { return root ? root->sz : 0; }
  Data at(int i) { return select(root, i)->val; }
  template <class Comp>
  pair<int, Data *> lower_bound(const Data &v, Comp cmp) {
    pair<int, Node *> p = getFirst(root, v, cmp);
    return make_pair(p.first, p.second ? &p.second->val : nullptr);
  }
  template <class Comp>
  pair<int, Data *> upper_bound(const Data &v, Comp cmp) {
    return lower_bound(
        v, [&](const Data &a, const Data &b) { return !cmp(b, a); });
  }
  template <class Comp>
  pair<int, Data *> find(const Data &v, Comp cmp) {
    pair<int, Data *> ret = lower_bound(v, cmp);
    if (!ret.second || cmp(v, *(ret.second)) || cmp(*(ret.second), v))
      return make_pair(size(), nullptr);
    return ret;
  }
  template <const int _ = Node::RANGE_QUERIES>
  typename enable_if<_, Data>::type query(int i, int j) {
    Data ret = Node::qdef();
    if (i <= j) applyToRange(root, i, j, [&](Node *&x) { ret = x->sbtr; });
    return ret;
  }
  vector<Data> values() {
    vector<Data> ret;
    ret.reserve(size());
    function<void(Node *)> dfs = [&](Node *x) {
      if (!x) return;
      x->propagate();
      dfs(x->l);
      ret.push_back(x->val);
      dfs(x->r);
    };
    dfs(root);
    return ret;
  }
};
template <class T>
struct NodeVal {
  using Data = T;
  using Lazy = Data;
  const static int RANGE_UPDATES = false, RANGE_QUERIES = false;
  const static int RANGE_REVERSALS = true, HAS_PAR = true;
  bool rev;
  int sz;
  NodeVal *l, *r, *p;
  Data val;
  NodeVal(const Data &v)
      : rev(false), sz(1), l(nullptr), r(nullptr), p(nullptr), val(v) {}
  void update() {
    sz = 1;
    if (l) sz += l->sz;
    if (r) sz += r->sz;
  }
  void propagate() {
    if (rev) {
      swap(l, r);
      rev = false;
      if (l) l->reverse();
      if (r) r->reverse();
    }
  }
  void apply(const Lazy &v) { val = v; }
  void reverse() { rev = !rev; }
};
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int N, Q, M;
  cin >> N >> Q >> M;
  DynamicRangeOperations<Splay<NodeVal<int>>> TR(N, [&] {
    int a;
    cin >> a;
    return a;
  });
  using Node = decltype(TR)::Node;
  for (int i = 0; i < Q; i++) {
    int t, l, r;
    cin >> t >> l >> r;
    --l;
    --r;
    if (t == 1) {
      if (l < r) {
        Node *&root = TR.root, *y;
        TR.applyToRange(root, r, r, [&](Node *&x) {
          y = x;
          x = nullptr;
        });
        TR.applyToRange(root, l, l - 1, [&](Node *&x) { x = y; });
      }
    } else
      TR.reverse(l, r);
  }
  for (int i = 0; i < M; i++) {
    int b;
    cin >> b;
    cout << TR.at(--b) << " \n"[i == M - 1];
  }
  return 0;
}
