#include "bits/stdc++.h"

class vertex
{
public:
    int u;
    double w;

    vertex() = default;
    vertex(int _u, double _w) : u(_u), w(_w) {}

    bool operator>(const vertex &other) const
    {
        return w > other.w;
    }
};

const int maxn = 1e3 + 5;

std::vector<vertex> g[maxn];
double dis[maxn];
bool vis[maxn];

void dijkstra(int n, int s)
{
    memset(vis, false, sizeof(vis));

    for (int i = 0; i < n; i++)
    {
        dis[i] = 0xfffffff;
    }

    std::priority_queue<vertex, std::vector<vertex>, std::greater<vertex>> q;

    dis[s] = 0;
    q.push(vertex(s, 0));

    while (!q.empty())
    {
        int u = q.top().u;

        q.pop();

        if (vis[u])
            continue;

        vis[u] = true;

        for (auto it : g[u])
        {
            int v = it.u, w = it.w;

            if (dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                q.push(vertex(v, dis[v]));
            }
        }
    }
}

int x[maxn] = {0};
int y[maxn] = {0};

template <class T>
T min(T a, T b, T c)
{
    return ((a < b) ? ((a < c) ? a : c) : ((b < c) ? b : c));
}

template <class T>
T max(T a, T b, T c)
{
    return ((a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c));
}

int main()
{
    int n;
    std::cin >> n;

    while (n--)
    {
        int s, t, a, b;
        std::cin >> s >> t >> a >> b;

        for (int i = 0; i < 4 * s; i++)
        {
            g[i].clear();
        }

        for (int i = 0; i < s; i++)
        {
            int x1, x2, x3, y1, y2, y3, T;

            std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> T;

            int h = std::max(std::abs(y1 - y2), std::abs(y1 - y3));
            int w = std::max(std::abs(x1 - x2), std::abs(x1 - x3));
            double l = std::sqrt(h * h + w * w);

            x[4 * i] = min(x1, x2, x3);
            y[4 * i] = min(y1, y2, y3);

            x[4 * i + 1] = max(x1, x2, x3);
            y[4 * i + 1] = min(y1, y2, y3);

            x[4 * i + 2] = min(x1, x2, x3);
            x[4 * i + 2] = max(y1, y2, y3);

            x[4 * i + 3] = max(x1, x2, x3);
            x[4 * i + 3] = max(y1, y2, y3);

            // 城市内连线
            // 4i 左下角
            // 4i + 1 右下角
            // 4i + 2 左上角
            // 4i + 3 右上角
            g[4 * i].push_back(vertex(4 * i + 1, w * T));
            g[4 * i].push_back(vertex(4 * i + 2, h * T));
            g[4 * i].push_back(vertex(4 * i + 3, l * T));

            g[4 * i + 1].push_back(vertex(4 * i, w * T));
            g[4 * i + 1].push_back(vertex(4 * i + 2, l * T));
            g[4 * i + 1].push_back(vertex(4 * i + 3, h * T));

            g[4 * i + 2].push_back(vertex(4 * i, h * T));
            g[4 * i + 2].push_back(vertex(4 * i + 1, l * T));
            g[4 * i + 2].push_back(vertex(4 * i + 3, w * T));

            g[4 * i + 3].push_back(vertex(4 * i, l * T));
            g[4 * i + 3].push_back(vertex(4 * i + 2, w * T));
            g[4 * i + 3].push_back(vertex(4 * i + 1, h * T));
        }

        // 城市间连接
        for (int s1 = 0; s1 < s; s1++)
        {
            for (int s2 = 0; s2 < s; s2++)
            {
                if (s1 == s2)
                    continue;

                for (int a = 0; a < 4; a++)
                {
                    for (int b = 0; b < 4; b++)
                    {
                        int pa = 4 * s1 + a, pb = 4 * s2 + b;

                        g[pa].push_back(vertex(pb, std::sqrt(std::pow(x[pa] - x[pb], 2) + std::pow(y[pa] - y[pb], 2)) * t));
                    }
                }
            }
        }

        double min = 0xfffffff;

        for (int i = 0; i < 4; i++)
        {
            dijkstra(4 * s, 4 * (a - 1) + i);

            for (int j = 0; j < 4; j++)
            {
                min = std::min(min, dis[4 * (b - 1) + j]);
            }
        }

        std::cout << std::fixed << std::setprecision(1) << min;
    }

    return 0;
}