/**
 * Patryk Kisielewski
 * 
 * Potyczki Algorytmiczne 2024
 * Zadanie: KOL - Kolorowy las [A]
*/
#include <unordered_map>
#include <set>
#include <vector>
#include <utility>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <bitset>

using namespace std;

const long long MAX_DISTANCE = 1'000'000'000'000'000LL;

struct Query
{
    int type;
    long a, b, k;
    long long d = 0, z;
};

struct Node
{
    Node();
    Node* parent;
    unordered_map<Node*, long long> edges;
    long color;
};

Node::Node() : parent(this), color(0L) {}

long n, m, q;
Node* tree;
long global_color = 0;
bool no_mods;
bool no_distance;

void changeRoot(Node* a) {
    if (a->parent == a) {
        return;
    }
    changeRoot(a->parent);
    if (no_distance) {
        a->color = a->parent->color;
    }
    a->parent->parent = a;
    a->parent = a;
}

Node* getRoot(Node* a) {
    while (a->parent != a) {
        a = a->parent;
    }
    return a;
}

void addEdgeBase(Node* a, Node* b, long long d) {
    changeRoot(a);
    a->parent = b;
    a->edges.emplace(make_pair(b, d));
    b->edges.emplace(make_pair(a, d));
}

void removeEdgeBase(Node* a, Node* b) {
    a->edges.erase(b);
    b->edges.erase(a);
    if (a->parent == b) {
        a->parent = a;
    } else {
        b->parent = b;
    }
}

void colorBase(Node* prev, Node* current, long long z, int k) {
    if (z < 0) return;
    current->color = k;
    for (auto& next : current->edges) {
        if (next.first != prev) {
            colorBase(current, next.first, z - next.second, k);
        }
    }
}

long getColorBase(Node* node) {
    return node->color;
}

void removeEdgeNoDistance(Node* a, Node* b) {
    a->edges.erase(b);
    b->edges.erase(a);
    if (a->parent == b) {
        a->color = getRoot(a)->color;
        a->parent = a;
    } else {
        b->color = getRoot(b)->color;
        b->parent = b;
    }
}

void colorNoDistance(Node* prev, Node* current, long long z, int k) {
    getRoot(current)->color = k;
}

long getColorNoDistance(Node* node) {
    return getRoot(node)->color;
}

void colorNoModsAndDistance(Node* prev, Node* current, long long z, int k) {
    global_color = k;
}

long getColorNoModsAndDistance(Node* node) {
    return global_color;
}

int main() {

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    void (*addEdge)(Node* a, Node* b, long long d) = addEdgeBase;
    void (*removeEdge)(Node* a, Node* b) = removeEdgeBase;
    void (*color)(Node* prev, Node* current, long long z, int k) = colorBase;
    long (*getColor)(Node* a) = getColorBase;

    cin >> n >> m >> q;

    tree = new Node[n+1];

    long a, b;
    long long d;

    for (int i = 0; i < m; ++i) {
        cin >> a >> b >> d;
        addEdgeBase(tree + a, tree + b, d);
    }

    vector<Query> queries(q);

    no_mods = (m + 1 == n);
    no_distance = true;

    for (auto& query : queries) {
        cin >> query.type;
        switch (query.type) {
            case 1:
                cin >> query.a >> query.b >> query.d;
                no_mods = false;
                break;
            case 2:
                cin >> query.a >> query.b;
                no_mods = false;
                break;
            case 3:
                cin >> query.a >> query.z >> query.k;
                if (query.k != MAX_DISTANCE) no_distance = false;
                break;
            case 4:
                cin >> query.a;
        }
    }

    if (no_distance) {
        removeEdge = removeEdgeNoDistance;
        if (no_mods) {
            color = colorNoModsAndDistance;
            getColor = getColorNoModsAndDistance;
        } else {
            color = colorNoDistance;
            getColor = getColorNoDistance;
        }
    }

    for (auto& query : queries) {
        switch (query.type) {
            case 1:
                addEdge(tree + query.a, tree + query.b, query.d);
                break;
            case 2:
                removeEdge(tree + query.a, tree + query.b);
                break;
            case 3:
                color(nullptr, tree + query.a, query.z, query.k);
                break;
            case 4:
                cout << getColor(tree + query.a) << '\n';
        }
    }

    return 0;
}