#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")


constexpr int INF = 1001001001;

int C;
struct Data {
  int cnt[2], cost[2][2];
  Data() : cnt{}, cost{} {}
  void up() {
    swap(cnt[0], cnt[1]);
    ++cnt[0];
    int sub[2][2];
    memcpy(sub, cost, sizeof(cost));
    for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) {
      sub[x][y] += 0
        + ((x == 1) ? 1 : 0)
        + ((x == 0 && y == 1) ? C : 0)
      ;
    }
    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, sub[yy ^ 1][xx ^ 1]);
      }
      cost[x][y] = mn;
    }
  }
};
ostream &operator<<(ostream &os, const Data &f) {
  return os << "(" << f.cnt[0] << "," << f.cnt[1] << "; " << f.cost[0][0] << "," << f.cost[0][1] << "," << f.cost[1][0] << "," << f.cost[1][1] << ")";
}
Data operator+(const Data &f, const Data &g) {
  Data h;
  for (int s = 0; s < 2; ++s) h.cnt[s] = f.cnt[s] + g.cnt[s];
  for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) h.cost[x][y] = f.cost[x][y] + g.cost[x][y];
  return h;
}
Data operator-(const Data &f, const Data &g) {
  Data h;
  for (int s = 0; s < 2; ++s) h.cnt[s] = f.cnt[s] - g.cnt[s];
  for (int x = 0; x < 2; ++x) for (int y = 0; y < 2; ++y) h.cost[x][y] = f.cost[x][y] - g.cost[x][y];
  return h;
}


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


namespace brute {
vector<vector<int>> graph;
Data solve(int u, int p) {
  Data f;
  for (const int v : graph[u]) if (p != v) {
    f = f + solve(v, u);
  }
  f.up();
// cerr<<u<<" "<<p<<": "<<f<<endl;
  return f;
}

vector<int> run() {
cerr<<"[brute::run]"<<endl;
  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);
        }
        C = (K[q] + 1) / 2;
        const auto res = solve(U[q], -1);
        if (res.cnt[0] == res.cnt[1]) {
          ans = (res.cost[0][1] >= res.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);
      }
    }
    
    const auto anss = brute::run();
    for (const int ans : anss) {
      puts(ans ? "Bob" : "Alice");
    }
  }
  return 0;
}