#include <stdio.h>
#include <math.h>
#include <string.h>
#include <algorithm>
#include <vector>
int rd()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = 0;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = x * 10 + (c ^ '0');
        c = getchar();
    }
    return f ? x : -x;
}
void wr(int x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        wr(x / 10);
    putchar((x % 10) ^ '0');
}
const int N = 50010;
const int M = 100010;
const int B = 810;

int n, m, q;
// edge and info
struct edge
{
    int u, v, w, id;
    void input(int i = 0) { u = rd(), v = rd(), w = rd(), id = i; }
    bool operator<(const edge& o) const { return (w ^ o.w) ? (w > o.w) : (id < o.id); }
} e[M];
int eid_to_idx[M];
void resort_edge()
{
    std::sort(e + 1, e + m + 1);
    for (int i = 1; i <= m; ++i)
        eid_to_idx[e[i].id] = i;
}

struct info
{
    int pos, val, t;
    info(int p = 0, int v = 0, int _t = 0) : pos(p), val(v), t(_t) {}
    bool operator<(const info& o) const { return (val ^ o.val) ? (val > o.val) : (t < o.t); }
    // type 1 : modify 2 : query
    void input(int _t) { pos = rd(), val = rd(), t = _t; }
};
info tmp;
std::vector<info> modify, query;

namespace rollback_dsu
{
    int n;
    int stk[M], stk_sz;
    int f[N], sz[N];
    void init(int _n)
    {
        n = _n;
        for (int i = 1; i <= n; ++i)
            f[i] = i, sz[i] = 1;
    }
    int getf(int x) { return (f[x] == x) ? x : getf(f[x]); }
    void merge(int x, int y)
    {
        int fx = getf(x), fy = getf(y);
        if (!(fx ^ fy))
            return;
        if (sz[fx] < sz[fy])
            std::swap(fx, fy);
        stk[++stk_sz] = fy, f[fy] = fx, sz[fx] += sz[fy]; 
    }
    void rollback_single()
    {
        int fy = stk[stk_sz--];
        sz[f[fy]] -= sz[fy], f[fy] = fy;
    }
    void rollback(int t = 0)
    {
        while (stk_sz > t)
            rollback_single();
    }
}

std::vector<info> blk_modify;
// no-modify : 0 have-modify : -1
// for edge modified, val determined by time 
int time_status[M];

bool is_query[M];
int ans[M];

void solve()
{
    resort_edge();
    std::sort(query.begin(), query.end());

    // add unmodify and modify to blk
    for (int i = 0; i < modify.size(); ++i)
    {
        time_status[modify[i].pos] = -1;
        int eidx = eid_to_idx[modify[i].pos];
        blk_modify.push_back(info(modify[i].pos, e[eidx].w, 0));
    }
    for (int i = 0; i < modify.size(); ++i)
        blk_modify.push_back(modify[i]);

    rollback_dsu::rollback();
    for (int _q = 0, eg = 1; _q < query.size(); ++_q)
    {
        // add edge for val >= query.val
        while (eg <= m && e[eg].w >= query[_q].val)
        {
            // no modify, just add this edge
            if (!time_status[e[eg].id])
                rollback_dsu::merge(e[eg].u, e[eg].v);
            ++eg;
        }
        int rollback_time = rollback_dsu::stk_sz;
        // determine edge modified or not by query time
        for (int i = 0; i < blk_modify.size(); ++i)
            if (blk_modify[i].t <= query[_q].t)
                time_status[blk_modify[i].pos] = blk_modify[i].val;
        // add edge if val >= query.val
        for(int i = 0; i < modify.size(); ++i)
        {
            int eidx = eid_to_idx[modify[i].pos];
            if (time_status[modify[i].pos] >= query[_q].val)
                rollback_dsu::merge(e[eidx].u, e[eidx].v);    
        } 
        int rt = rollback_dsu::getf(query[_q].pos);
        ans[query[_q].t] = rollback_dsu::sz[rt];
        rollback_dsu::rollback(rollback_time);
    }
    // update modify
    for (int i = 0; i < modify.size(); ++i)
    {
        int eidx = eid_to_idx[modify[i].pos];
        e[eidx].w = modify[i].val;
        time_status[blk_modify[i].pos] = 0;
    }
    blk_modify.clear(), modify.clear(), query.clear();
}

int main()
{
    n = rd(), m = rd();
    for (int i = 1; i <= m; ++i)
        e[i].input(i);
    rollback_dsu::init(n);
    
    q = rd();
    for (int i = 1; i <= q; ++i)
    {
        int op = rd();
        tmp.input(i);
        if (op & 1)
            modify.push_back(tmp);
        else
            is_query[i] = 1, query.push_back(tmp);
        if (!(i % B))
            solve();
    }
    if (q % B)
        solve();
    for (int i = 1; i <= q; ++i)
        if (is_query[i])
            wr(ans[i]), putchar('\n');
}