//#ifdef DEBUG
//#define _GLIBCXX_DEBUG
//#endif
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;

#define pb push_back

typedef long long ll;
typedef long double ld;
const int infinity = 1e9;
struct DinitzFlow{
    struct Edge {
        int src, dst, cap, flow;
        Edge() {
        }
        Edge(int src, int dst, int cap, int flow)
                : src(src), dst(dst), cap(cap), flow(flow) {
        }
    };
    int n, s, t;
    vector<Edge> edges;
    vector< vector<int> > g;
    vector<int> layer;
    vector<int> ptr;
    inline bool bfs() {
        layer.assign(n, -1);
        queue<int> q;
        layer[s] = 0;
        q.push(s);
        while (!q.empty() && layer[t] < 0) {
            int v = q.front(); q.pop();
            for (int eid: g[v]) {
                int to = edges[eid].dst;
                if (edges[eid].cap > edges[eid].flow) {
                    if (layer[to] < 0) {
                        layer[to] = layer[v] + 1;
                        q.push(to);
                    }
                }
            }
        }
        return layer[t] >= 0;
    }
    int dfs(int v, int flow = infinity) {
        if (v == t) {
            return flow;
        }
        if (flow == 0) {
            return 0;
        }
        for (; ptr[v] < (int)g[v].size(); ptr[v]++) {
            int eid = g[v][ptr[v]];
            int to = edges[eid].dst;
            if (layer[to] == layer[v] + 1) {
                int can = edges[eid].cap - edges[eid].flow;
                int pushed = dfs(to, min(flow, can));
                if (pushed > 0) {
                    edges[eid].flow += pushed;
                    edges[eid^1].flow -= pushed;
                    return pushed;
                }
            }
        }
        return 0;
    }
    inline void changeSrcDst(int ns, int nt) {
        s = ns; t = nt;
        for (Edge &e : edges) {
            e.flow = 0;
        }
    }
    inline vector<char> getCut() {
        // side[i] = 1 if the vertex is in component of s after the cut
        // side[i] = 0 otherwise (even if the vertex is not in component of t)
        vector<char> side(n, 0);
        function<void(int)> dfs = [&](int v) {
            if (side[v]) {
                return;
            }
            side[v] = 1;
            for (int eid : g[v]) {
                if (edges[eid].cap == edges[eid].flow) {
                    continue;
                }
                dfs(edges[eid].dst);
            }
        };
        dfs(s);
        return side;
    }
    inline int flow() {
        int ans = 0;
        while (bfs()) {
            ptr.assign(n, 0);
            int pushed = dfs(s);
            while (pushed != 0) {
                ans += pushed;
                pushed = dfs(s);
            }
        }
        return ans;
    }
    inline void addEdge(int src, int dst, int cap) {
        g[src].push_back(edges.size());
        edges.emplace_back(src, dst, cap, 0);
        g[dst].push_back(edges.size());
        edges.emplace_back(dst, src, 0, 0);
    }
    DinitzFlow(int n, int s, int t)
            : n(n), s(s), t(t), g(n), layer(n), ptr(n) {
    }
};
int n;
const int maxN = 305;
int a[maxN][maxN];
int e[maxN][maxN];
int p[maxN];
int sz[maxN];
int get(int x) {
    if (x == p[x]) return x;
    return p[x] = get(p[x]);
}
void unite(int a, int b) {
    a = get(a);
    b = get(b);
    if (a == b) return;
    p[b] = a;
    sz[a] += sz[b];
}
int id[305];
bool OK = true;
void add_e(int a, int b) {
    assert(a != b);
    e[a][b] = e[b][a] = 1;
}
void solve(vector<int> v, int k) {
    if (v.size() == 1) return;
    for (int& x : v) {
        p[x] = x;
    }
    for (int x = 0; x < v.size(); x++) {
        for (int y = x + 1; y < v.size(); y++) {
            if (a[v[x]][v[y]] > k) {
                unite(v[x], v[y]);
            }
        }
    }
    vector<vector<int>> S(v.size());
    for (int x = 0; x < v.size(); x++) id[v[x]] = x;
    for (int x = 0; x < v.size(); x++) {
        S[id[get(v[x])]].emplace_back(v[x]);
    }
    for (int x = 0; x < v.size(); x++) {
        for (int y = x + 1; y < v.size(); y++) {
            if (a[v[x]][v[y]] < k) {
                OK = false;
                return;
            }
            if ((a[v[x]][v[y]] > k) != (get(v[x]) == get(v[y]))) {
                OK = false;
                return;
            }
        }
    }
    if (k == 0) {
        for (auto& it : S) {
            if (!it.empty()) {
                solve(it, 1);
            }
        }
    }
    else if (k == 1) {
        int lst = -1;
        for (auto& it : S) {
            if (!it.empty()) {
                if (lst != -1) {
                    e[lst][it.back()] = e[it.back()][lst] = 1;
                }
                solve(it, 2);
                lst = it.back();
            }
        }
    }
    else {
        //k = 2
//        cout << " hi " << k << endl;
        assert(k == 2);
        vector<vector<int>> vecs;
        for (int x = 0; x < v.size(); x++) {
            if (!S[x].empty()) vecs.emplace_back(S[x]);
        }
        sort(vecs.begin(), vecs.end(), [&](vector<int>& a, vector<int>& b) {
           return a.size() < b.size();
        });
        for (int x = 0; x < vecs.size(); x++) {
            if (vecs[x].size() == 2 || vecs[x].size() == 3) {
                for (int& a : vecs[x]) {
                    for (int& b : vecs[x]) {
                        if (a < b) add_e(a, b);
                    }
                }
            }
            if (vecs[x].size() >= 4) {
                for (int a = 0; a + 2 < (int)vecs[x].size(); a++) {
                    add_e(vecs[x][a], vecs[x][a + 1]);
                }
                add_e(vecs[x][0], vecs[x][vecs[x].size() - 2]);
                for (int a = 0; a + 1 < vecs[x].size(); a++) {
                    add_e(vecs[x][a], vecs[x].back());
                }
            }
        }
        bool has_23 = false;
        for (auto& it : vecs) {
            if (it.size() == 2 || it.size() == 3) has_23 = true;
        }
        if (!has_23) {
            if (vecs.size() == 2 && vecs[0].size() == 1 && vecs[1].size() == 1) {
                OK = false;
                return;
            }
            if ((int)vecs.size() > 1) {
                for (int x = 0; x < vecs.size(); x++) {
                    e[vecs[x][0]][vecs[x].back()] = e[vecs[x].back()][vecs[x][0]] = 0;
                    add_e(vecs[x][0], vecs[(x + 1) % vecs.size()].back());
                }
            }
            return;
        }
        if (vecs.size() <= 2) {
            OK = false;
            return;
        }
        for (int x = 2; x < vecs.size(); x++) {
            if ((int)vecs[x].size() >= 4) {
                if (vecs[0].size() == 2 || vecs[0].size() == 3) {
                    swap(vecs[0], vecs[x]);
                }
                else if (vecs[1].size() == 2 || vecs[1].size() == 3){
                    swap(vecs[1], vecs[x]);
                }
            }
        }
        if (vecs[0].size() == 2 || vecs[0].size() == 3 || vecs[1].size() == 2 || vecs[1].size() == 3) {
            OK = false;
            return;
        }
        vector<int> UP{vecs[0][0]};
        vector<int> DOWN{vecs[0][0]};
        for (int x = 2; x < vecs.size(); x++) {
            if (vecs[x].size() == 2) {
                UP.emplace_back(vecs[x][0]);
                DOWN.emplace_back(vecs[x][1]);
            }
            else if (vecs[x].size() == 3) {
                UP.emplace_back(vecs[x][0]);
                UP.emplace_back(vecs[x][1]);
                DOWN.emplace_back(vecs[x][2]);
            }
        }
        UP.emplace_back(vecs[1][0]);
        DOWN.emplace_back(vecs[1][0]);
        for (auto& it : {UP, DOWN}) {
            for (int z = 0; z + 1 < (int)it.size(); z++) add_e(it[z], it[z + 1]);
        }
        assert(UP.size() >= 2);
        int x = UP[0];
        int y = UP[1];
        for (int t = 2; t < vecs.size(); t++) {
            if ((int)vecs[t].size() >= 4 || (int)vecs[t].size() == 1) {
                e[x][y] = 0;
                e[y][x] = 0;
                add_e(vecs[t][0], x);
                add_e(vecs[t][0], y);
                x = vecs[t][0];
            }
        }
    }
}
mt19937 rnd(228);
void solve() {
    cin >> n;
//    n = rnd() % 4 + 1;
    bool ok = true;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> a[i][j];
//            a[i][j] = rnd() % 4;
//            if (i == j) a[i][j] = 0;
//            if (i > j) a[i][j] = a[j][i];
            e[i][j] = 0;
            if ((i == j) && a[i][j] != 0) {
                ok = false;
                continue;
            }
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (a[i][j] != a[j][i]) {
                ok = false;
            }
        }
    }
    if (!ok) {
        cout << "No\n";
        return;
    }
    OK = true;
    vector<int> F(n);
    iota(F.begin(), F.end(), 0);
    solve(F, 0);
    if (!OK) {
        cout << "No\n";
        return;
    }
    vector<pair<int,int>> ans;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (e[i][j]) {
                ans.emplace_back(i + 1, j + 1);
            }
        }
    }
    cout << "Yes\n";
    cout << ans.size() << '\n';
    /*for (int x = 0; x < n; x++) {
        for (int y = x + 1; y < n; y++) {
            DinitzFlow ds(n, x, y);
            for (auto& it : ans) {
                ds.addEdge(it.first - 1, it.second - 1, 1);
                ds.addEdge(it.second - 1, it.first - 1, 1);
            }
            if (ds.flow() != a[x][y]) {
                assert(false);
            }

        }
    }*/
    for (auto& it : ans) {
        cout << it.first << " " << it.second << '\n';
    }
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
#endif
    int tst = 10000;
    cin >> tst;
    while (tst--) {
        solve();
    }
    return 0;
}