#include <bits/stdc++.h>
using namespace std;

using LL = long long;
const int N = 5e5 + 5;

template<int N>
struct SA {
  int rk[N], sa[N], h[N];
  void init(string s) {
    int n = s.size();
    iota(sa, sa + n, 0);
    sort(sa, sa + n, [&](int u, int v) {
      return s[u] < s[v];
    });
    rk[sa[0]] = 0;
    for (int i = 1; i < n; ++i)
      rk[sa[i]] = rk[sa[i - 1]] + (s[sa[i]] != s[sa[i - 1]]);
    for (int w = 1; rk[sa[n - 1]] != n - 1; w *= 2) {
      static int tmp[N], cnt[N];
      int o = 0;
      for (int i = n - w; i < n; ++i)
        tmp[o++] = i;
      for (int i = 0; i < n; ++i)
        if (sa[i] >= w) tmp[o++] = sa[i] - w;
      fill_n(cnt, n, 0);
      for (int i = 0; i < n; ++i)
        cnt[rk[i]]++;
      partial_sum(cnt, cnt + n, cnt);
      for (int i = n - 1; i >= 0; --i)
        sa[--cnt[rk[tmp[i]]]] = tmp[i];
      copy(rk, rk + n, tmp);
      rk[sa[0]] = 0;
      for (int i = 1; i < n; ++i)
        rk[sa[i]] = rk[sa[i - 1]] + (tmp[sa[i]] != tmp[sa[i - 1]]
            || sa[i - 1] + w == n || tmp[sa[i] + w] != tmp[sa[i - 1] + w]);
    }
    for (int i = 0, w = 0; i < n; ++i) {
      w = max(0, w - 1);
      if (rk[i] == 0) continue;
      while (i + w < n && sa[rk[i] - 1] + w < n
          && s[i + w] == s[sa[rk[i] - 1] + w]) ++w;
      h[rk[i] - 1] = w;
    }
  }
};

template<int N>
struct SegTree {
  int sz;
  struct Node {
    int ls, rs, cnt;
  } t[N];
  inline int ls(int u) {return t[u].ls;}
  inline int rs(int u) {return t[u].rs;}
  int modify(int u, int l, int r, int p) {
    t[++sz] = t[u];
    u = sz;
    t[u].cnt++;
    if (l != r) {
      int mid = (l + r) / 2;
      if (p <= mid)
        t[u].ls = modify(ls(u), l, mid, p);
      else
        t[u].rs = modify(rs(u), mid + 1, r, p);
    }
    return u;
  }
  int query(int u, int v, int l, int r, int k) {
    if (l == r) {
      return k == 1 ? l : -1;
    }
    int mid = (l + r) / 2;
    int num = t[ls(u)].cnt - t[ls(v)].cnt;
    if (k <= num)
      return query(ls(u), ls(v), l, mid, k);
    else
      return query(rs(u), rs(v), mid + 1, r, k - num);
  }
  void clear() {
    sz = 0;
  }
};

string s;
SA<N> sa_;
auto sa = sa_.sa, h = sa_.h, rk = sa_.rk;
int n, m, o[N], rt[N], RT, SZ, dep[N];
LL q[N], ans[N];
SegTree<N * 30> sgt;
vector<int> G[N];

int mn[N], mx[N], cnt[N];
void dfs(int u) {
  mn[u] = 1e9, mx[u] = -1e9;
  if (u < n) {
    mn[u] = mx[u] = rk[u];
    cnt[u]++;
  }
  for (auto v : G[u]) {
    dfs(v);
    mn[u] = min(mn[u], mn[v]);
    mx[u] = max(mx[u], mx[v]);
    cnt[u] += cnt[v];
  }
}

void sol(int u, LL &sum) {
  static int cur = 0;
  for (auto v : G[u]) {
    LL len = dep[v] - dep[u];
    LL val = LL(dep[u] + 1 + dep[v]) * len / 2;
    LL res = val * cnt[v];
    while (cur < m && q[o[cur]] <= sum + res) {
      int l = dep[u] + 1, r = dep[v];
      while (l < r) {
        int mid = (l + r) / 2;
        LL nval = LL(mid + dep[u] + 1) * (mid - dep[u]) / 2;
        if (q[o[cur]] <= sum + LL(cnt[v]) * nval) r = mid;
        else l = mid + 1;
      }
      LL A = q[o[cur]] - sum;
      if (l != dep[u] + 1) {
        A -= LL(dep[u] + 1 + l - 1) * (l - dep[u] - 1) / 2 * cnt[v];
      }
      int i = (A - 1) / l + 1;
      int j = (A - 1) % l + 1;
      int id = sgt.query(rt[mx[v] + 1], rt[mn[v]], 0, n - 1, i);
      ans[o[cur]] = id + j - 1;
      cur++;
    }
    sum += res;
    sol(v, sum);
  }
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> s;
  sa_.init(s);
  n = s.size();
  cin >> m;
  for (int i = 0; i < m; ++i)
    cin >> q[i];
  iota(o, o + m, 0);
  sort(o, o + m, [&](int u, int v) {
    return q[u] < q[v];
  });
  for (int i = 0; i < n; ++i) {
    rt[i + 1] = sgt.modify(rt[i], 0, n - 1, sa[i]);
  }
  RT = n, SZ = n + 1;
  static int tp, st[N];
  st[++tp] = RT;
  st[++tp] = sa[0];
  dep[sa[0]] = n - sa[0];
  for (int i = 1; i < n; ++i) {
    int u = sa[i];
    dep[u] = n - u;
    while (tp > 1 && h[i - 1] <= dep[st[tp - 1]]) {
      G[st[tp - 1]].emplace_back(st[tp]);
      --tp;
    }
    if (tp > 1 && h[i - 1] != dep[st[tp]]) {
      int v = SZ++;
      dep[v] = h[i - 1];
      G[v].emplace_back(st[tp]);
      st[tp] = v;
    }
    st[++tp] = u;
  }
  for (int i = 1; i < tp; ++i) {
    G[st[i]].emplace_back(st[i + 1]);
  }
  dfs(RT);
  LL sum = 0;
  sol(RT, sum);
  for (int i = 0; i < m; ++i)
    cout << ans[i] + 1 << "\n";
  return 0;
}