#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    int n;
    std::cin >> n;
    
    std::vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
    }

    int cnt = n;
    std::vector<std::vector<int>> adj(n);
    std::map<int, int> mp;
    for (int i = 0; i < n; ++i) {
        int x = a[i] + i;
        if (!mp.count(x)) {
            mp[x] = cnt++;
            adj.emplace_back();
        }
        adj[i].push_back(mp[x]);
        adj[mp[x]].push_back(i);
    }
    mp.clear();
    for (int i = 0; i < n; ++i) {
        int x = a[i] - i;
        if (!mp.count(x)) {
            mp[x] = cnt++;
            adj.emplace_back();
        }
        adj[i].push_back(mp[x]);
        adj[mp[x]].push_back(i);
    }

    std::vector<bool> vis(cnt), ok(cnt);
    std::vector<int> f(cnt, -1);
    std::vector<std::pair<int, int>> ans;
    auto dfs = [&](auto self, int u, int fa) -> void {
        vis[u] = true;
        for (auto v : adj[u]) {
            if (v == fa || vis[v]) {
                continue;
            }
            self(self, v, u);
            if (v < n && !ok[v]) {
                if (f[u] == -1) {
                    f[u] = v;
                } else {
                    ok[f[u]] = ok[v] = true;
                    ans.emplace_back(f[u], v);
                    f[u] = -1;
                }
            } else if (f[v] != -1) {
                ok[f[v]] = ok[u] = true;
                ans.emplace_back(f[v], u);
                f[v] = -1;
            }
        }
    };
    for (int i = n; i < cnt; ++i) {
        if (!vis[i]) {
            dfs(dfs, i, -1);
            if (f[i] != -1) {
                std::cout << "No\n";
                return;
            }
        }
    }
    if (int(ans.size()) * 2 < n) {
        std::cout << "No\n";
        return;
    }

    std::cout << "Yes\n";
    for (auto [u, v] : ans) {
        std::cout << u + 1 << " " << v + 1 << "\n";
    }
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}