#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
  char ch;
  x = 0;
  bool fl = false;
  while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
  for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
    ;
  (fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
  if (x / 10) output(x / 10);
  putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
  if (x < 0) putchar('-'), x = -x;
  output(x);
  putchar(' ');
}
template <class T>
inline void prt(T a[], long long st, long long nd) {
  for (register long long i = st; i <= nd; ++i) ot(a[i]);
  putchar('\n');
}
namespace Modulo {
const long long mod = 998244353;
inline long long ad(long long x, long long y) {
  return x + y >= mod ? x + y - mod : x + y;
}
inline long long sub(long long x, long long y) { return ad(x, mod - y); }
inline long long mul(long long x, long long y) {
  return (long long)x * y % mod;
}
inline void inc(long long &x, long long y) { x = ad(x, y); }
inline void inc2(long long &x, long long y) { x = mul(x, y); }
inline long long qm(long long x, long long y = mod - 2) {
  long long ret = 1;
  while (y) {
    if (y & 1) ret = mul(x, ret);
    x = mul(x, x);
    y >>= 1;
  }
  return ret;
}
template <class... Args>
inline long long ad(const long long a, const long long b, const Args &...args) {
  return ad(ad(a, b), args...);
}
template <class... Args>
inline long long mul(const long long a, const long long b,
                     const Args &...args) {
  return mul(mul(a, b), args...);
}
}  // namespace Modulo
namespace Miracle {
const long long N = 1e6 + 5;
struct node {
  long long ch[2], val;
  long long sz, rev;
  long long prio;
} t[N];
long long cur;
long long rt;
long long nc(long long v) {
  long long r = ++cur;
  t[cur].val = v;
  t[cur].sz = 1;
  t[cur].rev = 0;
  t[cur].ch[0] = t[cur].ch[1] = 0;
  t[cur].prio = rand();
  return r;
}
void pushup(long long x) { t[x].sz = t[t[x].ch[0]].sz + t[t[x].ch[1]].sz + 1; }
void rev(long long x) {
  if (!x) return;
  swap(t[x].ch[0], t[x].ch[1]);
  t[x].rev ^= 1;
}
void pushdown(long long x) {
  if (!x) return;
  if (t[x].rev) {
    rev(t[x].ch[0]);
    rev(t[x].ch[1]);
    t[x].rev = 0;
  }
}
void split(long long now, long long k, long long &x, long long &y) {
  if (!now) {
    x = 0;
    y = 0;
    return;
  }
  if (t[now].val <= k) {
    x = now;
    split(t[now].ch[1], k, t[now].ch[1], y);
  } else {
    y = now;
    split(t[now].ch[0], k, x, t[now].ch[0]);
  }
  pushup(now);
}
long long merge(long long x, long long y) {
  if (!x || !y) return x + y;
  if (t[x].prio < t[y].prio) {
    pushdown(x);
    t[x].ch[1] = merge(t[x].ch[1], y);
    pushup(x);
    return x;
  } else {
    pushdown(y);
    t[y].ch[0] = merge(x, t[y].ch[0]);
    pushup(y);
    return y;
  }
}
long long kth(long long now, long long k) {
  long long x = now;
  while (1) {
    if (t[t[x].ch[0]].sz + 1 == k) return t[x].val;
    long long tmp = t[t[x].ch[0]].sz + 1;
    if (tmp < k) {
      k -= tmp;
      x = t[x].ch[1];
    } else {
      x = t[x].ch[0];
    }
  }
}
void ins(long long v) {
  long long x, y;
  split(rt, v - 1, x, y);
  rt = merge(merge(x, nc(v)), y);
}
struct qs {
  long long id;
  long long num;
  long long typ;
  bool friend operator<(qs a, qs b) {
    if (a.num != b.num) return a.num < b.num;
    return a.typ < b.typ;
  }
} q[N];
long long ans[N];
long long tot;
long long ct[N];
vector<long long> mem[N];
long long main() {
  srand(19260817);
  long long st, n, m;
  rd(st);
  rd(n);
  rd(m);
  long long x;
  for (register long long i = 1; i <= st; ++i) {
    rd(x);
    ++ct[x];
  }
  for (register long long i = 1; i <= m; ++i) {
    rd(q[i].num);
    q[i].id = i;
    q[i].typ = 0;
  }
  tot = m;
  long long mi = 0x3f3f3f3f, mx = 0;
  for (register long long i = 1; i <= n; ++i) {
    mem[ct[i]].push_back(i);
    mi = min(mi, ct[i]);
    mx = max(mx, ct[i]);
  }
  long long ptr = mi + 1;
  long long nz = mem[mi].size();
  long long las = mi;
  long long ny = st;
  while (ptr <= mx) {
    if (mem[ptr].size()) {
      long long cos = ptr - las;
      cos *= nz;
      ++tot;
      q[tot].id = ptr;
      q[tot].num = ny + cos;
      q[tot].typ = 1;
      las = ptr;
      ny = ny + cos;
      nz += mem[ptr].size();
    }
    ++ptr;
  }
  sort(q + 1, q + tot + 1);
  ny = st;
  nz = mem[mi].size();
  for (const auto &y : mem[mi]) {
    ins(y);
  }
  for (register long long i = 1; i <= tot; ++i) {
    if (q[i].typ == 0) {
      long long now = q[i].num - ny;
      now %= nz;
      if (now == 0) now = nz;
      ans[q[i].id] = kth(rt, now);
    } else {
      ny = q[i].num;
      nz += mem[q[i].id].size();
      for (const auto &y : mem[q[i].id]) {
        ins(y);
      }
    }
  }
  for (register long long i = 1; i <= m; ++i) {
    printf("%d\n", ans[i]);
  }
  return 0;
}
}  // namespace Miracle
signed main() {
  Miracle::main();
  return 0;
}
