#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <set>
#include <map>
#include <complex>
#include <iostream>
#include <time.h>
#include <stack>
#include <stdlib.h>
#include <memory.h>
#include <bitset>
#include <math.h>
#include <string>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

const int MaxN = 2e3 + 10;
const int MOD = 1e9 + 7;
const int INF = 1e9;

int n, m, q, vis[MaxN];
int g[MaxN][MaxN];
int who[MaxN], sz;
pair < int, int > vec[MaxN * MaxN];

bool connected() {
  queue < int > q;
  q.push(1);
  vis[1] = 1;
  int all = 0;
  while (!q.empty()) {
    int v = q.front();
    q.pop();
    ++all;
    for (int i = 1; i <= n; ++i) {
      if (!vis[i] && g[v][i]) {
        vis[i] = 1;
        q.push(i);
      }
    }
  }
  return all == n;
}

int getWho(int v) {
  return v == who[v] ? v : who[v] = getWho(who[v]);
}

int main() {
//  freopen("input.txt", "r", stdin);
  scanf("%d%d%d", &n, &m, &q);
  assert (1 <= n && n <= 2000);
  assert (1 <= m && m <= 200000);
  assert (1 <= q && q <= 20000);
  vector < pair < int, pair < int, int > > > all, mst;
  for (int i = 1; i <= m; ++i) {
    int x, y, c;
    scanf("%d%d%d", &x, &y, &c);
    assert (1 <= x && x <= n);
    assert (1 <= y && y <= n);
    assert (1 <= c && c <= 1000000000);
    assert (x != y && g[x][y] == 0);
    g[x][y] = g[y][x] = c;
    all.push_back(make_pair(c, make_pair(x, y)));
  }
  assert (connected());
  sort(all.begin(), all.end());
  long long wmst = 0;
  for (int i = 1; i <= n; ++i) {
    who[i] = i;
  }
  for (int i = 0; i < (int)all.size(); ++i) {
    int u = all[i].second.first, v = all[i].second.second;
    if (getWho(u) != getWho(v)) {
      mst.push_back(all[i]);
      who[getWho(u)] = getWho(v);
      wmst += all[i].first;
    }
  }
  int ltype = 3;
  while (q --> 0) {
    int type;
    scanf("%d", &type);
    assert (1 <= type && type <= 3);
    if (type == 1) {
      int u, v;
      scanf("%d%d", &u, &v);
      assert (1 <= u && u <= n);
      assert (1 <= v && v <= n);
      if (u > v) {
        swap(u, v);
      }
      assert (g[u][v] > 0);
      bool fnd = false;
      for (int i = 0; i < sz; ++i) {
        if (u == vec[i].first && v == vec[i].second) {
          fnd = true;
          break;
        }
      }
      if (!fnd) {
        vec[sz++] = make_pair(u, v);
      }
    } else if (type == 2) {
      int u, v;
      scanf("%d%d", &u, &v);
      assert (1 <= u && u <= n);
      assert (1 <= v && v <= n);
      if (u > v) {
        swap(u, v);
      }
      for (int i = 0; i < sz; ++i) {
        if (u == vec[i].first && v == vec[i].second) {
          swap(vec[i], vec[sz - 1]);
          sz--;
          break;
        }
      }
    } else {
      if (ltype != 3) {
        for (int i = 1; i <= n; ++i) {
          who[i] = i;
        }
        wmst = 0;
        for (auto it = 0; it < sz; ++it) {
          int u = vec[it].first, v = vec[it].second;
          if (u & 1) {
            swap(u, v);
          }
          who[getWho(u)] = getWho(v);
        }
        for (int i = 0; i < (int)mst.size(); ++i) {
          int u = mst[i].second.first, v = mst[i].second.second;
          if (u & 1) {
            swap(u, v);
          }
          if (getWho(u) != getWho(v)) {
            who[getWho(u)] = getWho(v);
            wmst += mst[i].first;
          }
        }
      }
      printf("%lld\n", wmst);
    }
    ltype = type;
  }
  return 0;
}