#include <bits/stdc++.h>
using namespace std;
const int MN = 100010;
string S;
int N, Q;
vector<int> P[26];
int L[26][MN], R[26][MN];
struct Info {
  int l, r, id;
  bool operator<(const Info &i) const { return l < i.l; }
};
vector<Info> seg[MN];
vector<vector<int> > pref[26], suff[26];
int dp1[MN * 200], dp2[MN][26];
int solve2(int idx, int c) {
  if (dp2[idx][c] != -1) {
    return dp2[idx][c];
  }
  dp2[0][c] = (P[c][0] - 1 >= 0) ? dp1[pref[c][0][P[c][0] - 1]] : 0;
  if (idx == 0) return dp2[0][c];
  int p = 0;
  for (int i = idx; i >= 0; i--) {
    if (dp2[i][c] != -1) {
      p = i;
      break;
    }
  }
  for (int i = p + 1; i <= idx; i++) {
    dp2[i][c] =
        dp2[i - 1][c] ^ ((P[c][i] - P[c][i - 1] - 2) >= 0
                             ? dp1[pref[c][i][P[c][i] - P[c][i - 1] - 2]]
                             : 0);
  }
  return dp2[idx][c];
}
int solve1(int l, int r) {
  vector<int> chk(26, 0);
  for (int i = 0; i < 26; i++) {
    int a = R[i][l];
    int b = L[i][r];
    if (a > b) continue;
    int tmp1 = 0;
    if (P[i][a] - l - 1 < 0)
      tmp1 = 0;
    else if ((int)suff[i][a].size() > P[i][a] - l - 1) {
      tmp1 = dp1[suff[i][a][P[i][a] - l - 1]];
    } else {
      tmp1 = dp1[pref[i][a][P[i][a] - l - 1]];
    }
    int tmp2 =
        (r - P[i][b] - 1 >= 0) ? dp1[pref[i][b + 1][r - P[i][b] - 1]] : 0;
    int Xor = tmp1 ^ tmp2 ^ solve2(a, i) ^ solve2(b, i);
    if (Xor < 26) chk[Xor] = 1;
  }
  for (int i = 0; i < 26; i++)
    if (!chk[i]) return i;
  return 26;
}
int main() {
  cin >> S;
  N = S.size();
  for (int i = 0; i < S.size(); i++) {
    P[S[i] - 'a'].push_back(i);
  }
  for (int i = 0; i < 26; i++) {
    int la = -1;
    for (int j = 0; j < S.size(); j++) {
      if (S[j] - 'a' == i) la++;
      L[i][j] = la;
    }
    la = P[i].size();
    for (int j = (int)S.size() - 1; j >= 0; j--) {
      if (S[j] - 'a' == i) la--;
      R[i][j] = la;
    }
  }
  int cnt = 0;
  for (int i = 0; i < 26; i++) {
    int st = 0;
    pref[i] = suff[i] = vector<vector<int> >(P[i].size() + 1);
    for (int j = 0; j < P[i].size(); j++) {
      if (P[i][j] - st) {
        for (int k = st; k < P[i][j]; k++) {
          seg[k].push_back({st, k, cnt});
          pref[i][j].push_back(cnt);
          cnt++;
        }
        for (int k = P[i][j] - 1; k > st; k--) {
          seg[P[i][j] - 1].push_back({k, P[i][j] - 1, cnt});
          suff[i][j].push_back(cnt);
          cnt++;
        }
      }
      st = P[i][j] + 1;
    }
    if (N - st) {
      for (int k = st; k < N; k++) {
        seg[k].push_back({st, k, cnt});
        pref[i][P[i].size()].push_back(cnt);
        cnt++;
      }
      for (int k = N - 1; k > st; k--) {
        seg[N - 1].push_back({k, N - 1, cnt});
        suff[i][P[i].size()].push_back(cnt);
        cnt++;
      }
    }
  }
  memset(dp2, -1, sizeof(dp2));
  for (int len = 0; len < N; len++) {
    sort(seg[len].begin(), seg[len].end());
    for (int x = (int)seg[len].size() - 1; x >= 0; x--) {
      int l = seg[len][x].l;
      int r = seg[len][x].r;
      int n = seg[len][x].id;
      dp1[n] = solve1(l, r);
    }
  }
  scanf("%d", &Q);
  for (int i = 0; i < Q; i++) {
    int l, r;
    scanf("%d %d", &l, &r);
    l--;
    r--;
    if (solve1(l, r))
      printf("Alice\n");
    else
      printf("Bob\n");
  }
}
