#include <iostream>
#include <queue>
#include <cmath>
#include <iomanip>
#include <fstream>
using namespace std;

struct dot
{
    int x;
    int y;
};

struct center_status
{
    double x;
    int status;
};

void simpleSort(center_status* states, int l, int r)
{
    center_status buff;
    int j;

    for (int i = l + 1; i < r + 1; ++i)
    {
        j = i;
        while (j > l && states[j - 1].x > states[j].x)
        {
            buff = states[j - 1];
            states[j - 1] = states[j];
            states[j] = buff;
            j--;
        }
    }
}

void merge(center_status* states, int l, int mid, int r)
{
    int ls = 0, rs = 0;
    center_status result[r - l + 1];


    while ((l + ls < mid + 1) && (mid + rs < r))
    {
        if (states[l + ls].x < states[mid + rs + 1].x)
        {
            result[ls + rs] = states[l + ls];
            ls++;
        }
        else
        {
            result[ls + rs] = states[mid + 1 + rs];
            rs++;
        }
    }


    while (l + ls < mid + 1)
    {
        result[ls + rs] = states[l + ls];
        ls++;
    }

    while (mid + rs < r)
    {
        result[ls + rs] = states[mid + rs + 1];
        rs++;
    }

    for (int i = 0; i < ls + rs; ++i)
        states[l + i] = result[i];
}

void mergeSort(center_status* states, int l, int r)
{
    if (r - l <= 1)
        return;

    if (r - l < 12)
    {
        simpleSort(states, l, r);
        return;
    }

    int mid = (l + r) / 2;
    mergeSort(states, l, mid);
    mergeSort(states, mid + 1, r);
    merge(states, l, mid, r);
}

bool is_contain_k(double radius, dot* dots, int n, int k)
{
    double eps = 1e-6;
    double offset;
    center_status states[2 * n];

    for (int i = 0; i < n; ++i)
    {
        if (abs(dots[i].y) < radius)
        {
            offset = sqrt(radius * radius - dots[i].y * dots[i].y);
            states[2 * i].x = dots[i].x - offset - eps * (i + 1);
            states[2 * i].status = 1;
            states[2 * i + 1].x = dots[i].x + offset + eps * (i + 1);
            states[2 * i + 1].status = 0;
        }
        else
        {
            states[2 * i].x = 0;
            states[2 * i].status = 2;
            states[2 * i + 1].x = 0;
            states[2 * i + 1].status = 2;
        }
    }

    mergeSort(states, 0, 2 * n - 1);

    /*
    for (int i = 0; i < 2 * n; ++i)
    {
        cout << states[i].x << " ";
    }
    cout << endl;
    cout << endl;
    */

    int curr_count = 0;
    int max_count = 0;
    for (int i = 0; i < 2 * n; ++i)
    {
        if (states[i].status == 1)
        {

            curr_count++;

            if (curr_count > max_count)
                max_count = curr_count;
        }
        if (states[i].status == 0)
        {
            curr_count--;
        }
    }

    if (max_count >= k)
        return true;
    return false;
}

double binary_search(dot* dots, int n, int k)
{
    double max_r = 1420;
    double min_r = 0;
    double radius;

    while (max_r - min_r > 1e-4)
    {
        radius = (max_r + min_r) / 2;

        if (is_contain_k(radius, dots, n, k))
            max_r = radius;
        else
            min_r = radius;
    }
    return max_r;
}

int main()
{
    int n, k;
    double res;
    int count_tests;


    ifstream ifs("123.txt");
    ifs >> count_tests;

    ofstream out("results.txt");
    for (int i = 0; i < count_tests; ++i)
    {

        ifs >> n;
        ifs >> k;
        dot dots[n] = {};

        for (int i = 0; i < n; ++i)
        {
            ifs >> dots[i].x;
            ifs >> dots[i].y;
            cout << dots[i].x << " " << dots[i].y << " \n";
        }


        res = binary_search(dots, n, k);
        std::cout << std::setprecision(7) << res;
        out << std::setprecision(7) << res;
        out << '\n';
    }
    return 0;
}