Untitled

#include <bits/stdc++.h>

using namespace std;

#define ll long long

void FIO() {
#ifndef ONLINE_JUDGE
    freopen("../in.txt", "r", stdin);
    freopen("../out.txt", "w", stdout);
#endif
}

const int N = 1e5 + 50;
const int MOD = 1e9 + 7;

struct item {
    long long x;
};

struct segTree {
    int size;
    vector<item> values;

    item NEUTRAL_ELEMENT = {1};

    item merge(item a, item b) {
        return {a.x * b.x % MOD};
    }

    void init(int n) {
        size = 1;
        while (size < n) size *= 2;
        values.resize(2 * size, {0});
    }

    void set(int i, int v, int x, int lx, int rx) {
        if (rx - lx == 1) {
            values[x].x += v;
            return;
        }

        int m = (lx + rx) / 2;
        if (i < m)
            set(i, v, 2 * x + 1, lx, m);
        else
            set(i, v, 2 * x + 2, m, rx);
        values[x] = merge(values[2 * x + 1], values[2 * x + 2]);
    }

    void set(int i, int v) {
        set(i, v, 0, 0, size);
    }

    item calc(int l, int r, int x, int lx, int rx) {
        if (lx >= r || l >= rx)
            return NEUTRAL_ELEMENT;
        if (lx >= l && rx <= r)
            return values[x];

        int m = (lx + rx) / 2;
        item s1 = calc(l, r, 2 * x + 1, lx, m);
        item s2 = calc(l, r, 2 * x + 2, m, rx);

        return merge(s1, s2);
    }

    item calc(int l, int r) {
        return calc(l, r, 0, 0, size);
    }
};


void solve() {
    int n, q;
    cin >> n >> q;

    vector<int> v(n), comp;
    for (int &i: v) cin >> i, comp.push_back(i);
    vector<array<int, 3>> queries(q);
    for (int i = 0; i < q; ++i) {
        cin >> queries[i][0] >> queries[i][1] >> queries[i][2];
        comp.push_back(queries[i][2]);
        if (queries[i][0] == 2) comp.push_back(queries[i][1]);
    }
    sort(comp.begin(), comp.end());
    comp.resize(unique(comp.begin(), comp.end()) - comp.begin());
    segTree st;
    st.init(comp.size() + 5);
    for (int &i: v) {
        i = lower_bound(comp.begin(), comp.end(), i) - comp.begin();
        st.set(i, 1);
    }


    for (auto [t, x, y]: queries) {
        if (t == 1) {
            --x;
            st.set(v[x], -1);
            v[x] = lower_bound(comp.begin(), comp.end(), y) - comp.begin();
            st.set(v[x], 1);
        } else {
            int l = lower_bound(comp.begin(), comp.end(), x) - comp.begin();
            int r = lower_bound(comp.begin(), comp.end(), y) - comp.begin();
            if (r - l != y - x) {
                cout << "0" << '\n';
            } else {
                cout << st.calc(l, r + 1).x << '\n';
            }
        }
    }

}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    FIO();

    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}