#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <cassert>
using namespace std;

pair<map<long long, int>, vector<long long>> Compress(const vector<long long>& lst) {
    vector<long long> decomp(lst.begin(), lst.end());
    sort(decomp.begin(), decomp.end());
    decomp.erase(unique(decomp.begin(), decomp.end()), decomp.end());
    map<long long, int> comp;
    for (int i = 0; i < decomp.size(); ++i) {
        comp[decomp[i]] = i;
    }
    return {comp, decomp};
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--) {
        int N;
        cin >> N;
        vector<long long> A(N);
        for (int i = 0; i < N; ++i) {
            cin >> A[i];
        }

        const long long INF = 1LL << 60;
        vector<long long> to_compress;
        for (int i = 0; i < N; ++i) {
            to_compress.push_back(A[i] + i);
            to_compress.push_back(A[i] - i + INF);
        }

        auto [comp, decomp] = Compress(to_compress);
        int le = comp.size();
        vector<vector<pair<int, int>>> graph(le);

        for (int n = 0; n < N; ++n) {
            int i = comp[A[n] + n];
            int j = comp[A[n] - n + INF];
            graph[i].emplace_back(j, n);
            graph[j].emplace_back(i, n);
        }

        vector<int> tour;
        vector<bool> seen(le, false);
        vector<int> parents(le, -1);
        for (int x = 0; x < le; ++x) {
            if (seen[x]) continue;
            queue<int> q;
            q.push(x);
            seen[x] = true;
            while (!q.empty()) {
                int current = q.front();
                q.pop();
                tour.push_back(current);
                for (auto& [y, n] : graph[current]) {
                    if (!seen[y]) {
                        parents[y] = current;
                        seen[y] = true;
                        q.push(y);
                    }
                }
            }
        }

        reverse(tour.begin(), tour.end());
        vector<vector<int>> dp(le);
        vector<pair<int, int>> ans_lst;
        vector<bool> seen_nodes(N, false);

        for (int x : tour) {
            for (auto& [y, n] : graph[x]) {
                if (y == parents[x]) continue;
                if (parents[y] == x && !dp[y].empty()) {
                    ans_lst.emplace_back(n, dp[y].back());
                    dp[y].pop_back();
                } else if (!seen_nodes[n]) {
                    dp[x].push_back(n);
                    seen_nodes[n] = true;
                }
            }
            while (dp[x].size() >= 2) {
                int a = dp[x].back(); dp[x].pop_back();
                int b = dp[x].back(); dp[x].pop_back();
                ans_lst.emplace_back(a, b);
            }
        }

        if ((int)ans_lst.size() * 2 == N) {
            cout << "Yes\n";
            for (auto& [i, j] : ans_lst) {
                cout << i + 1 << " " << j + 1 << "\n";
                assert(abs(i - j) == abs(A[i] - A[j]));
            }
        } else {
            cout << "No\n";
        }
    }

    return 0;
}