#include <iostream>
#include <vector>
#include <array>
#include <algorithm>
#include <cmath>
#include <tuple>
#include <list>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <climits>
#include <cfloat>
#include <set>
#include <map>
#include <queue>
#include <stdexcept>
#include <iomanip>
#include <unordered_map>

using namespace std;

// Shortcuts for common data types
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> pii;
typedef vector<pii> vii;
typedef vector<int> vi;

//Structs
struct graphInfo{
    unordered_map<int, int> parentMap;
    unordered_map<int, int> rankMap;
};

// Various
void printGraph(vector<vector<pair<int, float>>> graph);

double &dFS(vector<vector<pair<int, float>>> graph, int source, int target);

void printPath(vector<int> Parent, int target);

void printDist(vector<double> dists);

vector<tuple<int, int, float>> kruskal(vector<vector<pair<int, float>>> garph);

int parentFind(int u, unordered_map<int, int> parentMap);

graphInfo unionNodes(int u, int v, graphInfo gi);

#define rep(i, n) for(int i=0;i<(n);i++)
#define foreach(i, a) for(__typeof(a.begin()) i = a.begin(); i != a.end(); i++)
#define feq(x, y) (fabs(x-y) <= DBL_EPSILON)
#define min(a, b) ((a)<(b)?(a):(b))
#define max(a, b) ((a)>(b)?(a):(b))

// Bit operations
#define set_bit(x, i) (x) |= (1 << (i))
#define clr_bit(x, i) (x) & ~(1 << (i))
#define tog_bit(x, i) (x) ^= (1 << (i))
#define chk_bit(x, i) (((x) >> (i)) & 1)

// Quick scanning
#define sf(n)       scanf("%d", &n)
#define sff(a, b)    scanf("%d %d", &a, &b)
#define sfff(a, b, c) scanf("%d %d %d", &a, &b, &c)

// Useful constants
#define MOD 1000000007
#define INF ((int) 1e9)
#define EPS 1e-9

// Shortcuts for pair
#define x first
#define y second

// Debugging
#define DBUG(x)    std::cout<<#x<<" is "<<x<<"\n"


int main() {
    std::ios::sync_with_stdio(false); // Speedup (do not mix with scanf/prinf)
    std::cin.tie(NULL); // Speedup (do not mix with scanf/prinf)
    std::cout << std::fixed;
    std::cout << std::setprecision(2); //print as 1.1234

    int t, n, s;
    cin >> t;
    for (int test = 0; test < t; test++) {
        cin >> s >> n;
        int x[500] = {};
        int y[500] = {};
        for (int i = 0; i < n; i++) {
            cin >> x[i];
            cin >> y[i];
        }

        vector<vector<pair<int, float>>> graph(n);
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                float dist = sqrt(pow(x[i] - x[j], 2.0) + pow(y[i] - y[j], 2.0));
                graph[i].push_back(make_pair(j, dist));
                graph[j].push_back(make_pair(i, dist));
            }
        }
        vector<tuple<int, int, float>> mst = kruskal(graph);
        float ans = get<2>(mst[n - s - 1]);
        cout << ans << endl;
    }
    return 0;
}

vector<tuple<int, int, float>> kruskal(vector<vector<pair<int, float>>> graph) {
    vector<tuple<int, int, float>> allEdges;
    vector<pair<int, float >> neighbours;
    vector<tuple<int, int, float>> mst;
    for (int i = 0; i < graph.size(); i++) {
        neighbours = graph[i];
        for (int j = 0; j < neighbours.size(); j++) {
            allEdges.push_back(make_tuple(i, neighbours[j].first, neighbours[j].second));
        }
    }
    sort(begin(allEdges), end(allEdges),
         [](tuple<int, int, float> const &t1, tuple<int, int, float> const &t2) {
             return get<2>(t1) < get<2>(t2);
         }
    );
    /* for (int i=0; i<allEdges.size(); i++){
         cout << get<0> (allEdges[i])<< "\t" << get<1>(allEdges[i]) << "\t" << get<2>(allEdges[i]) << endl;
     }*/
    graphInfo gi;
    for (int i = 0; i < allEdges.size(); i++) {
        gi.parentMap[i] = i;
        gi.rankMap[i] = 0;
    }

    for (int i = 0, j=0;j<graph.size()-1 ; i += 2) {
        clock_t begin,beginOneUnion,stopOneUnion;
        begin = clock();
        int u = get<0>(allEdges[i]);
        int v = get<1>(allEdges[i]);
        if (parentFind(u, gi.parentMap) != parentFind(v, gi.parentMap)) {
            mst.push_back(allEdges[i]);
            beginOneUnion=clock();
            gi = unionNodes(u, v,gi);
            stopOneUnion=clock();
            j++;
            //cout << i <<"\t" << j<<endl;
        }
        clock_t end = clock();
        double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
        double elapsed_secsOneUnion = double(stopOneUnion - beginOneUnion) / CLOCKS_PER_SEC;
        //cout<<i<<"\t"<< elapsed_secs<<"/t"<<elapsed_secsOneUnion<<endl;
    }
    vector<tuple<int, int, float>>::const_iterator first = allEdges.begin();
    vector<tuple<int, int, float>>::const_iterator last = allEdges.begin() + graph.size();
    //vector<tuple<int, int, float>> mst(first, last);
    /*
    for (int i = 0; i < mst.size(); i++) {
        cout << get<0> (mst[i])<< "\t" << get<1>(mst[i]) << "\t" << get<2>(mst[i]) << endl;
    }*/
    return mst;
}

graphInfo unionNodes(int u, int v, graphInfo gi) {
    //unordered_map<int, int> parentMap=gi.parentMap;
    //unordered_map<int, int> rankMap=gi.rankMap;

    //clock_t begin1 = clock();
    int pu = parentFind(u, gi.parentMap);
    int pv = parentFind(v, gi.parentMap);
    //clock_t begin2 = clock();
    if (gi.rankMap[pu]<gi.rankMap[pv]) gi.parentMap[pu] = pv;
    else if(gi.rankMap[pv]<gi.rankMap[pu]) gi.parentMap[pv] =pu;
    else{
        if(rand()%2==0){
            gi.parentMap[pu]=pv;
            gi.rankMap[pv]++;
        } else{
            gi.parentMap[pv]=pu;
            gi.rankMap[pu]++;
        }
    }
    //clock_t end = clock();
    //double elapsed_secs1 = double(end - begin1) / CLOCKS_PER_SEC;
    //double elapsed_secs2 = double(end - begin2) / CLOCKS_PER_SEC;
    //cout<<elapsed_secs1<<"\t"<<elapsed_secs2<<endl;
    return gi;
}

//Tested, time =0.00
int parentFind(int u, unordered_map<int, int> parentMap) {
    while (u != parentMap[u]) u = parentMap[u];
    return u;
}

void printPath(vector<int> parent, int node) {
    if (parent[node] >= 0) {
        cout << "The parent of " << node << " is " << parent[node] << endl;
        printPath(parent, parent[node]);
    }
    return;
}