// Love the way you Lie.

#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e5 + 1;

map<int,int> mp[maxn];

int par[maxn];
int sz[maxn];

struct DSU {
    DSU() {
        for (int i = 0; i < maxn; ++i) {
            par[i] = i;
            sz[i] = 1;
        }
    }
    int find(int x) {
        if (x == par[x]) return x;
        return par[x] = find(par[par[x]]);
    }
    void join(int x, int y) {
        int px = find(x), py = find(y);
        if (px == py) return;
        if (sz[px] > sz[py]) swap(px, py);
        par[px] = py;
        sz[py] += sz[px];
        for (auto it: mp[px]) mp[py][it.first] += it.second;
    }
};

void solve() {
    int n, q;
    cin >> n >> q;
    DSU ins;
    vector<int> col(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> col[i];
        mp[i][col[i]]++;
    }
    while (q--) {
        int type;
        cin >> type;
        if (type == 1) {
            int a, b;
            cin >> a >> b;
            ins.join(a, b);
        }
        else {
            int x, y;
            cin >> x >> y;
            x = ins.find(x);
            auto it = mp[x].find(y);
            cout << (it == mp[x].end() ? 0 : it->second) << '\n';
        }
    }
}

#define single_test

signed main() {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int t = 1;
    #ifndef single_test
        cin >> t;
    #endif
    for (int i = 1; i <= t; ++i) {
        // cout << "Case #" << i << ": ";
        solve();
    }
    return 0;
}

https://atcoder.jp/contests/abc183/submissions/18122849

/**
    Lost Arrow (Aryan V S)
    Sunday 2020-11-15
**/

#ifdef LOST_IN_SPACE
#  if   __cplusplus > 201703LL
#    include "lost_pch1.h" // C++20
#  elif __cplusplus > 201402LL
#    include "lost_pch2.h" // C++17
#  else
#    include "lost_pch3.h" // C++14
#  endif
#else
#  include <bits/stdc++.h>
#endif

namespace competitive_programming::inline utility { }
namespace competitive_programming::debugging      { }
namespace competitive_programming::io             { }

namespace competitive_programming::utility {

    class timer {
      private:
        std::chrono::time_point <std::chrono::steady_clock> begin, end;
      public:
#ifdef LOST_IN_SPACE
         timer () : begin (std::chrono::steady_clock::now()), end () { }
        ~timer () {
            end = std::chrono::steady_clock::now();
            std::cerr << "\n\nDuration: " << std::chrono::duration <double> (end - begin).count() << "s\n";
        }
#else
         timer () : begin (), end () { }
        ~timer () { }
#endif
    };
}

constexpr bool test_cases = false;

auto solve () -> void {
    int64_t n, w;
    std::cin >> n >> w;
    std::vector <int64_t> s (n), t (n), p (n);
    for (int i = 0; i < n; ++i) {
        std::cin >> s [i] >> t [i] >> p [i];
    }

    const int m = 2e5 + 42;
    std::vector <int64_t> time (m, 0);
    for (int i = 0; i < n; ++i) {
        time [s [i]] += p [i];
        time [t [i]] -= p [i];
    }

    bool okay = true;
    for (int i = 0; i < m; ++i) {
        if (i > 0)
            time [i] += time [i - 1];
        if (time [i] > w) {
            okay = false;
            break;
        }
    }

    std::cout << (okay ? "Yes" : "No") << '\n';
}

int main () {

    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.precision(10);
    std::cerr.precision(10);
    std::cout << std::fixed << std::boolalpha;
    std::cerr << std::fixed << std::boolalpha;

    competitive_programming::timer t;
    int32_t cases = 1;
    if (test_cases)
        std::cin >> cases;
    while (cases--)
        solve();

    return 0;
}

// g++.exe -Wall -Weffc++ -Wextra -pedantic -std=c++20 -g -D_GLIBCXX_DEBUG -DLOST_IN_SPACE -H