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


int N[2], Q;
vector<int> A[2], B[2];
vector<int> C[2];
vector<int> O, X[4];
int K;

vector<vector<int>> graph[2];
int zeit[2];
vector<int> dep[2], dis[2], fin[2];
void dfs(int h, int u, int p) {
  dep[h][u] = (~p) ? (dep[h][p] + 1) : 0;
  dis[h][u] = zeit[h]++;
  for (const int v : graph[h][u]) if (p != v) {
    dfs(h, v, u);
  }
  fin[h][u] = zeit[h];
}

namespace brute {
vector<int> run() {
  vector<int> css[2] = {C[0], C[1]};
  int lt = 0;
  vector<int> ans(Q, 0);
  vector<int> on(K, -1);
  for (int q = 0; q < Q; ++q) {
    if (O[q] == 1) {
      const int R[2] = {X[0][q], X[1][q]};
      const int D[2] = {X[2][q] ^ lt, X[3][q] ^ lt};
// cerr<<COLOR("33")<<"calc "<<R[0]<<","<<D[0]<<" "<<R[1]<<","<<D[1]<<COLOR()<<endl;
      for (int h = 0; h < 2; ++h) for (int u = 0; u < N[h]; ++u) {
        if (dis[h][R[h]] <= dis[h][u] && dis[h][u] < fin[h][R[h]] && dep[h][u] <= dep[h][R[h]] + D[h]) {
// cerr<<"  "<<h<<" "<<u<<endl;
          on[css[h][u]] = q;
        }
      }
      for (int k = 0; k < K; ++k) if (on[k] == q) {
        ++ans[q];
      }
      lt = ans[q];
    } else if (O[q] == 2) {
// cerr<<COLOR("33")<<"change "<<X[0][q]<<" "<<X[1][q]<<endl;
      css[0][X[0][q]] = X[1][q];
    } else {
      assert(false);
    }
  }
  return ans;
}
}  // brute


int main() {
  for (; ~scanf("%d%d%d", &N[0], &N[1], &Q); ) {
    for (int h = 0; h < 2; ++h) {
      A[h].resize(N[h] - 1);
      B[h].resize(N[h] - 1);
      for (int i = 0; i < N[h] - 1; ++i) {
        scanf("%d%d", &A[h][i], &B[h][i]);
        --A[h][i];
        --B[h][i];
      }
    }
    for (int h = 0; h < 2; ++h) {
      C[h].resize(N[h]);
      for (int u = 0; u < N[h]; ++u) {
        scanf("%d", &C[h][u]);
      }
    }
    O.resize(Q);
    X[0].assign(Q, 0);
    X[1].assign(Q, 0);
    X[2].assign(Q, 0);
    X[3].assign(Q, 0);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d%d", &O[q], &X[0][q], &X[1][q]);
      if (O[q] == 1) {
        scanf("%d%d", &X[2][q], &X[3][q]);
        --X[0][q];
        --X[1][q];
      } else if (O[q] == 2) {
        --X[0][q];
      } else {
        assert(false);
      }
    }
    
    {
      vector<int> cs;
      for (int h = 0; h < 2; ++h) for (int u = 0; u < N[h]; ++u) {
        cs.push_back(C[h][u]);
      }
      for (int q = 0; q < Q; ++q) if (O[q] == 2) {
        cs.push_back(X[1][q]);
      }
      sort(cs.begin(), cs.end());
      cs.erase(unique(cs.begin(), cs.end()), cs.end());
      K = cs.size();
      auto indexOf = [&](int c) -> int {
        return lower_bound(cs.begin(), cs.end(), c) - cs.begin();
      };
      for (int h = 0; h < 2; ++h) for (int u = 0; u < N[h]; ++u) {
        C[h][u] = indexOf(C[h][u]);
      }
      for (int q = 0; q < Q; ++q) if (O[q] == 2) {
        cs[q] = indexOf(cs[q]);
      }
    }
// cerr<<"K = "<<K<<", C[0] = "<<C[0]<<", C[1] = "<<C[1]<<endl;
    
    for (int h = 0; h < 2; ++h) {
      graph[h].assign(N[h], {});
      for (int i = 0; i < N[h] - 1; ++i) {
        graph[h][A[h][i]].push_back(B[h][i]);
        graph[h][B[h][i]].push_back(A[h][i]);
      }
      zeit[h] = 0;
      dep[h].assign(N[h], -1);
      dis[h].assign(N[h], -1);
      fin[h].assign(N[h], -1);
      dfs(h, 0, -1);
    }
    
    const auto ans = brute::run();
    for (int q = 0; q < Q; ++q) if (O[q] == 1) {
      printf("%d\n", ans[q]);
    }
  }
  return 0;
}