#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ulli;
#define F(i, n, m) for (int i = n; i <= m; i++)

inline int read() {
    bool w = 0;
    int s = 0;
    char ch = 0;
    while (!isdigit(ch)) w = ch == '-', ch = getchar();
    while (isdigit(ch)) s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
    return w ? -s : s;
}

inline void write(int x) {
    if (x < 0)
        putchar('-'), x = ~x + 1;
    if (x > 9)
        write(x / 10);
    putchar((x % 10) | 48);
}

class Edge {
public:
    int be, ed, co;
    Edge(int i, int j, int k) : be(i), ed(j), co(k){};
    Edge(){};
    friend bool operator>(const Edge &E, const Edge &F) { return E.co > F.co; }
};

int be[500010], n, m;
vector<Edge> edges;

int index(int i, int j);
int kruskal(int n);
int find(int x);

int main() {
    int h, ans;
    for (int t = read(); t; t--) {
        edges.clear();
        ans = 0;
        n = read();
        m = read();
        F(i, 1, n) {
            F(j, 1, m) {
                h = read();
                if (i != n) {
                    ans += h;
                    edges.push_back(Edge(index(i, j), index(i + 1, j), h));
                }
                h = read();
                if (j != m) {
                    ans += h;
                    edges.push_back(Edge(index(i, j), index(i, j + 1), h));
                }
            }
        }
        write(ans - kruskal(index(n, m)));
        printf("\n");
    }
    return 0;
}

inline int index(int a, int b) { return (a - 1) * m + b; }

int kruskal(int n) {
    F(i, 1, n)
    be[i] = i;
    sort(edges.begin(), edges.end(), greater<Edge>());
    int all = 0, ans = 0;
    Edge e;
    F(i, 0, edges.size() - 1) {
        e = edges[i];
        if (find(e.be) != find(e.ed)) {
            all++;
            ans += e.co;
            be[be[e.be]] = be[e.ed];
            if (all == n - 1)
                break;
        }
    }
    return ans;
}

int find(int x) {
    if (be[x] == x)
        return x;
    be[x] = find(be[x]);
    return be[x];
}