#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


template <class Flow> struct MaxFlow {
  // Watch out when using types other than int and long long.
  static constexpr Flow FLOW_EPS = 1e-10L;
  static constexpr Flow FLOW_INF = std::numeric_limits<Flow>::max();
  
  int n, m;
  vector<int> ptr, nxt, zu;
  vector<Flow> capa;

  explicit MaxFlow(int n_) : n(n_), m(0), ptr(n_, -1) {}
  void ae(int u, int v, Flow w0, Flow w1 = 0) {
    assert(0 <= u); assert(u < n);
    assert(0 <= v); assert(v < n);
    assert(0 <= w0);
    assert(0 <= w1);
    nxt.push_back(ptr[u]); zu.push_back(v); capa.push_back(w0); ptr[u] = m++;
    nxt.push_back(ptr[v]); zu.push_back(u); capa.push_back(w1); ptr[v] = m++;
  }

  vector<int> see, lev, que;

  Flow augment(int u, int t, Flow limFlow) {
    if (u == t) return limFlow;
    for (int &i = see[u]; ~i; i = nxt[i]) if (capa[i] > FLOW_EPS) {
      const int v = zu[i];
      if (lev[u] < lev[v]) {
        const Flow f = augment(v, t, min(limFlow, capa[i]));
        if (f > FLOW_EPS) { capa[i] -= f; capa[i ^ 1] += f; return f; }
      }
    }
    return 0;
  }
  bool bfs(int s, int t) {
    for (int u = 0; u < n; ++u) { see[u] = ptr[u]; lev[u] = -1; }
    auto head = que.begin(), tail = que.begin();
    for (lev[*tail++ = s] = 0; head != tail; ) {
      const int u = *head++;
      for (int i = ptr[u]; ~i; i = nxt[i]) if (capa[i] > FLOW_EPS) {
        const int v = zu[i];
        if (!~lev[v]) {
          lev[*tail++ = v] = lev[u] + 1;
          if (v == t) return true;
        }
      }
    }
    return false;
  }
  Flow run(int s, int t, Flow limFlow = FLOW_INF) {
    see.resize(n); lev.resize(n); que.resize(n);
    Flow flow = 0;
    for (; flow + FLOW_EPS < limFlow && bfs(s, t); ) {
      for (Flow f; (f = augment(s, t, limFlow - flow)) > FLOW_EPS; flow += f) {}
    }
    return flow;
  }
};

////////////////////////////////////////////////////////////////////////////////


namespace bm {
constexpr int LIM_N0 = 200'010;
constexpr int LIM_N1 = 200'010;
constexpr int LIM_M = 400'010;
int n0, n1, m, as[LIM_M], bs[LIM_M];
int to[LIM_N0], fr[LIM_N1], tof;
int pt[LIM_N0 + 2], zu[LIM_M], used[LIM_N0], lev[LIM_N0], que[LIM_N0], *qb, *qe;
void init(int n0_, int n1_) {
  n0 = n0_; n1 = n1_; m = 0;
}
int ae(int u, int v) {
  as[m] = u; bs[m] = v; return m++;
}
int augment(int u) {
  used[u] = tof;
  for (int j = pt[u]; j < pt[u + 1]; ++j) {
    const int v = zu[j];
    const int w = fr[v];
    if (!~w || (used[w] != tof && lev[u] < lev[w] && augment(w))) {
      to[u] = v; fr[v] = u; return 1;
    }
  }
  return 0;
}
int run() {
  memset(pt, 0, (n0 + 2) * sizeof(int));
  for (int i = 0; i < m; ++i) ++pt[as[i] + 2];
  for (int u = 2; u <= n0; ++u) pt[u + 1] += pt[u];
  for (int i = 0; i < m; ++i) zu[pt[as[i] + 1]++] = bs[i];
  memset(to, ~0, n0 * sizeof(int));
  memset(fr, ~0, n1 * sizeof(int));
  memset(used, ~0, n0 * sizeof(int));
  for (tof = 0; ; ) {
    qb = qe = que; memset(lev, ~0, n0 * sizeof(int));
    for (int u = 0; u < n0; ++u) if (!~to[u]) lev[*qe++ = u] = 0;
    for (; qb != qe; ) {
      const int u = *qb++;
      for (int j = pt[u]; j < pt[u + 1]; ++j) {
        const int w = fr[zu[j]];
        if (~w && !~lev[w]) lev[*qe++ = w] = lev[u] + 1;
      }
    }
    int f = 0;
    for (int u = 0; u < n0; ++u) if (!~to[u]) f += augment(u);
    if (!f) return tof;
    tof += f;
  }
}

// s: true, t: false (s: reachable from unmatched left)
// vertex cover: (0: false, 0: true)
// independent set: (0: true, 1: false)
bool side0[LIM_N0], side1[LIM_N1];
void dfs(int u) {
  if (!side0[u]) {
    side0[u] = true;
    for (int j = pt[u]; j < pt[u + 1]; ++j) {
      const int v = zu[j];
      if (!side1[v]) {
        side1[v] = true;
        const int w = fr[v];
        if (~w) dfs(w);
      }
    }
  }
}
void minCut() {
  memset(side0, 0, n0 * sizeof(bool));
  memset(side1, 0, n1 * sizeof(bool));
  for (int u = 0; u < n0; ++u) if (!~to[u]) dfs(u);
}
}  // namespace bm


namespace enu_tree {
constexpr int MAX_N = 16;

using Id = pair<int, int>;

// (largest subtree, remaining tree)
vector<pair<Id, Id>> T[MAX_N + 1];

inline int TLen(int n) {
  return T[n].size();
}

// tie-break (n/2) + (n/2)
inline bool isCentroid(int n, int x) {
  return (T[n][x].first <= T[n][x].second);
}

// |non-root subtree| <= limDn
void build(int limDn = MAX_N - 1) {
  for (int n = 0; n <= MAX_N; ++n) T[n].clear();
  T[1].emplace_back(Id(0, 0), Id(0, 0));
  for (int dn = 1; dn < MAX_N && dn <= limDn; ++dn) for (int dx = 0; dx < TLen(dn); ++dx) {
    for (int n = 1; n + dn <= MAX_N; ++n) for (int x = 0; x < TLen(n); ++x) {
      T[n + dn].emplace_back(Id(dn, dx), Id(n, x));
    }
  }
}

void getParDfs(int n, int x, int p, int &id, vector<int> &par) {
  const int u = id++;
  par[u] = p;
  for (int nn = n, xx = x; nn > 1; ) {
    const auto &t = T[nn][xx];
    getParDfs(t.first.first, t.first.second, u, id, par);
    nn = t.second.first;
    xx = t.second.second;
  }
}
vector<int> getPar(int n, int x) {
  assert(1 <= n); assert(n <= MAX_N);
  assert(0 <= x); assert(x < TLen(n));
  int id = 0;
  vector<int> par(n, -1);
  getParDfs(n, x, -1, id, par);
  return par;
}
vector<int> getPar(const Id &id) {
  return getPar(id.first, id.second);
}
}  // enu_tree

////////////////////////////////////////////////////////////////////////////////


void exper() {
  using namespace enu_tree;
  build(MAX_N / 2);
  constexpr int maxK = MAX_N;
  for (int n = 2; n <= MAX_N; n += 2) {
    vector<int> freq(maxK + 1, 0);
    for (int x = 0; x < TLen(n); ++x) if (isCentroid(n, x)) {
      const auto par = getPar(n, x);
      vector<int> cols(n, 0);
      for (int u = 1; u < n; ++u) cols[u] = cols[par[u]] ^ 1;
      int ns[2] = {};
      vector<int> ids(n);
      for (int u = 0; u < n; ++u) ids[u] = ns[cols[u]]++;
      if (ns[0] == n/2 && ns[1] == n/2) {
        int lo = 0, hi = n/2;
        for (; lo + 1 < hi; ) {
          const int mid = (lo + hi) / 2;
          MaxFlow<int> mf((n << 1) + 2);
          const int src = n << 1, snk = n << 1 | 1;
          for (int u = 0; u < n; ++u) {
            mf.ae(u << 1, u << 1 | 1, mid);
            if (cols[u]) {
              mf.ae(u << 1 | 1, snk, 1);
            } else {
              mf.ae(src, u << 1, 1);
            }
          }
          for (int u = 1; u < n; ++u) {
            mf.ae(par[u] << 1 | 1, u << 1, n/2);
            mf.ae(u << 1 | 1, par[u] << 1, n/2);
          }
          const int f = mf.run(src, snk);
          ((f >= n/2) ? hi : lo) = mid;
        }
        const int kk = 2 * hi - 1;
        
        for (int k = 1; k <= maxK; k += 2) {
          bm::init(k * (n/2), k * (n/2));
          for (int i = 0; i < k; ++i) {
            for (int u = 1; u < n; ++u) {
              if ((i & 1) ^ cols[u]) {
                bm::ae(i * (n/2) + ids[par[u]], i * (n/2) + ids[u]);
              } else {
                bm::ae(i * (n/2) + ids[u], i * (n/2) + ids[par[u]]);
              }
            }
          }
          for (int i = 0; i < k - 1; ++i) {
            for (int u = 0; u < n; ++u) {
              if ((i & 1) ^ cols[u]) {
                bm::ae((i + 1) * (n/2) + ids[u], i * (n/2) + ids[u]);
              } else {
                bm::ae(i * (n/2) + ids[u], (i + 1) * (n/2) + ids[u]);
              }
            }
          }
          const int res = bm::run();
          if (res == k * (n/2)) {
            ++freq[k];
            if (k >= 5) {
              cout << par << ": " << k << endl;
            }
            if (k != kk) {
              cerr << "FAIL: " << par << ": " << k << " " << kk << endl;
            }
            assert(k == kk);
            goto found;
          }
        }
        ++freq[0];
        cerr << par << ": " << 0 << endl;
       found:{}
      }
    }
    cerr << n << ": " << freq << endl;
  }
}


constexpr int INF = 1001001001;

int N, M, Q;
vector<int> A, B;
vector<int> O, U, V, K;

vector<vector<int>> graph;
vector<int> rs;

int cnt[2];
void dfs(int r, int u, int p, int side) {
  rs[u] = r;
  ++cnt[side];
  for (const int v : graph[u]) if (p != v) {
    dfs(r, v, u, side ^ 1);
  }
}

// [u][IN(u)'s side][OUT(u)'s side] -> min cut
int dp[200'010][2][2];
void solve(int u, int p, int side, int k) {
  for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) {
    dp[u][x][y] = 0
      + ((side == 0 && x == 1) ? 1 : 0)
      + ((x == 0 && y == 1) ? k : 0)
      + ((y == 0 && side == 1) ? 1 : 0)
    ;
  }
  for (const int v : graph[u]) if (p != v) {
    solve(v, u, side ^ 1, k);
    for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) {
      int mn = INF;
      for (int xx = 0; xx < 2; ++xx) for (int yy = 0; yy < 2; ++yy) {
        if (y == 0 && xx == 1) continue;
        if (yy == 0 && x == 1) continue;
        chmin(mn, dp[v][xx][yy]);
      }
      dp[u][x][y] += mn;
    }
  }
}


namespace subA {
vector<int> run() {
cerr<<"[subA::run]"<<endl;
  graph.assign(N, {});
  for (int i = 0; i < M; ++i) {
    graph[A[i]].push_back(B[i]);
    graph[B[i]].push_back(A[i]);
  }
  rs.assign(N, -1);
  vector<int> needs(N, INF);
  for (int r = 0; r < N; ++r) if (!~rs[r]) {
    cnt[0] = cnt[1] = 0;
    dfs(r, r, -1, 0);
    if (cnt[0] == cnt[1]) {
      int lo = 0, hi = cnt[0];
      for (; lo + 1 < hi; ) {
        const int mid = (lo + hi) / 2;
        solve(r, -1, 0, mid);
        int mn = INF;
        for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) {
          chmin(mn, dp[r][x][y]);
        }
        ((mn >= cnt[0]) ? hi : lo) = mid;
      }
      needs[r] = hi;
    }
  }
  vector<int> anss;
  for (int q = 0; q < Q; ++q) {
    assert(O[q] == 3);
    int ans;
    if (K[q] % 2 != 0) {
      ans = ((K[q] + 1) / 2 >= needs[rs[U[q]]]) ? 1 : 0;
    } else {
      ans = 1;
    }
    anss.push_back(ans);
  }
  return anss;
}
}  // subA


namespace brute {
vector<int> run() {
cerr<<"[brute::run]"<<endl;
  rs.assign(N, -1);
  set<pair<int, int>> es;
  for (int i = 0; i < M; ++i) {
    es.insert(minmax(A[i], B[i]));
  }
  vector<int> anss;
  for (int q = 0; q < Q; ++q) {
    if (O[q] == 1) {
      es.insert(minmax(U[q], V[q]));
    } else if (O[q] == 2) {
      es.erase(minmax(U[q], V[q]));
    } else if (O[q] == 3) {
      int ans;
      if (K[q] % 2 != 0) {
        graph.assign(N, {});
        for (const auto &e : es) {
          graph[e.first].push_back(e.second);
          graph[e.second].push_back(e.first);
        }
        cnt[0] = cnt[1] = 0;
        dfs(U[q], U[q], -1, 0);
        if (cnt[0] == cnt[1]) {
          solve(U[q], -1, 0, (K[q] + 1) / 2);
          int mn = INF;
          for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) {
            chmin(mn, dp[U[q]][x][y]);
          }
          ans = (mn >= cnt[0]) ? 1 : 0;
        } else {
          ans = 0;
        }
      } else {
        ans = 1;
      }
      anss.push_back(ans);
    } else {
      assert(false);
    }
  }
  return anss;
}
}  // brute


int main() {
  // exper();
  
  for (; ~scanf("%d%d%d", &N, &M, &Q); ) {
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    O.assign(Q, -1);
    U.assign(Q, -1);
    V.assign(Q, -1);
    K.assign(Q, -1);
    for (int q = 0; q < Q; ++q) {
      scanf("%d", &O[q]);
      if (O[q] == 1 || O[q] == 2) {
        scanf("%d%d", &U[q], &V[q]);
        --U[q];
        --V[q];
      } else if (O[q] == 3) {
        scanf("%d%d", &U[q], &K[q]);
        --U[q];
      } else {
        assert(false);
      }
    }
    
    vector<int> anss;
    if (O == vector<int>(Q, 3)) {
      anss = subA::run();
    } else {
      anss = brute::run();
    }
    for (const int ans : anss) {
      puts(ans ? "Bob" : "Alice");
    }
  }
  return 0;
}