#include <cstdio>
#include <iostream>
#include <vector>
#define INF 2000000002
using namespace std;

vector<long long> ls[10];
long long dist[10];
long long cost[10][10];
int mark[10];
int N, M, X1, Y1, X2, Y2, X3, Y3, X4, Y4, X5, Y5, X6, Y6, C1, C2, C3;

long long abs(long long x)
{
    if (x > 0)
    {
        return x;
    }
    return -x;
}

void init()
{

    for(int i = 0; i < 10; i++)
    {
        ls[i].clear();
        mark[i] = 0;
        dist[i] = INF;
    }
    dist[1] = 0;
    for(int i = 0; i < 10; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            cost[i][j]= 0;
        }
    }
}

void dijkstra(int x)
{
    int current = x;
    mark[x] = 1;
    int minx = 0;
    long long minv = INF;
    for(int i = 0; i < ls[current].size(); i++)
    {
        if((mark[ls[current][i]] == 0) && (dist[ls[current][i]] > dist[current] + cost[current][ls[current][i]]))
        {
            dist[ls[current][i]] = dist[current] + cost[current][ls[current][i]];
        }
        if(mark[ls[current][i]] == 0)
        {
            if(minv > dist[ls[current][i]])
            {
                minv = dist[ls[current][i]];
                minx = ls[current][i];
            }
        }
    }
    if(minx > 0)
    {
        dijkstra(minx);
    }
}


int main()
{
    int T;
    freopen("portal3.in", "r", stdin);
    freopen("portal3.out", "w", stdout);
    scanf("%d", &T);
    for(int i = 0; i < T; i++)
    {
        scanf("%d %d", &N, &M);

        scanf("%d %d %d %d %d", &X1, &Y1, &X2, &Y2, &C1);
        scanf("%d %d %d %d %d", &X3, &Y3, &X4, &Y4, &C2);
        scanf("%d %d %d %d %d", &X5, &Y5, &X6, &Y6, &C3);
        /*cin>>N>>M;
        cin>>X1>>Y1>>X2>>Y2>>C1;
        cin>>X3>>Y3>>X4>>Y4>>C2;
        cin>>X5>>Y5>>X6>>Y6>>C3;*/

        init();

        ls[1].push_back(2);
        ls[1].push_back(3);
        ls[1].push_back(4);
        ls[1].push_back(5);
        ls[1].push_back(6);
        ls[1].push_back(7);
        ls[1].push_back(8);

        ls[2].push_back(3);
        ls[2].push_back(4);
        ls[2].push_back(5);
        ls[2].push_back(6);
        ls[2].push_back(7);
        ls[2].push_back(8);

        ls[3].push_back(2);
        ls[3].push_back(4);
        ls[3].push_back(5);
        ls[3].push_back(6);
        ls[3].push_back(7);
        ls[3].push_back(8);

        ls[4].push_back(2);
        ls[4].push_back(3);
        ls[4].push_back(5);
        ls[4].push_back(6);
        ls[4].push_back(7);
        ls[4].push_back(8);

        ls[5].push_back(2);
        ls[5].push_back(3);
        ls[5].push_back(4);
        ls[5].push_back(6);
        ls[5].push_back(7);
        ls[5].push_back(8);

        ls[6].push_back(2);
        ls[6].push_back(3);
        ls[6].push_back(4);
        ls[6].push_back(5);
        ls[6].push_back(7);
        ls[6].push_back(8);

        ls[7].push_back(2);
        ls[7].push_back(3);
        ls[7].push_back(4);
        ls[7].push_back(5);
        ls[7].push_back(6);
        ls[7].push_back(8);


        /*cost[1][2] = X1 - 1 + Y1 - 1;
        cost[1][3] = X2 - 1 + Y2 - 1;
        cost[1][4] = X3 - 1 + Y3 - 1;
        cost[1][5] = X4 - 1 + Y4 - 1;
        cost[1][6] = X5 - 1 + Y5 - 1;
        cost[1][7] = X6 - 1 + Y6 - 1;
        cost[1][8] = N - 1 + M - 1;*/

        cost[1][2] = X1 + Y1;
        cost[1][3] = X2 + Y2;
        cost[1][4] = X3 + Y3;
        cost[1][5] = X4 + Y4;
        cost[1][6] = X5 + Y5;
        cost[1][7] = X6 + Y6;
        cost[1][8] = N + M;

        cost[2][8] = N - X1 + M - Y1;
        cost[3][8] = N - X2 + M - Y2;
        cost[4][8] = N - X3 + M - Y3;
        cost[5][8] = N - X4 + M - Y4;
        cost[6][8] = N - X5 + M - Y5;
        cost[7][8] = N - X6 + M - Y6;

        cost[2][4] = abs(X3 - X1) + abs(Y3 - Y1);
        cost[2][5] = abs(X4 - X1) + abs(Y4 - Y1);
        cost[2][6] = abs(X5 - X1) + abs(Y5 - Y1);
        cost[2][7] = abs(X6 - X1) + abs(Y6 - Y1);

        cost[3][4] = abs(X3 - X2) + abs(Y3 - Y2);
        cost[3][5] = abs(X4 - X2) + abs(Y4 - Y2);
        cost[3][6] = abs(X5 - X2) + abs(Y5 - Y2);
        cost[3][7] = abs(X6 - X2) + abs(Y6 - Y2);

        cost[4][2] = abs(X1 - X3) + abs(Y1 - Y3);
        cost[4][3] = abs(X2 - X3) + abs(Y2 - Y3);
        cost[4][6] = abs(X5 - X3) + abs(Y5 - Y3);
        cost[4][7] = abs(X6 - X3) + abs(Y6 - Y3);

        cost[5][2] = abs(X1 - X4) + abs(Y1 - Y4);
        cost[5][3] = abs(X2 - X4) + abs(Y2 - Y4);
        cost[5][6] = abs(X5 - X4) + abs(Y5 - Y4);
        cost[5][7] = abs(X6 - X4) + abs(Y6 - Y4);

        cost[6][2] = abs(X1 - X5) + abs(Y1 - Y5);
        cost[6][3] = abs(X2 - X5) + abs(Y2 - Y5);
        cost[6][4] = abs(X3 - X5) + abs(Y3 - Y5);
        cost[6][5] = abs(X4 - X5) + abs(Y4 - Y5);

        cost[7][2] = abs(X1 - X6) + abs(Y1 - Y6);
        cost[7][3] = abs(X2 - X6) + abs(Y2 - Y6);
        cost[7][4] = abs(X3 - X6) + abs(Y3 - Y6);
        cost[7][5] = abs(X4 - X6) + abs(Y4 - Y6);

        cost[2][3] = abs(X2 - X1) + abs(Y2 - Y1);
        cost[4][5] = abs(X4 - X3) + abs(Y4 - Y3);
        cost[6][7] = abs(X6 - X5) + abs(Y6 - Y5);

        cost[3][2] = abs(X2 - X1) + abs(Y2 - Y1);
        cost[5][4] = abs(X4 - X3) + abs(Y4 - Y3);
        cost[7][6] = abs(X6 - X5) + abs(Y6 - Y5);

        if(C1 < cost[2][3])
        {
            cost[2][3] = C1;
            cost[3][2] = C1;
        }
        if(C2 < cost[4][5])
        {
            cost[4][5] = C2;
            cost[5][4] = C2;
        }
        if(C3 < cost[6][7])
        {
            cost[6][7] = C3;
            cost[7][6] = C3;
        }

        dijkstra(1);
        //printf("%lld\n", dist[8]);
        cout<<dist[8]<<endl;
    }
    return 0;
}