#include <bits/stdc++.h>
#define MAXN ((int) 1e5)
using namespace std;
typedef pair<int, int> pii;

int n, A[MAXN + 10];
vector<pii> ans;

int L, R;
unordered_map<int, int> mpL, mpR;

vector<int> e[MAXN * 2 + 10], v[MAXN * 2 + 10];
int deg[MAXN * 2 + 10], dep[MAXN * 2 + 10];
bool vis[MAXN * 2 + 10];

// BFS 用来统计连通块内边的数量
int bfs(int S) {
    int ret = 0;
    queue<int> q;
    q.push(S); vis[S] = true;
    while (!q.empty()) {
        int sn = q.front(); q.pop();
        ret += deg[sn];
        for (int fn : e[sn]) if (!vis[fn]) {
            q.push(fn);
            vis[fn] = true;
        }
    }
    return ret / 2;
}

// 返回还没有匹配的边
int dfs(int sn, int fa, int from, int d) {
    dep[sn] = d;
    vector<int> vec;
    for (int i = 0; i < e[sn].size(); i++) {
        int fn = e[sn][i], idx = v[sn][i];
        if (fn == fa) continue;
        // 把返祖边和子节点传上来的边都记录下来
        if (dep[fn] > 0) {
            if (dep[fn] < dep[sn]) vec.push_back(idx);
        } else {
            int t = dfs(fn, sn, idx, d + 1);
            if (t > 0) vec.push_back(t);
        }
    }

    // 把记录下来的边两两匹配
    while (vec.size() > 1) {
        int x = vec.back(); vec.pop_back();
        int y = vec.back(); vec.pop_back();
        ans.push_back(pii(x, y));
    }
    if (vec.size() == 1) {
        // 还剩一条边没匹配，把连向父节点的边也用来匹配
        assert(from > 0);
        ans.push_back(pii(vec.back(), from));
        return -1;
    } else {
        // 连向父节点的边交给父节点匹配
        return from;
    }
}

void solve() {
    mpL.clear(); mpR.clear();
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &A[i]);
        mpL[A[i] - i] = 0;
        mpR[A[i] + i] = 0;
    }
    // 离散化
    L = R = 0;
    for (auto it = mpL.begin(); it != mpL.end(); it++) it->second = ++L;
    for (auto it = mpR.begin(); it != mpR.end(); it++) it->second = ++R;

    // 建立二分图
    for (int i = 1; i <= n * 2; i++) e[i].clear(), v[i].clear();
    memset(deg, 0, sizeof(int) * (n * 2 + 3));
    for (int i = 1; i <= n; i++) {
        int x = mpL[A[i] - i], y = L + mpR[A[i] + i];
        e[x].push_back(y); v[x].push_back(i);
        e[y].push_back(x); v[y].push_back(i);
        deg[x]++;  deg[y]++;
    }

    ans.clear();
    memset(vis, 0, sizeof(bool) * (n * 2 + 3));
    memset(dep, 0, sizeof(int) * (n * 2 + 3));
    // 枚举每个连通块
    for (int i = 1; i <= L + R; i++) if (!vis[i]) {
        // 奇数条边则无解
        if (bfs(i) & 1) { printf("No\n"); return; }
        // 偶数条边则构造答案
        dfs(i, 0, -1, 1);
    }

    printf("Yes\n");
    for (pii p : ans) printf("%d %d\n", p.first, p.second);
}

int main() {
    int tcase; scanf("%d", &tcase);
    while (tcase--) solve();
    return 0;
}